GO语言基础语法#

一、标准输出#

fmt.Println：打印后自动换行，多个参数之间用空格分隔
fmt.Print：打印后不换行
fmt.Printf：格式化输出，和 C 语言的 printf 类似，需手动加 \n 换行

常用格式化占位符#

%d：整数
%s：字符串
%f：浮点数
- 示例：fmt.Printf("pi = %.2f\n", pi) 保留2位小数
%c：打印字符
%v：万能占位符，适配任意类型

1
fmt.Println(10, 20, "hello")   // 自动换行，参数间空格分隔
2
fmt.Print(10, 20, "hello")    // 不换行，参数间空格分隔
3
fmt.Printf("a = %d, b = %d\n", 10, 20) // 格式化模板输出

二、读取输入#

1. fmt.Scan#

以空格/换行作为分隔符读取输入
✅ 变量前必须加 & 传地址

1
var name string
2
var age int
3
fmt.Scan(&name, &age)
4
fmt.Println("姓名：", name)
5
fmt.Println("年龄：", age)

返回值：(n int, err error)
- n：成功读取的变量个数
- err：读取错误（正常为 nil）
- _：空白标识符，用于丢弃不需要的返回值

循环读取直到 EOF#

1
package main
2
import "fmt"
3

4
func main() {
5
    var a, b int
6
    for {
7
        n, err := fmt.Scan(&a, &b)
8
        if n != 2 || err != nil {
9
            break
10
        }
11
        fmt.Println(a + b)
12
    }
13
}

2. 读取整行（含空格）bufio.Scanner#

1
package main
2
import (
3
    "bufio"
4
    "fmt"
5
    "os"
6
)
7

8
func main() {
9
    scanner := bufio.NewScanner(os.Stdin)
10
    scanner.Scan()    // 读取一整行
11
    line := scanner.Text()
12
    fmt.Println(line)
13
}

三、& 和 * 运算符#

1. & 取地址运算符#

&变量：获取变量内存地址，生成指针
- 例：var a int; p := &a，p 类型为 *int
- 作用：传递原始变量地址，允许函数修改原变量（不是副本）
- 关键：fmt.Scan 需要指针参数才能正确写入值，不能直接传变量本身

2. * 解引用运算符#

*指针变量：访问/修改指针指向的原始变量
```
1
var a int
2
p := &a
3
*p = 100 // 通过指针修改原变量 a
4
fmt.Println(a) // 输出 100
```
- 类型声明写法：var p *int 表示 int 指针类型（和表达式解引用语法不同）

&x：取 x 的地址 → 生成指针

*p：顺着指针地址访问原值

四、变量与数据类型#

1. 基础类型#

bool：布尔（true / false）
string：UTF-8 字符串
整数：int / int8 / int16 / int32 / int64 / uint / uint8(byte) / uint16 / uint32 / uint64 / uintptr
rune：int32 别名，用于 Unicode 字符
浮点数：float32 / float64
复数：complex64 / complex128

2. 复合类型#

数组 [N]T：固定长度，值类型
切片 []T：动态数组，引用类型（需 make）
Map map[KeyType]ValueType：哈希映射，引用类型（需 make）
Struct：结构体，自定义聚合类型
Channel chan T：通道，goroutine 通信（需 make）
Pointer *T：指针类型
Function：函数类型
Interface：接口类型

3. 变量规则#

Go 强制要求：声明变量必须使用，否则编译报错
临时忽略值：用空白标识符 _

4. 常量 const#

1
const MaxSize = 100
2
const Pi = 3.14159

常量定义后不可修改

5. 显式类型转换#

Go 无隐式自动类型转换，必须显式转换

1
a := 42
2
b := float64(a)
3
fmt.Println(b)
4

5
c := 3.99
6
d := int(c) // 截断小数，不是四舍五入 → 结果 3
7
fmt.Println(d)
8

9
// 整数除法坑
10
x, y := 1, 2
11
fmt.Println(x / y)                  // int除法：0
12
fmt.Println(float64(x) / float64(y))// 浮点数除法：0.5
13

14
var e int = 100
15
var f int64 = int64(e)
16
fmt.Println(f)
17

18
// 数值转字符串
19
num := 42
20
s := fmt.Sprintf("%d", num)
21
fmt.Printf("%s (string)\n", s)

五、运算符#

1. 算术运算符#

