Go语言 变量

导言

• 原文链接: Part 3: Variables
• If translation is not allowed, please leave me in the comment area and I will delete it as soon as possible.

变量

变量是什么？

变量就是一个名称，它能标识一个内存地址，该内存地址存储了具体类型的数值。 (文字描述很抽象，看看代码就懂了)

声明一个变量

通过 var name type句式，我们能声明一个变量。

package main

import "fmt"

func main() {  
    var age int // variable declaration
    fmt.Println("my age is", age)
}

在上面的代码中，var age int语句，声明了一个类型为 int 的 age变量。

注意到，在声明 age变量 时，我们并没有为 age变量 赋予初值。

在 Go 中，如果变量声明时没被赋予初值，该变量将等于对应类型的 零值。 对于上面的例子来说，age变量 声明后将等于 0 — 0 是 int类型 的零值。

运行程序，输出如下：

my age is 0  

我们可以将 对应类型的任意数值 赋值给变量。对于上面的例子来说，我们可以将任意 int类型数值 分配给 age变量。

通过下面的代码进行验证：

package main

import "fmt"

func main() {  
    var age int // variable declaration
    fmt.Println("my age is ", age)
    age = 29 //assignment
    fmt.Println("my age is", age)
    age = 54 //assignment
    fmt.Println("my new age is", age)
}

程序输出如下：

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

声明有初始值的变量

在变量声明时，我们可以给它赋予初值。

使用 var name type = initialvalue 句式，我们就能声明一个有初值的变量。

package main

import "fmt"

func main() {  
    var age int = 29 // variable declaration with initial value

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

在上面的程序中，age是一个 int类型 的变量，它的初值为 29。

程序输出如下：

my age is 29  

类型推断

如果变量声明时具有初值，那 Go 会通过初值，自动推断出变量的类型，此时我们可以不用写类型声明。

使用 var name = initialvalue 句式，Go语言 就能帮我们推断出变量类型了。

来看代码：

package main

import "fmt"

func main() {  
    var age = 29 // type will be inferred

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

在上面的例子中，声明 age变量 时，我们为它赋予了初值 29。编译器会通过 初值29，推断出 age变量 的类型。

程序输出如下：

my age is 29

多变量声明

使用多变量声明，我们能在一条语句中声明多个变量。

var name1, name2 type = initialvalue1, initialvalue2 就是多变量声明的句式。

package main

import "fmt"

func main() {  
    var width, height int = 100, 50 //declaring multiple variables

    fmt.Println("width is", width, "height is", height)
}

如果变量有初始值，变量的类型声明可以省略。我们可以利用这个规则，重写上面的程序。

最终代码如下：

package main

import "fmt"

func main() {  
    var width, height = 100, 50 //"int" is dropped

    fmt.Println("width is", width, "height is", height)
}

程序输出如下：

width is 100 height is 50

如你所想，对于上面的程序，如果我们没有给 width、height 指定初始值，它们都将等于 0。

package main

import "fmt"

func main() {  
    var width, height int
    fmt.Println("width is", width, "height is", height)
    width = 100
    height = 50
    fmt.Println("new width is", width, "new height is ", height)
}

输出如下：

width is 0 height is 0  
new width is 100 new height is  50  

下面也是一种多变量声明的句式：

var (  
      name1 = initialvalue1
      name2 = initialvalue2
)

实例代码如下：

package main

import "fmt"

func main() {  
    var (
        name   = "naveen"
        age    = 29
        height int
    )
    fmt.Println("my name is", name, ", age is", age, "and height is", height)
}

在上面的程序中，我们声明了 string类型 的 变量name，以及 int类型 的 age、height。(在 下一节 中，我们会讨论变量类型)

运行程序，输出如下：

name is naveen , age is 29 and height is 0

快捷声明

Go 还提供了一种声明变量的简便方法，我们将这种方法叫做快捷声明。
name := initialvalue 是快捷声明的句式。

看代码：

package main

import "fmt"

func main() {  
    name, age := "naveen", 29 // 快捷声明

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

程序输出如下：

my name is naveen age is 29

使用快捷声明时，我们必须为 := 左边的变量赋予初值。

看个代码：

package main

import "fmt"

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

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

上面的程序会抛出错误，因为我们没给 age 赋予初值。

错误如下：

cannot assign 1 values to 2 variables

快捷声明至少要产生一个新变量，否则将会导致错误。

看看下面的程序：

package main

import "fmt"

func main() {  
    a, b := 20, 30 // declare variables a and b
    fmt.Println("a is", a, "b is", b)
    b, c := 40, 50 // b is already declared but c is new
    fmt.Println("b is", b, "c is", c)
    b, c = 80, 90 // assign new values to already declared variables b and c
    fmt.Println("changed b is", b, "c is", c)
}

在上面程序的第 8 行，此时 b 已经声明过了，但 c 还未被声明，也就是说，该快捷句式能产生一个 新变量c。

程序会正常运行，输出如下：

a is 20 b is 30  
b is 40 c is 50  
changed b is 80 c is 90  

将代码修改一下，修改后的代码如下：

package main

import "fmt"

func main() {  
    a, b := 20, 30 //a and b declared
    fmt.Println("a is", a, "b is", b)
    a, b := 40, 50 //error, no new variables
}

在第 8 行，此时 a、b 都已经声明过了，也就是说，快捷声明(a, b := 40, 50) 不能产生新变量。

运行程序，错误如下：

no new variables on left side of :=

在程序运行时，我们可以为变量重新赋值。

这主要与常量相区别，常量只能在编译时赋值，之后便不能修改。
关于这些，我们将在之后讨论。有兴趣可以先看这篇： Go语言 常量 。

看看下面的代码：

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 的值是在程序运行时被赋予的。

关于函数，我们将在 Go语言 函数 部分讲解。

程序运行如下：

minimum value is  145.8 

Go 是强类型语言，变量只能拥有一个类型。

看看代码：

package main

func main() {  
    age := 29      // age is int
    age = "naveen" // error since we are trying to assign a string to a variable of type int
}

在上面的程序中，age 的类型是 int，但我们却试图把 string类型 的 "naveen" 赋予它。

运行这个程序，你会看到如下错误信息：

cannot use "naveen" (type string) as type int in assignment

这就是变量了~

祝你每天有朝气~

原作者留言

优质内容来之不易，您可以通过该 链接 为我捐赠。

最后

感谢原作者的优质内容。

欢迎指出文中的任何错误。