golang教程之变量

变量

原文：https://golangbot.com/variables/

您可以阅读Golang教程第2部分：Hello World，了解配置golang和运行hello world程序。

什么是变量

变量是为存储特定类型的值的内存位置指定的名称。 在go中声明变量有各种语法。

声明一个变量

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

package main

import "fmt"

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

语句var age int声明了一个名为age的int类型的变量。 我们没有为变量分配任何值。 如果没有为变量赋值，则使用变量类型的零值自动初始化它。 在这种情况下，为age分配值0.如果运行此程序，则可以看到以下输出

my age is 0  

可以将变量分配给其类型的任何值。 在上面的程序中，age可以赋予任何整数值。

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  

声明具有初始值的变量

变量在声明时也可以给出初始值。

var name type = initialvalue是声明具有初始值的变量的语法。

package main

import "fmt"

func main() {  
    var age int = 29 // 具有初始值的变量声明

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

在上面的程序中，age是int类型的变量并且具有初始值29.如果运行上述程序，则可以看到以下输出。 它显示年龄已初始化，值为29。

my age is 29  

类型推断

如果变量具有初始值，Go将自动使用该初始值推断该变量的类型。 因此，如果变量具有初始值，则可以省略变量声明中的类型。

如果使用语法var name = initialvalue声明变量，Go将自动从初始值推断出该变量的类型。

在以下示例中，您可以看到变量age的int类型已在行号6中删除。由于变量的初始值为29，因此可以推断它的类型为int。

package main

import "fmt"

func main() {  
    var age = 29 // 类型将被推断

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

多变量声明

可以在单个语句中声明多个变量。

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

如果变量具有初始值，则可以省略该类型。 下面的程序使用类型推断声明多个变量。

package main

import "fmt"

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

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

以上程序将打印宽度为100高度为50作为输出。

正如您现在可能已经猜到的那样，如果没有为宽度和高度指定初始值，则将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的变量名，age和int类型的高度。 （我们将在下一个教程中讨论golang中可用的各种类型）。 运行上面的程序将产生输出，我的名字是naveen，年龄是29，高度是0

简短的声明

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

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

package main

import "fmt"

func main() {  
    name, age := "naveen", 29 // 简短的声明

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

如果你运行上面的程序，你可以看到我的名字是naveen age是29作为输出。

简写声明需要分配左侧所有变量的初始值。 以下程序将抛出错误，无法为2个变量分配1个值。 这是因为没有为年龄分配值。

package main

import "fmt"

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

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

只有在新声明左侧的至少一个变量时才能使用简写语法。 考虑以下程序，

package main

import "fmt"

func main() {  
    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)
}

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

它会抛出错误左侧没有新的变量:=这是因为变量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是强类型的，因此声明属于一种类型的变量不能分配另一种类型的值。 以下程序将抛出错误，不能在赋值时使用“naveen”（类型字符串）作为int类型，因为age声明为int类型，我们正在尝试为其分配字符串值。

package main

func main() {  
    age := 29      // age是int类型
    age = "naveen" // 因为我们试图将字符串分配给int类型的变量，所以会出错
}