Go语言变量学习

Go语言变量学习

1. 简单类型

空值：nil

整型类型： int(取决于操作系统), int8, int16, int32, int64, uint8, uint16, …

浮点数类型：float32, float64

字节类型：byte (等价于uint8)

字符串类型：string

布尔值类型：boolean，(true 或 false)dd

var a int8 = 10
var c1 
byte = 'a'
var b 
float32 = 12.2
var msg = "Hello World"
ok := false`

2. 字符串

在 Go 语言中，字符串使用 UTF8 编码，UTF8 的好处在于，如果基本是英文，每个字符占 1 byte，和 ASCII 编码是一样的，非常节省空间，如果是中文，一般占3字节。包含中文的字符串的处理方式与纯 ASCII 码构成的字符串有点区别。

我们看下面的例子：

package main
import (    "fmt"    "reflect")
func main() {
	str1 := "Golang"
	str2 := "Go语言"
	fmt.Println(reflect.TypeOf(str2[2]).Kind()) //uint8    
	fmt.Println(str1[2], string(str1[2]))       //108 l    
	fmt.Printf("%d %c\n", str2[2], str2[2])     // 232 è    
	fmt.Println("len(str2)：", len(str2))        // len(str2)： 8}
}

• reflect.TypeOf().Kind() 可以知道某个变量的类型，我们可以看到，字符串是以 byte 数组形式保存的，类型是 uint8，占1个 byte，打印时需要用 string 进行类型转换，否则打印的是编码值。
• 因为字符串是以 byte 数组的形式存储的，所以，str2[2] 的值并不等于语。str2 的长度 len(str2) 也不是 4，而是 8（ Go 占 2 byte，语言占 6 byte）。

正确的处理方式是将 string 转为 rune 数组

str2 := "Go语言"
runeArr := []rune(str2)
fmt.Println(reflect.TypeOf(runeArr[2]).Kind()) // int32
fmt.Println(runeArr[2], string(runeArr[2]))    // 35821 语
fmt.Println("len(runeArr)：", len(runeArr))    // len(runeArr)： 4

转换成 []rune 类型后，字符串中的每个字符，无论占多少个字节都用 int32 来表示，因而可以正确处理中文。

3. 数组(array)与切片(slice)

数组的长度不能改变，如果想拼接2个数组，或是获取子数组，需要使用切片。切片是数组的抽象。 切片使用数组作为底层结构。切片包含三个组件：容量，长度和指向底层数组的指针,切片可以随时进行扩展

声明切片：

slice1 := make([]float32, 0)          // 长度为0的切片
fmt.Println(len(slice1), cap(slice1)) //0,0
slice2 := make([]float32, 3, 5)       // [0 0 0] 长度为3容量为5的切片
fmt.Println(len(slice2), cap(slice2)) // 3 5

使用切片：

	// 添加元素，切片容量可以根据需要自动扩展
	slice2 = append(slice2, 1, 2, 3, 4, 5, 6)
	fmt.Println(len(slice2), cap(slice2)) //9 12

	//子切片[start,end]
	sub1 := slice2[3:] //1,2,3,4,5,6
	fmt.Println(sub1)
	sub2 := slice2[:3]
	fmt.Println(sub2) //0,0,0
	sub3 := slice2[1:4]
	fmt.Println(sub3) //0,0,1

	//合并切片
	combined := append(sub1, sub2...)
	fmt.Println(combined)// [1 2 3 4 5 6 0 0 0]
	testArraySlice(combined)
	fmt.Println(combined) //[101 102 103 104 105 106 100 100 100]

func testArraySlice(combined []float32) {
	for i, v := range combined {
		combined[i] = v + 100
	}
}

• 声明切片时可以为切片设置容量大小，为切片预分配空间。在实际使用的过程中，如果容量不够，切片容量会自动扩展。
• sub2... 是切片解构的写法，将切片解构为 N 个独立的元素。

4. 字典(键值对，map)

map 类似于 java 的 HashMap，Python的字典(dict)，是一种存储键值对(Key-Value)的数据解构。使用方式和其他语言几乎没有区别。

// 仅声明
m1 := make(map[string]int)
// 声明时初始化
m2 := map[string]string{
	"Sam": "Male",
	"Alice": "Female",
}
// 赋值/修改
m1["Tom"] = 18

注： 需要明确在 Go 中不存在引用传递，所有的参数传递都是值传递。

5. 指针(pointer)

指针即某个值的地址，类型定义时使用符号*，对一个已经存在的变量，使用 & 获取该变量的地址。

str := "Golang"
var p *string = &str // p 是指向 str 的指针
*p = "Hello"
fmt.Println(str) // Hello 修改了 p，str 的值也发生了改变

一般来说，指针通常在函数传递参数，或者给某个类型定义新的方法时使用。Go 语言中，参数是按值传递的，如果不使用指针，函数内部将会拷贝一份参数的副本，对参数的修改并不会影响到外部变量的值。如果参数使用指针，对参数的传递将会影响到外部变量。