变量命名

命名方法

var name type是定义单一变量的语法

1package main
2
3import "fmt"
4
5func main(){
6    var age int	//variable declaration
7    fmt.Println("My age is",age)
8}

该语句中var age int声明了一个名为age的int类型变量. 但是并没有进行赋值, 这种情况下该类行变量被赋予0为他的初始值.

输出:

my age is 0

一个变量可以被分配任意该类型的值. 该程序中的age变量可以被赋予一个任意的integer value

1package main
2
3import "fmt"
4
5func main(){
6    var age int //variable declaration
7    fmt.Println("my age is",age)
8    age = 18 //assignment
9    fmt.Println("my age is ",age)
10    age = 19 // assignment
11    fmt.Println("next year I will be", age, "years old boy")
12}

output:

1my age is 0
2my age is 18
3next year I will be 19 years old boy

声明变量并赋初值

声明变量同时可以赋予初始值

var name type = initial_value

1package main
2
3import "fmt"
4
5func main(){
6    var age int = 18 //variable declaration with initial value;(my age is 18)
7    fmt.Println("my age is", age)
8}

in the above program, age被声明并赋予初值18,如果你运行above program,你会得到following output:

my age is 18

类型推断 (type inference)

如果variable具有一个initial value, 那么go会自动根据initial value to infer the type of that variable.

所以, 如果你的变量具有initial value, 则可以省略便来嗯声明中的type.

使用var name = initial_value声明变量时,go会根据initial value自动推断变量类型.

in the following example, 我们声明变量age时把type省略掉, 但是赋予了age一个初始值, go会根据这个initial value推断得到变量的类型是int

1package main
2
3import "fmt"
4
5func main(){
6    var age = 100
7    fmt.Println("my age is", age)
8}

定义多个变量 in a single statement

多个变量可以一起声明

var name1, name2 type = initialvalue1, initialvalue2 单次声明多个变量

1package main
2
3import "fmt"
4
5func main(){
6    var width, height int = 1920, 1080 //declaring multiple variables
7    fmt.Println(width, "x", height)
8}

这里声明变量中的type也可以省略, 使用go语言的特性推断出变量类型

1package main
2
3import "fmt"
4
5func main(){
6    var width, height = 1920, 1080 //type is dropped
7    fmt.Println(width, "x", height)
8}

out put

1920 x 1080

当然我们也可以不赋初值, 只是定义两个默认初值的变量

1package main
2
3import "fmt"
4
5func main(){
6    var width, heiht int
7    fmt.Println(width, height)
8    width = 1920
9    height = 1080
10    fmt.Println(width, height)
11}

the above program will print.

output:

0 0

1920 1080

某些情况下,我们在单个语句中声明属于不同类型的变量, 语法应该是:

1var(
2	name1 = initial value1
3    name2 = initial value2
4)

下述程序使用该语法声明不同类型的变量

1package main
2
3import "fmt"
4
5func main(){
6    var(
7    	name = "Gee"
8        age = 18
9        height int
10    )
11    fmt.Println("My name is", name, "age is",age, "and height is", height)
12}

输出My name is Gee age is 18 and height is 0

简单的声明

Go 还提供了一种简洁的变量声明方式: name := initialvalue,使用:=代替var

1package main
2
3import "fmt"
4
5func main(){
6    name, age := "Gee", 18
7    fmt.Println("my name is", name, "age is", age)
8}

输出:my name is Gee age is 18

这样的声明需要把左侧所有的变量都进行赋值.否则会报错cannot assign n values to m variables.

1package main
2
3import "fmt"
4
5func main(){
6    name, age := "Gee" //error
7    name, age := "Gee", 18 //correctness
8    fmt.Println(name, age)
9}

使用该声明方法时,左侧必须有至少一个变量是新声明的,参考以下程序:

1package main
2
3import "fmt"
4
5func main(){
6    a, b := 1, 2 //declare variables a ,b
7    fmt.Println(a, b)
8    b, c := 3, 4//b is already declared but c is new
9    fmt.Println(b, c)
10    b, c = 5, 6//assign new values to already declared variables b and c
11    fmt.Println(b, c)
12}

在上面的程序中, 第八行中的b已经被声明过了, 但是c是新声明的; 10 行中b, c都已经存在了, 所以不能再使用:=声明, 只能使用=进行赋值. 如果line No.10 使用:= 进行声明, 则会报错no new variables on left side of :=

输出:

1 2

3 4

5 6

赋值的时候也可以为变量分配运行计算的值. for example:

1package main
2
3import "fmt","math"
4
5func main(){
6    a, b := 199.9999, 200.0000
7    c := math.Min(a,b)
8    fmt.Println('minimum value is',c)
9}

output:`minimum value is 199.9999

最后:

Go是强类型语言, 如果我们声明了一个变量,然后再赋值给他一个其他类型的值, 那么go会抛出异常:cannot use "naveen" (type string) as type int in assignment

如图所示:

参考