Go 之 语言基本类型

一、基本类型及其特性和用途

类型	长度（字节）	默认值	说明
bool	1	false	布尔值，表示真假
byte	1	0	别名为 uint8，用于表示ASCII字符或其他小整数值
rune	4	0	别名为 int32，表示一个Unicode码点
int, uint	4 或 8	0	有符号和无符号整数，具体长度取决于系统架构（32位或64位系统）
int8, uint8	1	0	有符号范围：-128 ~ 127；无符号范围：0 ~ 255，byte 是 uint8 的别名
int16, uint16	2	0	有符号范围：-32,768 ~ 32,767；无符号范围：0 ~ 65,535
int32, uint32	4	0	有符号范围：-2,147,483,648 ~ 2,147,483,647；无符号范围：0 ~ 4,294,967,295，rune 是 int32 的别名
int64, uint64	8	0	有符号范围：-9,223,372,036,854,775,808 ~ 9,223,372,036,854,775,807；无符号范围：0 ~ 18,446,744,073,709,551,615
float32	4	0.0	单精度浮点数
float64	8	0.0	双精度浮点数
complex64	8		复数，实部和虚部都是 float32
complex128	16		复数，实部和虚部都是 float64
uintptr	4 或 8		用于存储指针的整数类型，具体长度取决于系统架构
array	-	-	固定大小的数组，值类型
struct	-	-	结构体，包含多个字段的聚合类型，值类型
string	-	""	UTF-8 编码的字符串，值类型
slice	-	nil	动态大小的数组，引用类型
map	-	nil	键值对集合，引用类型
channel	-	nil	用于goroutine之间通信的通道，引用类型
interface	-	nil	接口类型，定义了一组方法集
function	-	nil	函数类型，可以作为参数传递或返回

二、byte 和 rune 区别

• byte：适用于处理ASCII字符或单字节数据，通常用于处理纯英文文本或简单的二进制数据。
• rune：适用于处理Unicode字符，特别是包含多字节字符的语言（如中文、日文等）。在处理复杂的字符串操作时，建议使用 rune 类型以确保字符的正确解析。

案例：

package main

import (
    "fmt"
)

func main() {
    str := "Hello你好"

    // 使用 byte 类型遍历字符串
    fmt.Println("Using byte:")
    for i := 0; i < len(str); i++ {
        fmt.Printf("Character: '%c', value: %d\n", str[i], str[i])
    }

    // 使用 rune 类型遍历字符串
    fmt.Println("\nUsing rune:")
    for _, r := range str {
        fmt.Printf("Character: '%c', value: %d\n", r, r)
    }
}

// 输出

Using byte:
Character: 'H', value: 72
Character: 'e', value: 101
Character: 'l', value: 108
Character: 'l', value: 108
Character: 'o', value: 111
Character: 'ä', value: 228
Character: '½', value: 189
Character: '?', value: 63

Using rune:
Character: 'H', value: 72
Character: 'e', value: 101
Character: 'l', value: 108
Character: 'l', value: 108
Character: 'o', value: 111
Character: '你', value: 20320
Character: '好', value: 22909

使用 byte 类型遍历时，由于字符串包含多字节字符（如"你好"），会出现乱码现象；而使用 rune 类型遍历时，则能正确解析每个字符。

三、new 与 make 的区别

特性	new(T)	make(T, args...)
适用类型	任何类型，包括结构体、数组、基本类型	仅适用于切片、映射和通道
返回值	返回 *T（指向 T 的指针）	返回 T（类型本身，已初始化）
初始化方式	零值初始化	根据参数进行初始化
用途	分配内存并返回指针	创建并初始化切片、映射或通道

package main

import (
    "fmt"
)

func main() {
    // 使用 new 创建映射指针
    mNew := new(map[string]int)
    fmt.Printf("%v, %T\n", mNew, mNew) // 输出: &map[], *map[string]int
    fmt.Println(*mNew)                 // 输出: map[] (实际上是 nil)

    // 尝试直接对 nil 映射进行赋值会导致 panic
    // (*mNew)["key"] = 10 // 这行代码会引发 panic

    // 方法1：使用 make 初始化映射，并将其赋值给指针指向的映射
    *mNew = make(map[string]int)
    (*mNew)["key"] = 10
    fmt.Println(*mNew) // 输出: map[key:10]

    // 方法2：使用字面量初始化映射，并将其赋值给指针指向的映射
    *mNew = map[string]int{"anotherKey": 20}
    fmt.Println(*mNew) // 输出: map[anotherKey:20]

    // 使用 make 创建映射
    mMake := make(map[string]int)
    fmt.Printf("%v, %T\n", mMake, mMake) // 输出: map[], map[string]int
    mMake["key"] = 10
    fmt.Println(mMake) // 输出: map[key:10]

    // 也可以将 mMake 赋值给 mNew 指向的映射
    *mNew = mMake
    (*mNew)["key"] = 30
    fmt.Println(*mNew) // 输出: map[key:30]
}

综上像 slice、map、channel 这三种还是用make比较合适。

四、array 数组

1、初始化数组

// 初始化一个包含5个整数的数组
arr := [5]int{1, 2, 3, 4, 5} 

// 初始化前两个元素，其余为0 // 结果: [1, 2, 0, 0, 0]
arr := [5]int{1, 2} 

// 编译器会自动推断数组长度为5
arr := [...]int{1, 2, 3, 4, 5} 

// 赋值3和4位置得值 ["", "", "", "hello world", "tom"]
var str = [5]string{3: "hello world", 4: "tom"} 

2、多维数组

