Go 基础语法

var name string = "Go"        // 完整形式：var 名称 类型 = 值
var age int                    // 声明但未初始化，等于零值（0）
var name, age = "Go", 14      // 多变量声明 + 类型推断
var (                         // 批量声明块
    name   string = "Go"
    version int    = 23
    ok     bool   = true
)

// 只能在函数内使用！
name := "Go"                  // 类型推断为 string
age := 14                     // 类型推断为 int
name, ok := getValue()        // 部分变量已存在时，仅声明新变量

// Go 1.25 及之前：new(T) 仅接受类型，返回 *T（零值）
p := new(int)                     // *int，指向 0
user := new(User)                 // *User，所有字段零值

// Go 1.26+：new 支持带初始值的表达式，new(T) 旧用法不变
p := new(int64(300))              // *int64，指向 300（一行创建带值指针，实测）
u := new(User{Name: "Alice"})     // *User，复合字面量表达式同样合法（实测）

// 实用场景：JSON 可选字段
type Config struct {
    Timeout *int64 `json:"timeout,omitempty"`
}
cfg := Config{Timeout: new(int64(30))}  // Go 1.26：简洁
// 之前需要：t := int64(30); cfg := Config{Timeout: &t}

func demo() {
    x := 10
    if true {
        x := 20               // 新的局部 x，外部 x 不变（:= 总是声明新变量）
        fmt.Println(x)        // 20
    }
    fmt.Println(x)            // 10

    // vs 赋值（复用同一变量）
    y := 10
    if true {
        y = 20                // 修改外部 y
    }
    fmt.Println(y)            // 20

    // := 部分复用
    f, err := os.Open("a.txt")   // f 和 err 都是新的
    f2, err := os.Open("b.txt")  // err 复用，f2 是新的（err 在同一作用域）
}

a := 42                       // int（默认整数类型）
b := 3.14                     // float64（默认浮点类型）
c := "hello"                  // string
d := 1 + 2i                   // complex128
e := 'A'                      // rune（int32 别名）

package main

import (
	"fmt"
	"math"
)

func main() {
	// min / max：两个及以上参数，类型必须是同一有序类型（数值、字符串）
	fmt.Println(min(3, 1, 2), max(3, 1, 2))               // 1 3
	fmt.Println(min("apple", "banana"))                   // apple（字符串按字典序）

	// 无类型常量参数会自动适配目标类型
	x := min(3, 1.5)
	fmt.Printf("%v (%T)\n", x, x)                         // 1.5 (float64)

	// clear：map 删除所有键；切片所有元素置零值
	m := map[string]int{"a": 1, "b": 2}
	clear(m)
	fmt.Println(len(m), m == nil)                         // 0 false（map 仍在，只是空了）

	s := []int{1, 2, 3, 4}
	clear(s)
	fmt.Println(s, len(s), cap(s))                        // [0 0 0 0] 4 4（长度容量不变）

	// NaN 特殊行为：只要参与比较，min/max 都返回 NaN
	nan := math.NaN()
	fmt.Println(min(nan, 1.0), max(nan, 1.0))             // NaN NaN
}

const Pi = 3.14159                   // 无类型常量（更多灵活性）
const MaxSize int64 = 1 << 32        // 有类型常量

const (                              // 批量声明
    StatusOK    = 200
    StatusNotFound = 404
)

// iota：递增枚举器
const (
    Sunday = iota                    // 0
    Monday                           // 1
    Tuesday                          // 2
    Wednesday                        // 3
    Thursday                         // 4
    Friday                           // 5
    Saturday                         // 6
)

// 位掩码
const (
    FlagRead    = 1 << iota         // 1 (1 << 0)
    FlagWrite                       // 2 (1 << 1)
    FlagExec                        // 4 (1 << 2)
)

// 跳值
const (
    _ = iota                        // 0 跳过
    KB = 1 << (10 * iota)           // 1 << 10 = 1024
    MB                              // 1 << 20 = 1048576
    GB                              // 1 << 30
)

// 多表达式每行
const (
    X, Y = iota, iota * 2           // 0, 0
    A, B                            // 1, 2
    C, D                            // 2, 4
)

const huge = 1 << 100               // 无类型整数常量，精度远超 int64
fmt.Println(huge / (1 << 99))       // 2 — 编译期计算，不溢出

var x int64 = 1 << 62               // OK
var y int64 = 1 << 63               // 溢出 → 编译错误

b := 0b1010          // 二进制 → 10
o := 0o777           // 八进制 → 511
h := 0xFF            // 十六进制 → 255
n := 1_000_000       // 下划线分隔 → 1000000
m := 0xDE_AD_BE_EF   // 十六进制里同样可用 → 3735928559
f := 6.02e23         // 浮点科学计数（Println 输出 6.02e+23）

// 类型别名（Go 1.9+）：完全等同原类型
type MyInt = int                  // MyInt 和 int 完全相同
var a MyInt = 10
var b int = a                     // OK

