语法手册

一、基本数据类型

1、整数类型

var num3 int = 3
var num4 int8 = 4      // 占1个字节   -2^7  ~ 2^7 - 1
var num5 int16 = 5     // 占2个字节   -2^15 ~ 2^15 - 1
var num6 int32 = 6     // 占4个字节   -2^31 ~ 2^31 - 1
var num7 int64 = 7     // 占8个字节   -2^63 ~ 2^63 - 1

2、浮点类型

var num1 float32 = 1
var num2 float64 = 2

3、字符类型

转义字符

fmt.Println("aaa\nbbb")     // \n 换行
fmt.Println("aaa\bbbb")     // \b 退格
fmt.Println("aaa\rbbbb")    // \r 光标回到本行的开头，后续输入就会替换原有的字符
fmt.Println("aaaaa\tbbbbb") // -t 制表符 8位

输出：
aaa
bbb
aabbb
bbbb
aaaaa   bbbbb

4、布尔类型

5、字符串类型

var s1 string = "hello golang"
fmt.Println(s1)

字符串是不可变的：指的是字符串一旦定义好，其中的字符的值不能改变。

6、基本数据类型的默认值

var num1 float32
var num2 float64
var num3 int
var num4 int8
var num5 int16
var num6 int32
var num7 int64
var num8 string
var num9 byte
var num10 bool
fmt.Println(num1)
fmt.Println("float32: ", unsafe.Sizeof(num1))
fmt.Println(num2)
fmt.Println("float64: ", unsafe.Sizeof(num2))
fmt.Println(num3)
fmt.Println("int: ", unsafe.Sizeof(num3))
fmt.Println(num4)
fmt.Println("int8: ", unsafe.Sizeof(num4))
fmt.Println(num5)
fmt.Println("int16: ", unsafe.Sizeof(num5))
fmt.Println(num6)
fmt.Println("int32: ", unsafe.Sizeof(num6))
fmt.Println(num7)
fmt.Println("int64: ", unsafe.Sizeof(num7))
fmt.Println(num8)
fmt.Println("string: ", unsafe.Sizeof(num8))
fmt.Println(num9)
fmt.Println("byte: ", unsafe.Sizeof(num9))
fmt.Println(num10)
fmt.Println("bool: ", unsafe.Sizeof(num10))

输出结果：
0
float32:  4
0
float64:  8
0
int:  8
0
int8:  1
0
int16:  2
0
int32:  4
0
int64:  8

string:  16
0
byte:  1
false
bool:  1

7、数据类型之间的转换

7.1、基本数据类型之间的转换

var n1 int = 100
// var n2 float32 = n1  // 在这里自动转换不好使，比如显式转换
var n2 float32 = float32(n1)
fmt.Println(n1)
fmt.Println(n2)
fmt.Printf("%T\n", n1) // int  n1的类型还是int类型，只是将n1的值100转为了float32而已，n1还是int类型

// 将int64转为int8的时候，编译不会出错，但是会数据溢出
var n3 int64 = 888888
var n4 int8 = int8(n3)
fmt.Println(n4) //56

var n5 int32 = 12
var n6 int64 = int64(n5) + 30 // 一定要匹配 = 左右的数据类型
fmt.Println(n5)
fmt.Println(n6)

var n7 int64 = 12
var n8 int8 = int8(n7) + 127 // 编译通过，但是结果可能会溢出
// var n9 int8 = int8(n7) + 128 // 编译不会通过
fmt.Println(n8)
// fmt.Println(n9)

7.2、基本数据类型和字符串类型之间的转换

方式一、Sprintf("", )

var n1 int = 19
var s1 string = fmt.Sprintf("%d", n1)
fmt.Printf("s1对应的类型是： %T, s1 = %q \n", s1, s1)

var n2 float32 = 1.23
var s2 string = fmt.Sprintf("%f", n2)
fmt.Printf("s2对应的类型是： %T, s2 = %q \n", s2, s2)

var n3 bool = false
var s3 string = fmt.Sprintf("%t", n3)
fmt.Printf("s3对应的类型是： %T, s3 = %q \n", s3, s3)