1
a, b := 17, 5
2
fmt.Println(a + b) // 加法
3
fmt.Println(a - b) // 减法
4
fmt.Println(a * b) // 乘法
5
fmt.Println(a / b) // 整数除法，截断小数
6
fmt.Println(a % b) // 取余
7

8
// 自增/自减：只能独立语句，不能嵌入表达式
9
c := 10
10
c++
11
fmt.Println(c)
12
c--
13
fmt.Println(c)
14

15
// 复合赋值
16
c += 5
17
c *= 2

2. 比较 & 逻辑运算符#

1
a, b := 10, 20
2
// 比较
3
fmt.Println(a == b)
4
fmt.Println(a != b)
5
fmt.Println(a < b)
6

7
// 逻辑
8
fmt.Println(a > 5 && b > 15)  // && 并且
9
fmt.Println(a > 100 || b > 15) // || 或者
10
fmt.Println(!(a > 5))         // ! 取反

❗ Go 没有三元运算符 ?:，只能用 if-else

1
var max int
2
if a > b {
3
    max = a
4
} else {
5
    max = b
6
}

3. 位运算#

1
a := 10 // 1010
2
b := 12 // 1100
3

4
fmt.Println(a & b)  // 按位与
5
fmt.Println(a | b)  // 按位或
6
fmt.Println(a ^ b)  // 按位异或
7
fmt.Println(a << 1) // 左移（×2）
8
fmt.Println(a >> 1) // 右移（÷2）
9

10
// 判断奇偶
11
n := 7
12
if n&1 == 1 {
13
    fmt.Printf("%d 是奇数\n", n)
14
}

六、控制流#

1. if / else 条件判断#

条件不用括号 ()，左大括号 { 必须和 if 同行
支持前置局部变量声明

1
score := 85
2
if score >= 90 {
3
    fmt.Println("优秀")
4
} else if score >= 60 {
5
    fmt.Println("及格")
6
} else {
7
    fmt.Println("不及格")
8
}
9

10
// 前置变量写法
11
if num := 10; num%2 == 0 {
12
    fmt.Println("偶数")
13
}

2. for 循环（Go 唯一循环语句）#

1
// 写法1：经典for
2
for i := 0; i < 5; i++ {
3
    fmt.Print(i, " ")
4
}
5
fmt.Println()
6

7
// 写法2：类while
8
sum := 0
9
i := 1
10
for i <= 100 {
11
    sum += i
12
    i++
13
}
14
fmt.Println(sum)
15

16
// 写法3：无限循环
17
count := 0
18
for {
19
    count++
20
    if count >= 3 {
21
        break
22
    }
23
}
24
fmt.Println(count)

3. range 遍历#

返回：索引 i, 元素值 v

1
nums := [5]int{10, 20, 30, 40, 50}
2

3
// 完整接收索引和值
4
for i, v := range nums {
5
    fmt.Printf("索引 %d：值 %d\n", i, v)
6
}
7

8
// 只取值，用 _ 忽略索引
9
for _, v := range nums {
10
    fmt.Print(v, " ")
11
}
12
fmt.Println()
13

14
// 只取索引
15
for i := range nums {
16
    fmt.Print(i, " ")
17
}
18
fmt.Println()

4. break / continue#

break：跳出整个循环
continue：跳过本轮循环，直接进入下一轮

1
// break 示例
2
for i := 1; i <= 100; i++ {
3
    if i%7 == 0 {
4
        fmt.Println("第一个能被7整除的数：", i)
5
        break
6
    }
7
}
8

9
// continue 示例
10
for i := 1; i <= 10; i++ {
11
    if i%2 == 0 {
12
        continue
13
    }
14
    fmt.Print(i, " ")
15
}

5. switch#

默认自动 break，不会穿透 case
可多值匹配，也可无表达式作为 if-else 链使用

1
var day int
2
fmt.Scan(&day)
3
switch day {
4
case 1:
5
    fmt.Println("星期一")
6
case 2:
7
    fmt.Println("星期二")
8
case 3:
9
    fmt.Println("星期三")
10
case 6, 7:
11
    fmt.Println("周末")
12
default:
13
    fmt.Println("其他工作日")
14
}
15

16
// 无表达式 switch
17
score := 85
18
switch {
19
case score >= 90:
20
    fmt.Println("优秀")
21
case score >= 60:
22
    fmt.Println("及格")
23
default:
24
    fmt.Println("不及格")
25
}