go基础元素与结构的使用，快速上手

编译go文件

编译为可执行文件
go build +文件名.go运行文件
./文件名

输入/输出

引用fmt库（关于输入输出的库）

输入

**scanf：**按照给定的格式依次读取数据（包括非法数据），不能换行输入（如果要换行需要在前面加一个scanln吸收掉回车符，就像c语言中的getchar）
**scan：**比scanf高级，依次读取数据，遇到回车会忽略，可以换行输入（如果要先用了scan输入，再用scanf输入的话，需要在中间加一个scanln）
scanln：类似scan，但是遇到换行（回车）立马结束输入，如果要换行输入必须用多个scanln

package main
import ("fmt"
)
func main() {var a intvar b stringfmt.Printf("place input a: ")fmt.Scanf("%d  %s", &a, &b)i := 0for i < a {fmt.Println(i)i++}fmt.Println(b)
}

输出

print与println与printf

Print: 输出到控制台(不接受任何格式化，它等价于对每一个操作数都应用 %v)
fmt.Print(str)
Println: 输出到控制台并换行
fmt.Println(tmp)
Printf : 只可以打印出格式化的字符串。只可以直接输出字符串类型的变量（不可以输出整形变量和整形 等）

如果是使用"Print"或"Println"函数的话**，可以不需要格式化字符串。**也就是说"Print"或"Println"是已经封装好的printf，他们会帮你自动格式化这些函数会针对数据类型 自动作转换。

“Print"函数默认将每个参数以”%v"格式输出，

"Println"函数则是在"Print"函数 的输出基础上增加一个换

printf中的使用的格式化字符串

%v	按值的本来值输出
%+v	在 %v 基础上，对结构体字段名和值进行展开
%#v	输出 Go 语言语法格式的值
%T	输出 Go 语言语法格式的类型和值
%%	输出 % 本体
%b	整型以二进制方式显示
%o	整型以八进制方式显示
%d	整型以十进制方式显示
%x	整型以十六进制方式显示
%X	整型以十六进制、字母大写方式显示
%U	Unicode 字符
%f	浮点数
%p	指针，十六进制方式显示

选择结构

if-else

if condition1 {// do something 
} else if condition2 {// do something else    
} else {// catch-all or default
}

实例使用

package main
import "fmt"
func main() {var a int = 100if a > 100 {fmt.Printf("a > 100")} else if a >= 50 && a <= 100 {fmt.Printf("a > 50 and a < 100")} else {fmt.Printf("a is nonono !!!")}
}

switch case

switch var1 {case val1:...case val2:...default:...
}

go中的switch case 相对于 c++中的switch case 来说，

