go语言学习笔记 — 基本语法 — 变量（2）：多个变量的初始化声明与赋值_golang 多个变量声明的方法

1. 多个变量的声明方式

• 多个变量声明与赋值（声明全局变量、局部变量）

// 为类型相同的多个变量赋值, 非全局变量

var vname1, vname2, vname3 type
vname1, vname2, vname3 = v1, v2, v3
1
2
3
4

• 并行赋值

var vname1, vname2, vname3 type = v1, v2, v3
1

自动类型推断

// 和python很像，不需要显示声明类型，自动推断

var vname1, vname2, vname3 = v1, v2, v3 
1
2
3

• 最简写法（只能在函数体内部使用）

在相同的代码块中，我们不可以再次对于相同名称的变量使用初始化声明，例如：a := 20 就是不被允许的，编译器会提示错误 no new variables on left side of :=，但是 a = 20 是可以的，因为这是给相同的变量赋予一个新的值。

// 出现在:=左侧的变量不应该是已经被声明过的，否则会导致编译错误

vname1, vname2, vname3 := v1, v2, v3
1
2
3

在多个短变量声明和赋值中，最简写法需要至少有一个新声明的变量出现在左值中，即使其他变量名可能是重复声明的，编译器也不会报错。

conn, err = net.Dial("tcp", "127.0.0.1:8080)

conn2, err = net.Dial("tcp", "127.0.0.1:8080)
1
2
3

2. 声明的地方

• 全局变量组声明：var()，因式分解写法（只用于全局变量的声明）

可以使用并行方式和自动类型推断，不可以用最简写法，因为:用于代替var关键字，而前面var()已经有了var。

// 这种因式分解关键字的写法一般用于声明全局变量

var (
    vname1 type1
    vname2 type2
)
1
2
3
4
5
6

• 函数体内部变量声明

使用上述常见的4种变量声明方式即可。例子：

package main

import (
	"fmt"
)

// 全局变量组声明（var()因式分解写法）
var (
	aaa = "hello"      // 1. 使用常规方式
	ddd, bbb = 1, 2    // 2. 使用并行方式及自动类型推断
	// ccc := 3        // 3. 在var()中，不可以用最简写法。因为:用于代替var关键字，而前面已经有了var
)

// 函数体内部局部变量声明
func main() {
	// 1. 多个变量声明与赋值（用于函数体内部的局部变量声明）
	var a, b, c, d int
	a, b, c, d = 1, 2, 3, 4

	// 2. 并行方式
	var e, f, g, h int = 5, 6, 7, 8

	// 3. 自动类型推断
	var i, j, k, l = 9, 10, 11, 12

	// 4. 最简写法
	l, m, n, o := 13, 14, 15, 16

	fmt.Println(aaa, bbb, ddd)
	fmt.Println(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

注意：

• 全局变量的声明可使用var()因式分解写法进行简写。全局变量的声明不可以省略var，但可使用并行方式、自动类型推断

• 所有变量都可以使用自动类型推断

• 函数体内部的局部变量不建议使用var()因式分解写法简写，能使用并行方式、自动类型推断、最简写法

• 变量在定义之前，不能使用它，否则会报编译错误undefined: a

• 如果声明了一个局部变量却没有在相同的代码块中使用它，同样会得到编译错误a declared and not used；但是全局变量是允许声明但不使用

package main

import "fmt"

var b = 1

func main() {
	var a string = "abc"
	fmt.Println("hello, world", a)
}
1
2
3
4
5
6
7
8
9
10

• 如果你想要交换两个变量的值，则可以简单地使用a, b = b, a，前提是两个变量的类型必须相同

• 空白标识符_也被用于抛弃变量值，如值5在 _, b = 5, 7 中被抛弃了。_实际上是一个只写变量，你不能得到它的值。这样做是因为 Go 语言中你必须使用所有被声明的变量，但有时你并不需要使用一个函数的所有返回值

• 并行赋值也被用于当一个函数返回多个返回值时，比如这里的 val 和错误 err 是通过调用 Func1 函数同时得到：val, err = Func1(var1)

3. 实例：交换两个变量的值

交换变量的常见算法需要一个中间变量进行变量的临时保存。用传统方法编写变量交换代码如下：

package main 

import (
    "fmt"
)

func main() {
    var a int = 100
    var b int = 200 
    var t int = 300

    t = a
    a = b
    b = t
    
    fmt.Println(a, b)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

现在，内存不再是紧缺资源，使用go语言写法可以更简单。使用go语言的"多重赋值"特性，可以轻松完成交换变量的任务：

package main 

import (
    "fmt"
)

func main() {
    var a int = 100
    var b int = 200 
    
    b, a = a, b
    
    fmt.Println(a, b)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

注：

• 多重赋值时，变量的左值和右值按从左到右，一一对应的顺序赋值

• 多重赋值在go语言的错误处理和函数返回值中会大量地使用

package main

import (
	"fmt"
)

type IntSlice []int

func (p IntSlice) Len() int {
	return len(p)
}

func (p IntSlice) Less(i, j int) bool {
	return p[i] < p[j]
}

func (p IntSlice) Swap(i, j int) IntSlice {
	p[i], p[j] = p[j], p[i]
	return p
}

func main() {
	var a IntSlice

	a = []int{1, 2, 3}

	fmt.Println(a.Len())
	fmt.Println(a.Less(1, 2))
	fmt.Println(a.Swap(1, 2))
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30