Go语言基本数据类型

整数型

和C++类似，分为有符号整数和无符号整数，并且按照位数区分

var a1 int8 = 1 // 8位有符号整数
var a2 uint64 = 1 // 64位无符号整数
var a3 int = 1 // int 类型取决与系统的情况，对于64位系统为int64

uint8 还有一个别称 byte

浮点型

Go有两种浮点数类型，float32和float64，默认为float64，两者的最大值位math.MaxFloat32和math.MaxFloat64

package main

import (
    "fmt"
    "math"
)

func main() { 
    var a1 float32 = math.MaxFloat32
    var a2 float64 = math.MaxFloat64
    fmt.Println(a1, a2)
}

字符型

在Go语言中，字符本质就是一个8位的无符号整数，使用 byte 表示单字节字符，rune 表示多字节字符。
在输出的时候，需要使用%c格式化符，否则会直接输出对应的 UTF-8 编码值

func main() { 
    var c1 byte = 'a'
    var c2 rune = '你'
    fmt.Println(c1) // 97
    fmt.Println(c2) // 20320
    fmt.Printf("%c %c\n", c1, c2) // 你
}

字符串型

在Go语言中，字符串本质是一个字节数组，使用 string 表示字符串。
字符使用单引号，字符串使用双引号
在输出的时候，可以使用fmt.Println直接输出，或者使用fmt.Printf格式化输出，需要%s格式化符

func main() {
	var s1 = "abcd"
	fmt.Println(s1)
	fmt.Printf("s1: %s", s1)
}

转义字符

和C语言一样，Go语言的字符串中可以使用转义字符，如\n表示换行，\t表示制表符，\表示反斜杠，\"表示双引号，\'表示单引号，\\表示反斜杠

多行字符串

func main() {
	var s1 = `a
b
c
`
	fmt.Println(s1)
}

布尔类型

布尔类型只有两个值，true和false，使用bool表示

不允许将整型强制转化为布尔类型，如1不能转为true
布尔类型无法参与数学运算，也无法转换位其他类型

危险

如果一个类型在定义的时候没有被初始化，则默认位零值，如int的零值为0，bool的零值为false，字符串为""

数组

数组是一种静态数据结构，其长度是固定的，不能改变
数组声明格式：var 数组名 [数组长度] 数据类型
直接使用引索[]访问数组元素
数组长度可以通过len()函数获取

func main() { 
    var a [3]int = [3]int{1, 2, 3}
    fmt.Println(a)
    var b = [3]int{'a', 'b', 'c'}
    fmt.Println(b) // [97 98 99]，打印的为字符的ASCII码
    var c = [...]int{1, 2, 3} // 自动推导长度，长度为3
    fmt.Println(c)
    fmt.Println(len(c)) // 3
}

切片

切片（Slice）是一种动态数据结构，其长度是动态的的，可以改变
使用[] 数据类型创建切片，使用append()函数添加元素

func main() { 
    var list []string
    list = append(list, "a")
    list = append(list, "b")
    fmt.Println(list, len(list))
    list = append(list, "c")
    fmt.Println(list, len(list))
    list[1] = "x"
    fmt.Println(list, len(list))
}

make 函数

我们可以使用make函数创建切片，格式为make([] type, length, capacity)，其中length为切片的长度，capacity为切片的容量，capacity可以省略

func main() {
	var list = make([]string, 3)
	fmt.Println(list, len(list), cap(list))
	list[0] = "x"
	list = append(list, "a")
	fmt.Println(list, len(list), cap(list))
}

除了基本类型，其他数据类型如果只定义不赋值，实际的值为nil

func main() {
    var list1 []string
    var list2 = make([]string, 0)
    fmt.Println(list1 == nil) // true
    fmt.Println(list2 == nil) // false
}

切片和数组的关系

切片可以通过数组切出来，格式为array[start:end]。如果start和end为空，则表示从数组的开始或者结束，如果end为空，则表示到数组的末尾

func main() {
    var a = [5]int{1, 2, 3, 4, 5}
    slice1 := a[1:3] // [2 3]
    slice2 := a[:3] // [1 2 3]
    slice3 := a[1:] // [2 3 4 5]
    slice4 := a[:] // [1 2 3 4 5]
    fmt.Println(slice1, slice2, slice3, slice4)
}

切片排序

func main() {
    var list = []int{5, 4, 3, 2, 1}
    sort.Ints(list)
    fmt.Println("升序: ", list) // [1 2 3 4 5]
    sort.Sort(sort.Reverse(sort.IntSlice(list)))
    fmt.Println("降序: ", list) // [5 4 3 2 1]
}

字典

字典（Map）是一种动态数据结构，其长度是动态的的，可以改变，内部是一个无序的键值对（key-value）集合
Map的key必须是基本数据类型，如int、string、float64，不能是切片、数组、结构体、指针、函数等；value可以是任意类型
使用map[key] value创建字典，使用map[key]访问字典元素

func main() { 
    var map1 map[string]int
    // 初始化map
    map1 = make(map[string]int)
    map1 = map[string]int{} // 两种初始化方式
    // 设置值
    map1["a"] = 1
    map1["b"] = 2
    fmt.Println(map1) // map[a:1 b:2]
    fmt.Println(map1["a"]) // 1
    delete(map1, "a")
    fmt.Println(map1) // map[b:2]
}

在取元素的时候，如果有两个参数，则返回两个值，第一个值为对应的值，第二个值为是否存在该键，bool类型
如果值不括的键不存在，则返回0，false

func main() { 
    var map1 = map[string]int{"a": 1, "b": 2}
    a := map1["c"]
    fmt.Println(a) // 0 
    b, ok := map1["a"]
    fmt.Println(b, ok) // 1 true
}

整数型​

浮点型​

字符型​

字符串型​

布尔类型​

数组​

切片​

字典​

整数型

浮点型

字符型

字符串型

布尔类型

数组

切片

字典