Go语言变量学习

您可以阅读Golang 教程第 2 部分：如何运行Hello World以及IDE介绍

什么是变量？

变量是为存储特定类型值的内存位置指定的名称。Go 中有多种声明变量的语法。让我们一一看看。

声明单个变量

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

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)
}

Run in playground

上面的程序将打印以下输出。

My age is  0  
My age is 29  
My new age is 54  

该语句声明了一个名为类型的var age int变量。我们还没有为该变量分配任何值。如果一个变量没有被赋予任何值，Go 会自动用该变量类型的**零值来初始化它。**变量可以分配给其类型的任何值。在上面的程序中，age可以赋予任意整数值。

声明一个具有初始值的变量

var name type = initialvalue 声明变量时也可以为其提供初始值这是声明具有初始值的变量的语法。

package main

import "fmt"

func main() {  
    var age int = 29
    fmt.Println("My age is", age)
}

Run in playground

在上面的程序中，age是一个类型变量int并且具有初始值29。上面的程序将打印以下输出。

My age is 29  

类型推断

如果一个变量有一个初始值，Go 将自动使用该初始值推断该变量的类型。因此，如果变量有初始值，则type可以删除变量声明中的 。

可以使用以下语法声明变量
var name = initialvalue

Go 会自动从初始值推断出该变量的类型。

在下面的示例中，我们可以看到第 1 行中int的变量类型age已被删除。由于变量有一个初始值29，Go 可以推断它的类型是int。

package main

import "fmt"

func main() {  
    var age = 29 
    fmt.Println("My age is", age)
}

Run in playground

多变量声明

可以使用单个语句声明多个变量。下面是多变量声明的语法。

var name1, name2 type = initialvalue1,initialvalue2

package main

import "fmt"

func main() {  
    var width, height int = 100, 50 

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

Run in playground

如果变量具有初始值，则可以删除该*类型。*由于上面的程序有变量的初始值，因此int可以删除类型。

不同类型的变量声明

在某些情况下，我们可能希望在单个语句中声明属于不同类型的变量。这样做的语法是

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)
}

Run in playground

name这里我们声明了一个类型为string、age类型height为 的变量int。

运行上面的程序会打印

my name is naveen , age is 29 and height is 0  

简洁声明

Go 还提供了另一种简洁的变量声明方式。这称为简洁声明，它使用**:=**运算符。

name := initialvalue是声明变量的简洁声明语法。

以下程序使用简洁语法来声明一个count初始化为 的变量10。Go 会自动推断出count它的类型int，因为它已经用整数值初始化了10。

package main

import "fmt"

func main() {  
    count := 10
    fmt.Println("Count =",count)
}

Run in playground

上面的程序将打印，

Count = 10  

简洁语法多变量声明。

name, age := initialvalue,initialvalue是声明变量的简洁声明语法。

package main

import "fmt"

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

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

Run in playground

上面的程序声明了两个变量name和 ，age其类型分别为string和int。

如果运行上面的程序，您可以看到my name is naveen age is 29打印结果。

简写声明要求赋值左侧的所有变量都有初始值。以下程序将打印错误assignment mismatch: 2 variables but 1 values。这是因为年龄尚未分配值。

package main

import "fmt"

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

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

Run in playground

**仅当:=**左侧的至少一个变量是新声明的时才能使用简写语法。考虑以下程序，

package main

import "fmt"

func main() {  
	// 声明变量 a and b
    a, b := 20, 30 
    fmt.Println("a is", a, "b is", b)
    // b已经在上面被声明 c新声明 
    b, c := 40, 50
    fmt.Println("b is", b, "c is", c)
    // b c 重新赋值
    b, c = 80, 90 
    fmt.Println("changed b is", b, "c is", c)
}

Run in playground

在上面的程序中，第 1 行。a、 b已经被声明，但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 被赋值
    a, b := 20, 30 
    fmt.Println("a is", a, "b is", b)
    //错误, 没有新的变量
    a, b := 40, 50 
}

Run in playground

会打印 error/prog.go:8:10: no new variables on left side of :=
这是因为变量a和b都已经被声明了，并且第 1 行使用**:=**
第二行左边没有新的变量导致

还可以为变量分配在运行时计算的值。考虑以下程序，

package main

import (  
    "fmt"
    "math"
)

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

Run in playground

在上面的程序中，math是一个包，Min是该包中的一个函数。现在不用担心，我们将在接下来的教程中详细讨论包和函数。我们需要知道的是， c的值是在运行时计算的，并且它是a和b的最小值。上面的程序将打印，

Minimum value is  145.8  

由于 Go 是强类型的，声明为属于一种类型的变量不能被赋予另一种类型的值。以下程序将打印错误，cannot use "naveen" (type string) as type int in assignment因为age被声明为类型并且我们正在尝试为其int分配值。string

package main

func main() {  
    age := 29    
    // 错误 试图将字符串赋值给int类型的变量
    age = "naveen" 
}

Run in playground

下一个教程 - Go语言基本类型简介