Golang入门三：类型

基础类型

• 布尔类型：bool
• 整形：int8、byte、int16、int、uint、uintptr等
• 浮点类型：float32、float64
• 复数类型： complex64、 complex128。
• 字符串： string。
• 字符类型： rune。
• 错误类型： error。
  此外， Go语言也支持以下这些复合类型：
• 指针（ pointer）
• 数组（ array）
• 切片（ slice）
• 字典（ map）
• 通道（ chan）
• 结构体（ struct）
• 接口（ interface）

布尔

var b1 bool
b1 = true
b2 := (1 == 2)

整型

var value int32
value1 := 64 // 自动推导为int类型
value = value1 // 会编译错误，类型不一致
value= int32(value1) // 强制类型转换

数值运算

常规整数运算：+、 -、 *、 /和%，%为取余

比较运算

比较运算符：>、<、==、>=、<=和!=

位运算

位运算符：<<、>>、^、&、|

运算	含义	样例
x << y	左移	124 << 2 // 结果为496
x >> y	右移	124 >> 2 // 结果为31
x ^ y	异或	124 ^ 2 // 结果为126
x & y	与	124 & 2 // 结果为0
x | y	或	124 | 2 // 结果为126
^x	取反	^2 // 结果为-3

浮点型

var f1 float32
f1 = 12
f2 := 13.0 // 不加小数点，默认推导为整型而不是浮点型
f1 = float32(f2) // 强制转换

// 浮点数比较
import "math"

// p为用户自定义的比较精度，如0.0001
func IsEqual(f1, f2, p float64) bool {
    return math.Fdim(f1, f2) < p
}

复数类型

var v complex64 // 由两个float32构成的复数类型
v = 3.2 + 12i
v2 := 3.2 + 12i
v3 := complex(3.2, 12)

字符串

var str string              // 声明一个字符串变量
str = "Hello nnnuo"         // 字符串赋值
ch : = str[0]               // 取字符串的第一个字符

// 以字节数组遍历
n := len(str)
for i := 0; i < n; i++ {
    c := str[i]
    fmt.Println(i, c)
}
// 以Unicode字符遍历
for i, c := range str {
    fmt.Println(i, c) // c的类型为rune
}

数组

常规数组声明方法：

[32]byte                    // 长度为32的数组，每个元素为一个字节
[2*N] struct { x, y int32 } // 复杂类型数组
[1000]*float64              // 指针数组
[3][5]int                   // 二维数组
[2][2][2]float64            // 等同于[2]([2]([2]float64))
// 获取长度
arrLength := len(arr)

切片

创建切片

package main

import "fmt"

func main() {
    // 定义数组
    var myArray [10] int = [10] int {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    // 基于数组创建一个数组切片
    var mySlice [] int = myArray[:5]
    // 使用mack创建
    mySlice1 := make([]int, 5) // 初始元素个数为5，元素初始值为0
    mySlice2 := make([]int, 5, 10) // 初始元素个数为5，元素初始值为0，并预留10个元素存储空间
    fmt.Println("len(mySlice2 ): ", len(mySlice2)) // len(mySlice2 ): 5
    fmt.Println("cap(mySlice2): ", cap(mySlice2)) // cap(mySlice2): 10
    mySlice3 := []int{1, 2, 3, 4, 5} // 创建并初始化包含5个元素的切片

    fmt.Println("Elements of myArray: ")
    for _, v := range myArray {
        fmt.Print(v, " ")
    }
    fmt.Println("\nElements of mySlice: ")
    // 遍历
    for _, v := range mySlice {
        fmt.Print(v, " ")
    }
    fmt.Println()

    mySlice = append(mySlice, 1, 2, 3)
    mySlice = append(mySlice, mySlice3...)

    // 基于切片创建切片
    oldSlice := []int{1, 2, 3, 4, 5}
    newSlice := oldSlice[:3]

    // Copy
    copySlice1 := []int{1, 2, 3, 4, 5}
    copySlice2 := []int{5, 4, 3}
    copy(copySlice2, copySlice1) // 只会复制copySlice1的前3个元素到copySlice2中
    copy(copySlice1, copySlice2) // 只会复制copySlice2的前3个元素到copySlice2的前3个位置
}

运行结果为：
Elements of myArray:
1 2 3 4 5 6 7 8 9 10
Elements of mySlice:
1 2 3 4 5

map

package main
import "fmt"

type PersonInfo struct {
    ID string
    Name string
    Address string
}

func main() {
    // map变量声明：var map_name map[key_type] value_type
    var personDB map[string] PersonInfo
    // 创建，key类型为string，值为PersonInfo
    personDB = make(map[string] PersonInfo)
    /*
        personDB = make(map[string] PersonInfo, 100) // 初始存储能力为100
        // 创建并初始化
        personDB = map[string] PersonInfo {
            "1234": PersonInfo{"1234", "Nnnuo", "Room 1204..."}
        }
    */

    // 往map里面插入数据
    personDB["12345"] = PersonInfo{"12345", "Nnnuo", "Room 111..."}
    personDB["1"] = PersonINfo{"1", "JJAA", "Room 302..."}

    // 从map查询键为"12345"的信息
    person, ok := personDB["12345"]
    if ok {
        fmt.Println("Found person", person.Name, "with ID 12345.")
    } else {
        fmt.Println("Did not find person with ID 12345.")
    }

    // 删除
    delete(personDB, "1234")
}