基础语法·

定义变量·

1
2
3
4
5
6
7
8
9
10
11
12
13
var name string   //定义字符变量：name
var age int = 18  

var a, b *int    // 定义a,b两个指针
var (
	age int
	name string
)

b := "world"     //将"world"赋值给变量 b，并自动判断类型；b 必须为新变量

//交换变量
a, b = b, a

iota·

1
2
3
4
5
6
7
8
//在常量声明中，iota 的值从 0 开始，每次在下一个常量声明中递增 1
const (
	Apple = iota 	// 0
	Banana       	// 1
	Cherry       	// 2
    a = "aaa" 		// 3
    b = iota		// 4
)

数组·

1
2
3
4
5
var arrayName [size]dataType //声明数组
var numbers = [5]int{1, 2, 3, 4, 5}

//如果数组长度不确定，可以使用...代替数组的长度，编译器会根据元素个数自行推断数组的长度
balance := [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

切片(slice)·

Go 语言切片是对数组的抽象。

Go 数组的长度不可改变，在特定场景中这样的集合就不太适用，Go 中提供了一种灵活，功能强悍的内置类型切片(“动态数组”)，与数组相比切片的长度是不固定的，可以追加元素，在追加时可能使切片的容量增大。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
定义切片
var slice1 []type = make([]type, len)

var slice = [][]int{}   // 声明 空二维切片
切片初始化
s := []int {1,2,3 } 
s := arr[:] 
内容截取
 s[a:b]      		//对应的范围是 [a,b)

元素追加
	//执行 append 操作时，只会在长度末尾进行追加
 s := make([]int,5)
    for i := 0; i < 5; i++{
       s = append(s, i)
    }
    // 结果为： s: [0,0,0,0,0,0,1,2,3,4]
	//尾部加上其他切片需要使用 ... 运算符来辅助解构切片
	AB := append(A,B...)
切片拷贝

引用传递:切片当做函数参数的时候，函数内更改切片时，共享其底层数组的其他切片也会受到影响。这是因为切片本身并不存储实际的元素数据，而是指向底层数组的指针

如果不想影响到其他切片的数据，最好在函数内部使用 append 函数生成一个新的，不与参数切片共享底层数组的切片。

1
2
3
4
5
6
7
8
9
10
func modifySlice(s []int) {
	s[0] = 100				//影响
	s = append(s, 200)      //不影响
}
func main() {
	arr := []int{1, 2, 3}
	fmt.Println("Before:", arr) // 输出: [1 2 3]

	modifySlice(arr)
	fmt.Println("After:", arr) // 输出: [100 2 3]

未完待续…·