// 声明一个二维数组
matrix := [2][3]int{
    {1, 2, 3},
    {4, 5, 6},
}

// 使用省略号自动推断长度，注意 第 2 纬度不能用 "..."
matrix := [...][3]int{
    {1, 2, 3},
    {4, 5, 6},
}

3、遍历数组

arr := [5]int{1, 2, 3, 4, 5}


// for 模式
for i := 0; i < len(arr); i++ {
    fmt.Printf("arr[%d] = %d\n", i, arr[i])
}

// range 模式
for i, v := range arr {
    fmt.Printf("arr[%d] = %d\n", i, v)
}

五、slice 切片

切片是对底层数组的一个引用，因此多个切片可以共享同一个底层数组。长度（length）表示切片中当前元素的数量。 容量（capacity）表示切片底层数组中从切片起始位置到数组末尾的元素数量。

1、切片的创建、初始化、遍历、修改以及常见操作

package main

import (
    "fmt"
)

func main() {
    // 使用 make 创建切片
    s1 := make([]int, 5, 10)
    fmt.Println("s1:", s1) // 输出: [0 0 0 0 0]

    // 直接初始化切片
    s2 := []int{1, 2, 3, 4, 5}
    fmt.Println("s2:", s2) // 输出: [1 2 3 4 5]

    // 从数组创建切片
    arr := [6]int{1, 2, 3, 4, 5, 6}
    s3 := arr[1:4]
    fmt.Println("s3:", s3) // 输出: [2 3 4]

    // 遍历切片
    for i, v := range s2 {
        fmt.Printf("s2[%d] = %d\n", i, v)
    }

    // 修改切片元素
    s2[0] = 10
    fmt.Println("After modification:", s2) // 输出: [10 2 3 4 5]

    // 添加元素
    s2 = append(s2, 6, 7, 8)
    fmt.Println("After append:", s2) // 输出: [10 2 3 4 5 6 7 8]

    // 删除元素
    s2 = append(s2[:2], s2[3:]...)
    fmt.Println("After removing element at index 2:", s2) // 输出: [10 2 4 5 6 7 8]

    // 复制切片
    dst := make([]int, 3)
    n := copy(dst, s2)
    fmt.Println("Copied slice:", dst) // 输出: [10 2 4]
    fmt.Println("Number of elements copied:", n) // 输出: 3

    // 切片的切片
    subSlice := s2[1:4]
    fmt.Println("Sub-slice:", subSlice) // 输出: [2 4 5]
}

• 创建 ：可以使用 make 函数创建切片，或者直接初始化切片。
• 初始化：可以直接在声明时初始化切片元素，或者从现有数组中创建切片。
• 访问和修改：通过索引访问和修改切片中的元素。
• 遍历 ：可以使用 for 循环或 range 来遍历切片。
• 添加元素 ：使用 append 函数向切片添加元素。
• 删除元素：可以通过切片操作符删除元素。
• 复制切片 ：使用 copy 函数将一个切片的内容复制到另一个切片中。
• 切片的切片：可以从一个切片中创建另一个切片。

2、切片得常规操作

操作	含义
s[n]	访问切片 s 中索引位置为 n 的项。
s[:]	从切片 s 的索引位置 0 到 len(s)-1 处所获得的切片（即整个切片）。
s[low:]	从切片 s 的索引位置 low 到 len(s)-1 处所获得的切片。
s[:high]	从切片 s 的索引位置 0 到 high 处所获得的切片，长度为 high。
s[low:high]	从切片 s 的索引位置 low 到 high 处所获得的切片，长度为 high - low。
s[low:high:max]	从切片 s 的索引位置 low 到 high 处所获得的切片，长度为 high - low，容量为 max - low。
len(s)	返回切片 s 的长度，表示当前包含的元素数量，总是小于等于 cap(s)。
cap(s)	返回切片 s 的容量，表示底层数组中从切片起始位置到数组末尾的元素数量，总是大于等于 len(s)。

package main

import (
    "fmt"
)

func main() {
    s := []int{1, 2, 3, 4, 5}

    // 访问切片s中索引位置为2的项
    fmt.Println("s[2]:", s[2]) // 输出: 3

    // 获取整个切片
    fmt.Println("s[:]:", s[:]) // 输出: [1 2 3 4 5]

    // 获取从索引位置1到末尾的切片
    fmt.Println("s[1:]:", s[1:]) // 输出: [2 3 4 5]

    // 获取从索引位置0到3的切片
    fmt.Println("s[:3]:", s[:3]) // 输出: [1 2 3]

    // 获取从索引位置1到3的切片
    fmt.Println("s[1:3]:", s[1:3]) // 输出: [2 3]

    // 获取从索引位置1到3且最大容量为4的切片
    fmt.Println("s[1:3:4]:", s[1:3:4]) // 输出: [2 3]

    
    s := make([]int, 3, 5) // 创建一个长度为3，容量为5的切片
    s = append(s, 4, 5)    // 添加两个元素

    fmt.Println("s:", s)           // 输出: [0 0 0 4 5]
    fmt.Println("len(s):", len(s)) // 输出: 5
    fmt.Println("cap(s):", cap(s)) // 输出: 5

    // 获取从索引位置1到3的切片
    // 子切片的容量由底层数组的容量减去子切片的起始索引决定，所以 cap 容量 5-1
    subSlice := s[1:3]
    fmt.Println("subSlice:", subSlice)          // 输出: [0 0]
    fmt.Println("len(subSlice):", len(subSlice)) // 输出: 2
    fmt.Println("cap(subSlice):", cap(subSlice)) // 输出: 4
}