【Golang】变量

变量声明

可以一次声明多个变量：

1
var identifier1, identifier2 type

实例2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package main
import "fmt"

var c, python, java bool

func main() {
  var a string = "test"
  fmt.Println(a)

  var b, c int = 1, 2
  fmt.Println(b, c)
  
  var i int
	fmt.Println(i, c, python, java)
}

以上实例输出结果为：

1
2
test
1 2

  • 数值类型（包括complex64/128）为 0

  • 布尔类型为 false

  • 字符串为 “”（空字符串）

  • 以下几种类型为 nil：

    1
    2
    3
    4
    5
    6
    var a *int
    var a []int
    var a map[string] int
    var a chan int
    var a func(string) int
    var a error // error 是接口

实例

1
2
3
4
5
6
7
8
9
10
11
package main

import "fmt"

func main() {
  var i int
  var f float64
  var b bool
  var s string
  fmt.Printf("%v %v %v %q\n", i, f, b, s)
}

输出结果是：

1
0 0 false ""

根据值自行判定变量类型

1
var v_name = value

实例

1
2
3
4
5
6
package main
import "fmt"
func main() {
  var d = true
  fmt.Println(d)
}

输出结果是：

1
true

省略 var

Inside a function, the := short assignment statement can be used in place of a var declaration with implicit type.

Outside a function, every statement begins with a keyword (var, func, and so on) and so the := construct is not available.

注意 *:=* 左侧如果没有声明新的变量，就产生编译错误，格式：

1
v_name := value

例如：

1
2
3
4
5
var intVal int 

intVal :=1 // 这时候会产生编译错误

intVal,intVal1 := 1,2 // 此时不会产生编译错误，因为有声明新的变量，因为 := 是一个声明语句

可以将 var f string = “Runoob” 简写为 f := “Runoob”：

实例

1
2
3
4
5
6
7
package main
import "fmt"
func main() {
  f := "Runoob" // var f string = "Runoob"

  fmt.Println(f)
}

输出结果是：

1
Runoob

多变量声明

1
2
3
4
5
6
7
8
9
10
11
12
13
14
//类型相同多个变量, 非全局变量
var vname1, vname2, vname3 type
vname1, vname2, vname3 = v1, v2, v3

var vname1, vname2, vname3 = v1, v2, v3 // 和 python 很像,不需要显示声明类型，自动推断

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


// 这种因式分解关键字的写法一般用于声明全局变量
var (
    vname1 v_type1
    vname2 v_type2
)

实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package main

var x, y int
var ( *// 这种因式分解关键字的写法一般用于声明全局变量*
  a int
  b bool
)

var c, d int = 1, 2
var e, f = 123, "hello"

*//这种不带声明格式的只能在函数体中出现*
*//g, h := 123, "hello"*

func main(){
  g, h := 123, "hello"
  println(x, y, a, b, c, d, e, f, g, h)
}

以上实例执行结果为：

1
0 0 0 false 1 2 123 hello 123 hello

常量声明（const）

1
const identifier [type] = value

你可以省略类型说明符 [type]，因为编译器可以根据变量的值来推断其类型。

  • 显式类型定义： const b string = "abc"
  • 隐式类型定义： const b = "abc"

多个相同类型的声明可以简写为：

1
const c_name1, c_name2 = value1, value2

以下实例演示了常量的应用：

实例

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

import "fmt"

func main() {
  const LENGTH int = 10
  const WIDTH int = 5 
  var area int
  const a, b, c = 1, false, "str" *//多重赋值*

  area = LENGTH * WIDTH
  fmt.Printf("面积为 : %d", area)
  println()
  println(a, b, c) 
}

以上实例运行结果为：

1
2
面积为 : 50
1 false str

Default Values

Variables declared without an explicit initial value are given their zero value.

The zero value is:

  • 0 for numeric types,
  • false for the boolean type, and
  • "" (the empty string) for strings.
1
2
3
4
5
6
7
8
9
10
11
12
package main

import "fmt"

func main() {
	var i int
	var f float64
	var b bool
	var s string
	fmt.Printf("%v %v %v %q\n", i, f, b, s)
}
//output 0 0 false ""

变量作用域

局部变量

在函数体内声明的变量称之为局部变量，它们的作用域只在函数体内，参数和返回值变量也是局部变量。

以下实例中 main() 函数使用了局部变量 a, b, c：

实例

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

import "fmt"

func main() {
  */\* 声明局部变量 \*/*
  var a, b, c int

  */\* 初始化参数 \*/*
  a = 10
  b = 20
  c = a + b

  fmt.Printf ("结果： a = %d, b = %d and c = %d\n", a, b, c)
}

以上实例执行输出结果为：

1
结果： a = 10, b = 20 and c = 30

全局变量

在函数体外声明的变量称之为全局变量，全局变量可以在整个包甚至外部包（被导出后）使用。

全局变量可以在任何函数中使用，以下实例演示了如何使用全局变量：

实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package main

import "fmt"

*/\* 声明全局变量 \*/*
var g int

func main() {

  */\* 声明局部变量 \*/*
  var a, b int

  */\* 初始化参数 \*/*
  a = 10
  b = 20
  g = a + b

  fmt.Printf("结果： a = %d, b = %d and g = %d\n", a, b, g)
}

以上实例执行输出结果为：

1
结果： a = 10, b = 20 and g = 30

Go 语言程序中全局变量与局部变量名称可以相同，但是函数内的局部变量会被优先考虑。实例如下：

实例

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

import "fmt"

*/\* 声明全局变量 \*/*
var g int = 20

func main() {
  */\* 声明局部变量 \*/*
  var g int = 10

  fmt.Printf ("结果： g = %d\n", g)
}

以上实例执行输出结果为：

1
结果： g = 10

形式参数

形式参数会作为函数的局部变量来使用。实例如下：

实例

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
package main

import "fmt"

*/\* 声明全局变量 \*/*
var a int = 20;

func main() {
  */\* main 函数中声明局部变量 \*/*
  var a int = 10
  var b int = 20
  var c int = 0

  fmt.Printf("main()函数中 a = %d\n", a);
  c = sum( a, b);
  fmt.Printf("main()函数中 c = %d\n", c);
}

*/\* 函数定义-两数相加 \*/*
func sum(a, b int) int {
  fmt.Printf("sum() 函数中 a = %d\n", a);
  fmt.Printf("sum() 函数中 b = %d\n", b);

  return a + b;
}

以上实例执行输出结果为：

1
2
3
4
main()函数中 a = 10
sum() 函数中 a = 10
sum() 函数中 b = 20
main()函数中 c = 30

初始化局部和全局变量

不同类型的局部和全局变量默认值为：

数据类型 初始化默认值
int 0
float32 0
pointer nil

扫一扫，分享到微信