// 类型定义：创建新类型
type MyInt int                    // MyInt 是基于 int 的新类型
var a MyInt = 10
var b int = a                     // 编译错误！需要显式转换
var b int = int(a)                // OK

var i int           // 0
var f float64       // 0.0
var s string        // ""
var b bool          // false
var p *int          // nil
var sl []int        // nil
var m map[int]int   // nil
var ch chan int     // nil
var fn func()       // nil
var in interface{}  // nil

var i int = 42
var f float64 = float64(i)        // 显式转换
var u uint = uint(f)

// 数值与字符串互转
import "strconv"

s := strconv.Itoa(42)             // int → string ("42")
n, err := strconv.Atoi("42")      // string → int (42, nil)
f, err := strconv.ParseFloat("3.14", 64)  // string → float64
b, err := strconv.ParseBool("true")       // string → bool

s := "hello"
bs := []byte(s)                   // string → []byte
rs := []rune(s)                   // string → []rune（按 Unicode 拆分）
s2 := string(bs)                  // []byte → string
s3 := string(rs)                  // []rune → string

esc := "line1\nline2\t中文"     // 解释字符串：\n \t 等转义生效
raw := `line1\nline2`           // 原始字符串（反引号）：所见即所得，\n 就是两个字符

fmt.Println(len(esc))           // 18（\n、\t 各占 1 字节，中文各 3 字节，实测）
fmt.Println(len(raw))           // 12（反斜杠+n 本身被计为 2 个字符，实测）

re := `^\d{3}-\d{4}$`           // 不用写成 "^\\d{3}-\\d{4}$"

s := "Go语言"
b := s[0]                // byte(uint8)  'G'
r := []rune(s)[2]        // rune(int32)  '语'  ——按码点定位，前两个 ASCII 各占 1 个码点
fmt.Printf("%T %c / %T %c\n", b, b, r, r)  // uint8 G / int32 语（实测）

s := "Hello, 世界"               // Go 源码和字符串都是 UTF-8

// 长度（字节数，不是字符数！）
len(s)                            // 13（每个中文字符 3 字节）

// 字符数
import "unicode/utf8"
utf8.RuneCountInString(s)         // 9

// 遍历字符（不是字节）
for i, r := range s {
    fmt.Printf("%d: %c\n", i, r)  // r 是 rune 类型
}

// 索引（按字节）
s[0]                              // 'H' (byte)
s[7]                              // 字节，不完整的中文字符！不要这么做

// 字符串不可变
s[0] = 'h'                        // 编译错误！cannot assign to s[0]

s1 := "hello"
s2 := "world"

// 方式一：+ 运算符（少量拼接用）
s := s1 + ", " + s2

// 方式二：fmt.Sprintf（需要格式化时）
s := fmt.Sprintf("%s, %s", s1, s2)

// 方式三：strings.Builder（大量拼接，性能最优）
var builder strings.Builder
builder.WriteString(s1)
builder.WriteString(", ")
builder.WriteString(s2)
s := builder.String()

// 方式四：strings.Join（拼接切片）
s := strings.Join([]string{s1, s2}, ", ")

fmt.Printf("type=%T, value=%v\n", x, x)
fmt.Printf("struct with names: %+v\n", myStruct)
fmt.Printf("source code: %#v\n", myStruct)

multi := fmt.Errorf("batch failed: %w / %w", errA, errB)  // 合法（实测）
// errors.Is(multi, errA) 与 errors.Is(multi, errB) 均为 true

s := "你好"
fmt.Println(len(s))              // 6（每个中文字符 3 字节）
fmt.Println(utf8.RuneCountInString(s))  // 2（这才是字符数）

// 遍历字符串请用 for range，它会正确解码 UTF-8
for _, r := range s {
    fmt.Printf("%c", r)           // 你 好
}

s := "你好"
fmt.Printf("%c\n", s[0])          // ä（乱码！只是 "你" 的第一个 UTF-8 字节）
fmt.Printf("%c\n", []rune(s)[0])  // 你（正确）

const (
    A = iota                      // 0
    B                             // 1
)

const (
    C = iota                      // 0（重置了！）
)

var err error
if true {
    result, err := doSomething()  // 这是新的 err！外部 err 没被赋值
}
// 外部 err 仍然是 nil！

// 32 位机器上 int = int32，64 位机器上 int = int64
// 需要明确位数的场景（如二进制协议、文件格式）用 int64/uint32 等
var timestamp int64 = time.Now().Unix()

a := 0.1
b := 0.2
c := 0.3
fmt.Println(a+b == c)             // false! 浮点精度问题
fmt.Println(math.Abs(a+b-c) < 1e-9)  // true（正确比较方式）

v := min(math.NaN(), 1.0)         // NaN，不是 1.0（实测）

m := map[string]int{"a": 1}
clear(m)
fmt.Println(m == nil)             // false（map 还在，只是空，实测）
var arr [3]int
clear(arr)                        // 编译错误：argument must be (or constrained by) map or slice（实测）