跳转至

第三章：基础语法

3.1 变量与常量

变量声明

package main

import "fmt"

func main() {
    // 完整声明
    var name string = "Go"

    // 类型推断
    var age = 15

    // 短声明（最常用）
    language := "Go"

    // 多变量声明
    var (
        x int     = 10
        y float64 = 3.14
        z bool    = true
    )

    // 批量声明
    a, b, c := 1, 2, 3

    fmt.Println(name, age, language, x, y, z, a, b, c)
}

常量

package main

import "fmt"

// 常量声明
const PI = 3.14159

// 批量声明
const (
    StatusOK    = 200
    StatusError = 500
)

// iota 常量生成器
const (
    Sunday = iota  // 0
    Monday         // 1
    Tuesday        // 2
    Wednesday      // 3
    Thursday       // 4
    Friday         // 5
    Saturday       // 6
)

// 位运算常量
const (
    Read   = 1 << iota  // 1
    Write               // 2
    Execute             // 4
)

3.2 基本数据类型

数值类型

package main

import "fmt"

func main() {
    // 整数类型
    var i int = 42
    var i8 int8 = 127
    var i16 int16 = 32767
    var i32 int32 = 2147483647
    var i64 int64 = 9223372036854775807

    // 无符号整数
    var u uint = 42
    var u8 uint8 = 255

    // 浮点数
    var f32 float32 = 3.14
    var f64 float64 = 3.14159265358979

    // 复数
    var c64 complex64 = 1 + 2i
    var c128 complex128 = 1 + 2i

    fmt.Println(i, i8, i16, i32, i64, u, u8, f32, f64, c64, c128)
}

字符串

package main

import "fmt"

func main() {
    // 字符串声明
    var s1 string = "Hello"
    s2 := "World"

    // 多行字符串
    s3 := `这是一个
多行字符串`

    // 字符串操作
    fmt.Println(len(s1))           // 长度: 5
    fmt.Println(s1 + " " + s2)     // 拼接
    fmt.Println(s1[0])             // 字节: 72
    fmt.Println(s1[0:3])           // 切片: Hel

    // 遍历字符串
    for i, r := range s1 {
        fmt.Printf("%d: %c\n", i, r)
    }
}

布尔类型

package main

import "fmt"

func main() {
    var b1 bool = true
    b2 := false

    fmt.Println(b1 && b2)  // false
    fmt.Println(b1 || b2)  // true
    fmt.Println(!b1)       // false
}

3.3 流程控制

条件语句

package main

import "fmt"

func main() {
    age := 18

    // if 语句
    if age >= 18 {
        fmt.Println("成年人")
    }

    // if-else
    if age < 18 {
        fmt.Println("未成年")
    } else {
        fmt.Println("成年")
    }

    // if-else if-else
    if age < 12 {
        fmt.Println("儿童")
    } else if age < 18 {
        fmt.Println("青少年")
    } else {
        fmt.Println("成年人")
    }

    // 带初始化语句
    if score := 85; score >= 60 {
        fmt.Println("及格")
    }
}

switch 语句

package main

import "fmt"

func main() {
    day := 3

    switch day {
    case 1:
        fmt.Println("周一")
    case 2:
        fmt.Println("周二")
    case 3, 4, 5:
        fmt.Println("周三到周五")
    default:
        fmt.Println("周末")
    }

    // 无条件 switch
    score := 85
    switch {
    case score >= 90:
        fmt.Println("优秀")
    case score >= 60:
        fmt.Println("及格")
    default:
        fmt.Println("不及格")
    }

    // fallthrough 穿透
    switch day {
    case 1:
        fmt.Println("工作日")
        fallthrough
    case 2:
        fmt.Println("继续执行")
    }
}

循环语句

package main

import "fmt"

func main() {
    // for 循环
    for i := 0; i < 5; i++ {
        fmt.Println(i)
    }

    // while 风格
    i := 0
    for i < 5 {
        fmt.Println(i)
        i++
    }

    // 无限循环
    for {
        fmt.Println("无限循环")
        break
    }

    // 遍历切片
    nums := []int{1, 2, 3, 4, 5}
    for index, value := range nums {
        fmt.Printf("索引: %d, 值: %d\n", index, value)
    }

    // 遍历 map
    m := map[string]int{"a": 1, "b": 2}
    for key, value := range m {
        fmt.Printf("键: %s, 值: %d\n", key, value)
    }
}

3.4 指针

package main

import "fmt"

func main() {
    // 指针声明
    var p *int

    // 取地址
    x := 42
    p = &x

    fmt.Println("x 的值:", x)      // 42
    fmt.Println("x 的地址:", &x)   // 0xc0000b2008
    fmt.Println("p 的值:", p)      // 0xc0000b2008
    fmt.Println("p 指向的值:", *p) // 42

    // 通过指针修改值
    *p = 100
    fmt.Println("修改后 x:", x)    // 100
}

// 指针作为参数
func increment(n *int) {
    *n++
}

3.5 函数

函数定义

package main

import "fmt"

// 基本函数
func add(a, b int) int {
    return a + b
}

// 多返回值
func divide(a, b int) (int, error) {
    if b == 0 {
        return 0, fmt.Errorf("除数不能为 0")
    }
    return a / b, nil
}

// 命名返回值
func calculate(a, b int) (sum, product int) {
    sum = a + b
    product = a * b
    return // 自动返回
}

// 可变参数
func sum(nums ...int) int {
    total := 0
    for _, n := range nums {
        total += n
    }
    return total
}

// 函数作为参数
func apply(nums []int, fn func(int) int) []int {
    result := make([]int, len(nums))
    for i, n := range nums {
        result[i] = fn(n)
    }
    return result
}

// 闭包
func counter() func() int {
    count := 0
    return func() int {
        count++
        return count
    }
}

func main() {
    fmt.Println(add(1, 2))

    if result, err := divide(10, 2); err == nil {
        fmt.Println(result)
    }

    sum, product := calculate(3, 4)
    fmt.Println(sum, product)

    fmt.Println(sum(1, 2, 3, 4, 5))

    nums := []int{1, 2, 3}
    doubled := apply(nums, func(n int) int { return n * 2 })
    fmt.Println(doubled)

    c := counter()
    fmt.Println(c()) // 1
    fmt.Println(c()) // 2
}

小结

  1. Go 使用 var 和 := 声明变量
  2. 常量使用 const，iota 用于枚举
  3. 只有 for 一种循环语句
  4. switch 不需要 break，fallthrough 可穿透
  5. 函数支持多返回值和命名返回值

参考资料