1、变量 var1 可以是任何类型，而 val1 和 val2 则可以是同类型的任意值。类型不被局限于常量或整数，但必须是相同的类型；或者最终结果为相同类型的表达式。前花括号 { 必须和 switch 关键字在同一行。

2、可以同时测试多个可能符合条件的值，使用逗号分割它们，例如：case val1, val2, val3。

3、 （ Go 语言使用快速的查找算法来测试 switch 条件与 case 分支的匹配情况，直到算法匹配到某个 case 或者进入 default 条件为止。）一旦成功地匹配到某个分支，在执行完相应代码后就会退出，整个 switch 代码块不需要特别使用 break 语句来表示结束。

实例代码：

package main
import ("fmt"
)
func main() {var a intfor true {fmt.Printf("place input a: ")fmt.Scanf("%d", &a)switch a {case 1, 5, 6, 7:fmt.Println("this is 1")case 2:fmt.Println("this is 2")case 3:fmt.Println("this is 3")case 4:fmt.Println("exit")returndefault:fmt.Println("this is not 1,2,3,4")}}
}

循环结构

go中只用一个循环关键字，for，没有while，而是使用for进行通吃。

for有四种写法，对应着不同的使用：

类c/c++中的for：

for init; condition; post { }

实例代码：

package main
import ("fmt"
)
func main() {var a intfmt.Printf("place input a: ")fmt.Scanf("%d", &a)for i := 0; i < a; i++ {fmt.Println(i, "\n")}
}

类c/c++中的while语句：

for condition { }

实例代码：

package main
import ("fmt"
)
func main() {var a intfmt.Printf("place input a: ")fmt.Scanf("%d", &a)i := 0for i < a {fmt.Println(i, "\n")i++}}

类似while(1)

for {}for true{
}

这样将直接执行一个死循环

**range 格式**

for key, value := range oldMap {newMap[key] = value
}

数组

下面是一些示例，说明在Go语言中如何声明和使用数组：

（1） 声明和初始化一个数组：

**var** a [5]**int**         *// 声明一个长度为5的int类型数组*    
a = [5]**int**{1, 2, 3}  *// 将前三个元素初始化为1、2、3，后两个元素默认为0*
b **:=** [5]**int**{1, 2, 3, 4, 5} *//直接初始化并赋值*

（2） 访问数组元素：

x **:=** a[0]    *// 访问第一个元素*    
a[2] = 10    *// 修改第三个元素*

（3） 循环遍历数组：

**func** **sum**(a [5]**int**) **int** {s **:=** 0**for** i **:=** 0; i < len(a); i**++** {s **+=** a[i]}**return** s}
x **:=** **sum**([5]**int**{1, 2, 3, 4, 5})

（4） 数组作为函数参数传递:

**func** **sum**(a [5]**int**) **int** {s **:=** 0**for** i **:=** 0; i < len(a); i**++** {s **+=** a[i]}**return** s}
x **:=** **sum**([5]**int**{1, 2, 3, 4, 5})

（5）多维数组：

**var** a [3][3]**int**     *// 声明一个3x3的二维数组*    
a[0][0] = 1         *// 访问第一个元素*

函数

声明格式：

func functionName(parameter1 type, parameter2 type) returnType {// 函数体
}

• 函数声明：关键字 func
• functionName 代表是函数的名称，函数名由字母、数字、下划线组成。但函数名的第一个字母不能是数字。在同一个包内，函数名称不能重名。

parameter1 和 parameter2 代表是函数的参数，type 是参数的类型。参数由参数变量和参数变量的类型组成，参数变量可以省略，可以有一个参数，也可以有多个，也可以没有；多个参数之间使用,分隔；多个参数时参数变量要么全写，要么全省略；如果多个相邻参数的类型是一样的，可以只保留同一类型最后一个参数的声明

不同参数的使用

(1) 单个参数：

**func** **functionName**(parameterName parameterType) {*// 函数体*
}

这是函数接受单个参数的基本形式。parameterName是参数的名称，parameterType是参数的类型。

(2) 多个参数：

**func** **functionName**(parameter1Name parameter1Type, parameter2Name parameter2Type) {*// 函数体*
}

如果函数需要接受多个参数，可以在函数声明中依次列出参数的名称和类型。

(3) 可变参数（Variadic parameters）：

**func** **functionName**(parameterName **...**parameterType) {*// 函数体*
}

可变参数允许函数接受不定数量的参数。在参数类型之前使用…来指示可变参数的形式。在函数体内，可变参数被当作切片类型来处理。

(4) 参数命名和类型省略：

**func** **functionName**(parameter1, parameter2 **int**) {*// 函数体*
}

在函数定义中，如果多个参数具有相同的类型，可以省略参数类型，并在最后一个参数上指定类型。这种情况下，所有的参数都将具有相同的类型。

(5) 匿名参数：

**func** **functionName**(**int**, **string**) {*// 函数体*
}

在函数定义中，如果不需要使用参数的值，可以将参数名称省略，只保留参数类型。这种形式的参数被称为匿名参数。

• returnType 是函数的返回值类型。返回值由返回值变量和其变量类型组成，返回值变量可以省略，可以有一个返回值，也可以有多个，也可以没有；多个返回值必须用()包裹，并用,分隔；多个返回值时返回值变量要么全写，要么全省略。下面列举返回类型的不同定义方式：

不同返回值的使用

(1) 单个返回值：

**func** **functionName**() returnType {*// 函数体***return** value
}

这是函数返回单个值的基本形式。returnType是返回值的类型，value是要返回的具体值。

（2）多个返回值：

**func** **functionName**() (returnType1, returnType2) {*// 函数体***return** value1, value2
}

如果函数需要返回多个值，可以在函数声明中使用括号将多个返回值类型括起来，并在函数体内使用逗号分隔返回的具体值。

（3 命名返回值：

**func** **functionName**() (returnValue1 returnType1, returnValue2 returnType2) {*// 函数体*returnValue1 = value1returnValue2 = value2**return**}

可以为返回值命名，通过在函数声明中为返回值指定名称和类型。在函数体内，可以直接为这些命名返回值赋值，并在最后使用return关键字返回结果。

（4）空返回值：

如果函数没有返回值，可以省略返回值的类型和具体值，只使用return关键字。

**func** **functionName**() {*// 函数体***return**}

结构体

结构体的基本方法：

type MyStruct struct {// 结构体字段Field1 Type1变量名 + 类型// ...
}

基本的赋值操作

使用 var 声明变量

var p1 people
p1.Name = "zq"
p1.Age = 18
p1.Address = "杭州"

使用语法糖定义变量

p2 := people{Name: "zq",Age:   20,Address: "北京",
//变量 + ： + 数据
}

初始化结构体

初始化一个结构体实例（一个结构体字面量：struct-literal）的更简短和惯用的方式如下：ms := &struct1{10, 15.5, "Chris"}// 此时ms的类型是 *struct1
或者：var ms struct1ms = struct1{10, 15.5, "Chris"}

实际应用

package main
import "fmt"
type struct1 struct {i1  intf1  float32str string
}
func main() {ms := new(struct1)ms.i1 = 10ms.f1 = 15.5ms.str= "Chris"fmt.Printf("The int is: %d\n", ms.i1)fmt.Printf("The float is: %f\n", ms.f1)fmt.Printf("The string is: %s\n", ms.str)fmt.Println(ms)
}

切片

切片就类似与c++中的STL中vector,是一个动态数组，它长度是不固定的，可以追加元素，在追加时可能使切片的容量增大， 但是需要注意的是切片是引用类型，例如：当你将一个切片赋值给另一个切片时，它们将引用同一个底层数组。如果一个切片被修改，另一个引用该底层数组的切片也会受到影响。

切片的声明

直接声明切片：

var slice []T

T 是切片中元素的类型。例如，[]int 表示一个整数类型的切片，[]string 表示一个字符串类型的切片。
使用make来进行声明指定类型，长度，与容量

var slice1 []type = make([]type, len，capacity)也可以简写为
slice := make([]T, length, capacity)

对切片的基本操作

对于访问与修改元素

• 可以使用索引访问切片中的元素：

  a := slice[4]

• 也可以使用索引修改切片中的元素：

  slice[4] = 87
  

**获取切片的长度（**元素个数）：

length := len(slice)

获取切片的容量（底层数组可容纳的元素个数）：

capacity := cap(slice)

切片的切割：

获取原切片的一个子切片：

newSlice := slice[start:end]  // 包含 start 索引，不包含 end 索引myslice := slice[1: 5]   //得到slice[1],slice[2],slice[3],slice[4]

如果省略 start，则表示从切片的开头开始切割：

newSlice := slice[:end]  // 从开头切割到 end 索引（不包含 end）

如果省略 end，则表示从切片的 start 索引开始切割到末尾：

newSlice := slice[start:]  // 从 start 索引开始切割到末尾

切片的追加：

使用 append() 函数向切片末尾追加一个或多个元素：

slice = append(slice, element1, element2, ...)

切片的复制：

使用 copy() 函数将一个切片的内容复制到另一个切片：

copy(destSlice, srcSlice)

遍历切片：

使用 for range 循环遍历切片中的元素：

for index, value := range slice {// 使用 index 和 value}

index 是一个整数类型的变量，用于表示当前元素的索引。

value 是切片中当前元素的值。

slice 是要遍历的切片。

在每次循环中，会自动得到下一个索引与值，给予index与value，这样我们就能对其进行操作了

对于其是直接赋值给了index与value的因此如果我们直接对value进行修改是不会对我们的value的值发送改变的。

如果我们要直接进行修改,直接通过索引访问到指定的元素即可

package mainimport "fmt"func main() {numbers := []int{1, 2, 3, 4, 5}for index := range numbers {if index == 0 {numbers[index] = 10}}fmt.Println(numbers)
}

参考

Go 语言切片(Slice) | 菜鸟教程 (runoob.com)