第 2 章：变量与数据类型¶

package main

import "fmt"

// 包级别变量声明
var version = "1.0.0"

func main() {
    // 声明变量并指定类型
    var name string = "Go"

    // 声明变量，省略类型（类型推断）
    var year = 2009

    // 声明多个变量
    var x, y int = 10, 20

    // 先声明，后赋值
    var score int
    score = 95

    fmt.Println(name, year, x, y, score, version)
}

func main() {
    // 短变量声明，省略 var 关键字和类型
    name := "Go"        // 推断为 string
    year := 2009        // 推断为 int
    version := 1.0      // 推断为 float64

    // 多个变量同时声明
    x, y := 10, 20

    // 交换两个变量的值
    x, y = y, x         // 此时 x=20, y=10
}

func main() {
    x := 10
    x, y := 20, 30   // 允许：x 已存在，但 y 是新变量
    // x := 20       // 编译错误：左侧没有新变量
}

var isReady bool = true
var isDone bool   // 零值为 false

var a int = 42
var b uint8 = 255       // byte 的别名
var c int64 = 1 << 62   // 大整数

var pi float64 = 3.141592653589793
var e float32 = 2.71828

var s1 string = "Hello, Go"
s2 := "字符串中的换行必须使用转义\n"

func main() {
    s := "Hello, Go"

    // 获取字符串长度（字节数，而非字符数）
    fmt.Println(len(s))   // 输出：9

    // 索引访问（返回字节，而非字符）
    fmt.Println(s[0])     // 输出：72（H 的 ASCII 码值）

    // 子串截取
    fmt.Println(s[0:5])   // 输出：Hello

    // 字符串拼接
    fmt.Println(s + " 语言")  // 输出：Hello, Go 语言
}

func main() {
    var b byte = 'A'       // 97
    var r rune = '中'      // 20013 (Unicode U+4E2D)

    fmt.Printf("byte: %c, value: %d\n", b, b)   // byte: A, value: 65
    fmt.Printf("rune: %c, value: %d\n", r, r)   // rune: 中, value: 20013

    // 字符串由字节组成，转换为 rune 切片后才能按字符遍历
    s := "Go 语言"
    fmt.Println("byte length:", len(s))       // 输出：9

    runes := []rune(s)
    fmt.Println("rune count:", len(runes))     // 输出：5（G/o/ /语/言）
}

func main() {
    var i int
    var f float64
    var b bool
    var s string

    fmt.Printf("int: %v\n", i)       // int: 0
    fmt.Printf("float64: %v\n", f)   // float64: 0
    fmt.Printf("bool: %v\n", b)      // bool: false
    fmt.Printf("string: '%v'\n", s)  // string: ''
}

func main() {
    v1 := 42            // int
    v2 := 3.14          // float64
    v3 := "hello"       // string
    v4 := 3 + 4i        // complex128
    v5 := true          // bool

    fmt.Printf("v1: %T\n", v1)   // int
    fmt.Printf("v2: %T\n", v2)   // float64
}

var score float32 = 97.5   // 必须显式指定 float32，否则默认为 float64

func main() {
    var x int = 42
    var y float64 = float64(x)   // 显式 int -> float64

    var a float64 = 3.14
    var b int = int(a)           // 显式 float64 -> int（截断小数）
    fmt.Println(b)               // 输出：3

    // 编译错误：cannot use x (variable of type int) as type float64
    // var z float64 = x
}

// 不同类型之间的运算须先统一类型
var m int = 10
var n int64 = 20

// 编译错误：invalid operation: m + n (mismatched types int and int64)
// fmt.Println(m + n)

fmt.Println(m + int(n))   // 正确：将 n 转换为 int

import "strconv"

func main() {
    // 整数转字符串
    s := strconv.Itoa(42)
    fmt.Println(s)   // "42"

    // 字符串转整数
    n, err := strconv.Atoi("42")
    if err == nil {
        fmt.Println(n)   // 42
    }
}

const Pi = 3.14159
const Language string = "Go"

func main() {
    const MaxRetries = 3
    fmt.Println(Pi, Language, MaxRetries)

    // 编译错误：cannot assign to MaxRetries
    // MaxRetries = 5
}

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

const (
    B = 1 << (iota * 10)   // iota = 0 → 1 << 0 = 1
    KB                     // iota = 1 → 1 << 10 = 1024
    MB                     // iota = 2 → 1 << 20 = 1048576
    GB                     // iota = 3 → 1 << 30 = 1073741824
)

const (
    A = iota   // 0
    _          // 1 被跳过
    C          // 2
)

func main() {
    name := "Go"
    year := 2009
    version := 1.22
    isStable := true

    fmt.Printf("name: %T = %v\n", name, name)        // name: string = Go
    fmt.Printf("year: %T = %d (%#v)\n", year, year, year)  // year: int = 42 (2009)
    fmt.Printf("version: %.1f\n", version)            // version: 1.2
    fmt.Printf("stable: %t\n", isStable)              // stable: true
    fmt.Printf("Go syntax: %#v\n", name)              // Go syntax: "Go"
}