2018-07-26 | go

go初探-变量

总结

1.变量推断
2.可以声明多个变量
3.在一个语句中声明不同类型的变量
4.简短声明，并且简短声明的语法要求 := 操作符的左边至少有一个变量是尚未声明的，否则会抛出 no new variables on left side of := 的错误
5.变量也可以在运行时进行赋值
6.Go 是强类型（Strongly Typed）语言，因此不允许某一类型的变量赋值为其他类型的值。

变量是什么

变量指定了某存储单元（Memory Location）的名称，该存储单元会存储特定类型的值。在 Go 中，有多种语法用于声明变量。

声明单个变量

var name type 是声明单个变量的语法。

package main

import "fmt"

func main() {
    var age int // 变量声明
    fmt.Println("my age is", age)
}

语句 var age int 声明了一个 int 类型的变量，名字为 age。我们还没有给该变量赋值。如果变量未被赋值，Go 会自动地将其初始化，赋值该变量类型的零值（Zero Value）。本例中 age 就被赋值为 0。如果你运行该程序，你会看到如下输出：

age is 0```

1 2	变量可以赋值为本类型的任何值。上一程序中的 age 可以赋值为任何整型值（Integer Value）。

package main

import “fmt”

func main() {
var age int // 变量声明
fmt.Println(“my age is”, age)
age = 29 // 赋值
fmt.Println(“my age is”, age)
age = 54 // 赋值
fmt.Println(“my new age is”, age)
}

输出

my age is 0
my age is 29
my new age is 54

1
2
3


# 声明变量并初始化
声明变量的同时可以给定初始值。 var name type = initialvalue 的语法用于声明变量并初始化。

package main

import “fmt”

func main() {
var age int = 29 // 声明变量并初始化

fmt.Println("my age is", age)

}

输出

my age is 29



# 类型推断（Type Inference）

如果变量有初始值，那么 Go 能够自动推断具有初始值的变量的类型。因此，如果变量有初始值，就可以在变量声明中省略 type。

如果变量声明的语法是 var name = initialvalue，Go 能够根据初始值自动推断变量的类型。

在下面的例子中，你可以看到在第 6 行，我们省略了变量 age 的 int 类型，Go 依然推断出了它是 int 类型。

func myageType() {
var age = 25
fmt.Println(“my age is”,age)
}


# 声明多个变量
Go 能够通过一条语句声明多个变量。
声明多个变量的语法是 var name1, name2 type = initialvalue1, initialvalue2。

//声明多个变量
func anyVariables(){
var width,height int
fmt.Println(“heightis”,height,”width is”,width)
width,height = 100,25
fmt.Println(“heightis”,height,”width is”,width)
}

1 2	在有些情况下，我们可能会想要在一个语句中声明不同类型的变量。其语法如下：

var (
name1 = initialvalue1,
name2 = initialvalue2
)

1	使用上述语法，下面的程序声明不同类型的变量。

func anyVariablesdif() {
var(
name = “andy”
age = 28
height int
)
height = 185
fmt.Println(“name”,name,”age”,age,”height”,height)
}


# 简短声明
Go 也支持一种声明变量的简洁形式，称为简短声明（Short Hand Declaration），该声明使用了 := 操作符。
声明变量的简短语法是 name := initialvalue。

func easyfun() {
name,age := “andy”,29//简短声明
fmt.Println(“my name is”,name,”age is”,age)
}


运行上面的程序，可以看到输出为 my name is naveen age is 29。

简短声明要求 := 操作符左边的所有变量都有初始值。下面程序将会抛出错误 cannot assign 1 values to 2 variables，这是因为 age 没有被赋值。

package main

import “fmt”

func main() {
name, age := “naveen” //error

fmt.Println("my name is", name, "age is", age)

}

1 2	简短声明的语法要求 := 操作符的左边至少有一个变量是尚未声明的。考虑下面的程序：

func easyfunc2(){
a, b := 20, 30 // 声明变量a和b
fmt.Println(“a is”, a, “b is”, b)
b, c := 40, 50 // b已经声明，但c尚未声明
fmt.Println(“b is”, b, “c is”, c)
b, c = 80, 90 // 给已经声明的变量b和c赋新值
fmt.Println(“changed b is”, b, “c is”, c)
}

1 2	但是如果我们运行下面的程序:

package main

import “fmt”

func main() {
a, b := 20, 30 // 声明a和b
fmt.Println(“a is”, a, “b is”, b)
a, b := 40, 50 // 错误，没有尚未声明的变量
}


上面运行后会抛出 no new variables on left side of := 的错误，这是因为 a 和 b 的变量已经声明过了，:= 的左边并没有尚未声明的变量。

变量也可以在运行时进行赋值。考虑下面的程序：

package main

import (
“fmt”
“math”
)

func main() {
a, b := 145.8, 543.8
c := math.Min(a, b)
fmt.Println(“minimum value is “, c)
}



在上面的程序中，c 的值是运行过程中计算得到的，即 a 和 b 的最小值。上述程序会打印：

``minimum value is  145.8``

由于 Go 是强类型（Strongly Typed）语言，因此不允许某一类型的变量赋值为其他类型的值。下面的程序会抛出错误 cannot use "naveen" (type string) as type int in assignment，这是因为 age 本来声明为 int 类型，而我们却尝试给它赋字符串类型的值。

package main

func main() {
age := 29 // age是int类型
age = “naveen” // 错误，尝试赋值一个字符串给int类型变量
}
`