var n4 byte = 'a'
var s4 string = fmt.Sprintf("%c", n4)
fmt.Printf("s4对应的类型是： %T, s4 = %q \n", s4, s4)

方式二、strconv

二、复杂数据类型

1、指针

var num int = 18
// &符号+变量，就可以获取这个变量内存的地址
fmt.Println(&num)

// 定义一个指针变量：
// var代表要声明一个变量
// ptr 指针变量的名字
// ptr 对应的类型是：*int 是一个指针类型 ，可以理解为 指向int类型的指针
// &num 就是一个地址，是ptr变量的具体的值
var ptr *int = &num
fmt.Println(ptr)
fmt.Println("ptr本身的存储空间的值：", &ptr)

// 想获取ptr这个指针或者这个地址指向的那个数据
fmt.Printf("ptr指向的数值：%v \n", *ptr)

输出：
0xc000084048
0xc000084048
ptr本身的存储空间的值： 0xc00004c008
ptr指向的数值：18

总结：

1. & 取内存地址
2. *根据地址取值

1.1、可以通过指针改变指向值

var num int = 10
fmt.Println(num)

var ptr *int = &num
*ptr = 20
fmt.Println(num)

1.2、指针变量接收的一定是地址值

var ptr *int = num // 错误

1.3、指针变量的地址不可以不匹配

var ptr *float32 = &num

1.4、基本数据类型（又叫值类型）

都有对应的指针类型，形式为 * 数据类型，比如int对应的指针就是* int，float32对应的指针类型就是* float32，依次类推。

三、运算符

原文这一节只有标题。算术 / 比较 / 逻辑运算符和 C 接近，没有隐式数值提升；需要转换时显式写 int(x)。

四、流程控制

关键字

break

作用：

• break 用于立即终止循环（for、switch 或 select），并跳出当前的循环块或 switch 语句。
• 在多层嵌套循环中，break 仅作用于它所在的最近一层循环。

使用场景：提前退出循环，如在查找某个满足条件的元素时。

例子：

for i := 0; i < 10; i++ {
    if i == 5 {
        break // 终止循环，当 i == 5 时跳出 for 循环
    }
    fmt.Println(i)
}

输出：
0
1
2
3
4

continue

作用：

• continue 用于跳过当前循环的剩余部分，并立即进入下一次循环迭代。
• 在 for 循环中，当执行 continue 时，控制权会返回到循环的增量表达式（如果有的话）。

使用场景：跳过当前不符合条件的迭代，继续下一次迭代，例如跳过奇数或某些条件下的值。

例子：

for i := 0; i < 10; i++ {
    if i%2 == 0 {
        continue // 跳过本次循环的剩余部分，直接进入下一次循环
    }
    fmt.Println(i)
}

输出：
1
3
5
7
9

goto

作用：

• goto 是一种无条件跳转语句，用于将控制转移到同一函数或方法中的某个标签位置。
• 标签是由一个标识符加冒号 (:) 构成的，可以放置在代码的任意位置。

使用场景：在 Go 中不推荐频繁使用 goto，因为它可能会让代码难以理解。但在某些情况下（如在嵌套循环中需要跳出多层循环），goto 可以作为一种简便的控制方式。

例子：

for i := 0; i < 3; i++ {
    for j := 0; j < 3; j++ {
        if i == 1 && j == 1 {
            goto end // 跳转到 end 标签，直接结束嵌套循环
        }
        fmt.Println(i, j)
    }
}
end: // 标签位置
fmt.Println("跳出了嵌套循环")

输出：
0 0
0 1
0 2
1 0
跳出了嵌套循环

return

作用：

• return 用于从函数中返回值，并结束该函数的执行。执行 return 后，函数不会再执行 return 语句后的任何代码。
• 如果函数有返回值，return 语句后跟随返回的值。

使用场景：返回函数的计算结果或状态，或在特定条件下提前退出函数。

例子：

func add(a int, b int) int {
    return a + b // 返回 a + b 的结果，并结束函数
}

func main() {
    sum := add(3, 5)
    fmt.Println(sum) // 输出: 8
}

输出：
8