1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

var a int                  // 1. 只有类型，得到零值 0
var b = 42                 // 2. 只有初值，类型推断为 int
var c int = 42             // 3. 类型 + 初值
var d, e = 1, "two"        // 4. 批量，类型各自推断
var f, g int               // 5. 批量同类型，都是 0

var (                      // 6. 分组声明，包级最常用
	host string
	port int
	debug bool
)
fmt.Println(a, b, c, d, e, f, g, host, port, debug)

1

0 42 42 1 two 0 0  0 false

1
2
3
4
5
6
7

var (
	ErrNotFound = errors.New("not found")
	ErrConflict = errors.New("conflict")

	defaultTimeout = 30 * time.Second
	maxRetries     = 3
)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

func f() (int, error) { return 1, nil }

func demo() error {
	f, err := os.Open("a.txt")   // f 与 err 都是新变量
	if err != nil {
		return err
	}
	defer f.Close()

	n, err := f.Read(make([]byte, 10))  // ✅ n 是新的，err 被复用（不是新变量）
	_ = n
	return err
}

1
2
3
4
5
6
7
8

func bad() error {
	var err error
	if true {
		result, err := doSomething()   // ⚠️ 这是【新的】err，遮蔽了外面的
		_ = result
	}
	return err                          // 永远是 nil，外层的 err 从未被赋值
}

1
2
3
4
5
6
7
8

// ✅ 方案 A：把声明提到外面，用 = 赋值
var result string
result, err = doSomething()

// ✅ 方案 B：拆开，先声明 result
var result string
var err error
result, err = doSomething()

1
2
3
4
5
6
7

x := 1
fmt.Println("outer x =", x)
{
	x := 2                        // 新变量，遮蔽外层
	fmt.Println("inner x =", x)
}
fmt.Println("outer x =", x)

1
2
3

outer x = 1
inner x = 2
outer x = 1

1
2
3
4
5
6

if v, err := compute(); err == nil {
	fmt.Println(v)
} else {
	fmt.Println("failed:", err)   // ✅ else 里也能用 err
}
// fmt.Println(v)                 // 🛑 编译错误：v 不在作用域内

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

const big = 1 << 100      // 无类型，编译期不溢出
const small = big >> 99   // 仍然是常量表达式
fmt.Println(small)        // 2
fmt.Printf("%T\n", small)  // int（赋值/传参时才取默认类型）

// fmt.Println(big)       // 🛑 编译错误：constant overflows int
fmt.Println(float64(big)) // ✅ 1.2676506002282294e+30，先显式转换

const typed int8 = 100    // 有类型，受 int8 范围约束
fmt.Printf("%T\n", typed)  // int8

1
2
3
4

2
int
1.2676506002282294e+30
int8

1
2
3
4
5
6

const N = 10
var arr [N]int          // ✅ 数组长度必须是常量
// var arr2 [len(someSlice)]int   // 🛑 编译错误：长度不是编译期常量

const s = "hello"
const sl = len(s)       // ✅ 常量的 len 仍是常量 🆕 1.0 起内置函数对常量可用

1
2
3
4
5
6
7
8

type Color int

const (
	Red Color = iota // 0
	Green            // 1
	Blue             // 2
)
fmt.Println(Red, Green, Blue)

1

0 1 2

1
2
3
4

func (c Color) String() string {
	return [...]string{"Red", "Green", "Blue"}[c]
}
fmt.Println(Red, Green, Blue)   // Red Green Blue

1
2
3
4
5
6

const (
	_ = iota // 丢弃 0
	A        // 1
	B        // 2
)
fmt.Println(A, B)

1

1 2

1
2
3
4
5
6
7

const (
	FlagRead = 1 << iota // 1
	FlagWrite            // 2
	FlagExec             // 4
)
fmt.Println(FlagRead, FlagWrite, FlagExec)
fmt.Println(FlagRead|FlagWrite, FlagRead&FlagWrite, FlagRead&^FlagWrite)

1
2

1 2 4
3 0 1

1
2
3
4
5
6
7

const (
	_  = iota
	KB = 1 << (10 * iota)   // 1024
	MB                      // 1048576
	GB                      // 1073741824
)
fmt.Println(KB, MB, GB)

1

1024 1048576 1073741824

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

type ByteSize float64

const (
	_           = iota
	KB1 ByteSize = 1 << (10 * iota)   // 有类型：ByteSize
	MB1
)
const (
	_   = iota
	KB2 = 1 << (10 * iota)            // 无类型常量
	MB2
)
fmt.Println(KB2, MB2)     // 1024 1048576          ← 无类型常量：整数
fmt.Println(KB1, MB1)     // 1024 1.048576e+06     ← ByteSize：浮点显示 ⚠️
fmt.Printf("%T\n", KB1)   // main.ByteSize

1
2
3

1024 1048576
1024 1.048576e+06
main.ByteSize

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

const (
	_  = iota
	KB3 = 1 << (10 * iota)
)
// 或用表达式做任意步长
const (
	_ = iota * 100   // 0
	X                // 100
	Y                // 200
)
fmt.Println(X, Y)

1

100 200

1
2
3
4
5

const (
	A1, B1 = iota, iota + 1   // iota=0 → A1=0, B1=1
	C1, D1 = iota, iota + 1   // iota=1 → C1=1, D1=2
)
fmt.Println(A1, B1, C1, D1)

1

0 1 1 2

1
2

const N = 5
// p := &N     // 🛑 编译错误：cannot take the address of N

1
2
3
4

m := map[string]int{}
m["a"]++        // 未存在也安全，零值 0 自增为 1
m["a"] += 5
fmt.Println(m["a"])

1
2

1
6