梧席
变量
Q7nl1s admin
  2022-09-19 20:38:40 2022-09-19 20:38   2023-09-20 09:31:59      1.8k Words  

变量

变量时赋予内存位置以存储特定类型的值的名称。在Go中声明变量有多种语法，下面逐一介绍。

什么是变量

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

1
2
3
4
5
6
7
8
package main

import "fmt"

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

该语句var age int声明了一个名为age类型为int的变量。我们没有给这个变量赋值。如果一个变量没有被赋值，Go 会自动用变量类型的零值初始化它。在这种情况下，年龄被赋值为0，这是 的零值int。如果你运行这个程序，你可以看到下面的输出。

1
My age is 0

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

1
2
3
4
5
6
7
8
9
10
11
12
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)
}

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

1
2
3
My age is  0  
My age is 29  
My new age is 54

用初始值声明变量

在声明变量时可以为其提供初始值，语法如下：

1
var name type = initialvalue  
1
2
3
4
5
6
7
8
9
package main

import "fmt"

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

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

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

1
My age is 29

它表明age已被初始化为值 29。

类型判断

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

如果使用以下语法声明变量：

1
var name = initialvalue

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

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

1
2
3
4
5
6
7
8
package main

import "fmt"

func main() {  
    var age = 29 // type will be inferred
    fmt.Println("My age is", age)
}

多变量声明

可以使用单个语句声明多个变量。

以下是多变量声明的语法：

1
var name1, name2 type = initialvalue1, initialvalue2
1
2
3
4
5
6
7
8
9
package main

import "fmt"

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

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

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

1
2
3
4
5
6
7
8
9
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作为输出打印。

正如你现在可能已经猜到的那样，如果没有为宽度和高度指定初始值，它们将被指定为它们的初始值0。

1
2
3
4
5
6
7
8
9
10
11
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)
}

上面的程序将打印

1
2
width is 0 height is 0  
new width is 100 new height is 50

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

1
2
3
4
var(
	name1 = initialvalue1
    name2 = initialvalue2
)

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

1
2
3
4
5
6
7
8
9
10
11
12
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)
}

在这里，我们声明了一个type为string的变量name。（我们将在下一个教程中讨论 Golang 中可用的各种类型）。

运行上面的程序会打印

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

简写声明

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

声明变量的简写语法如下：

1
name := initialvalue

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

1
2
3
4
5
6
7
8
package main

import "fmt"

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

上面的程序将打印

1
Count = 10

可以使用简写语法在一行中声明多个变量。

1
2
3
4
5
6
7
8
9
package main

import "fmt"

func main(){
    name,age := "namveen",29 //short hand declaration
    
    fmt.Println("my name is", name, "age is", age)
}

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

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

简写声明需要赋值左侧的所有变量的初始值。下面的程序将打印一个错误assignment mismatch: 2 variables but 1 values。这是因为age没有被赋值。

1
2
3
4
5
6
7
8
9
package main

import "fmt"

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

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

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

1
2
3
4
5
6
7
8
9
10
11
12
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是新声明的，因此它可以工作并输出

1
2
3
a is 20 b is 30  
b is 40 c is 50  
changed b is 80 c is 90

而如果我们运行下面的程序，

1
2
3
4
5
6
7
8
9
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
}

它会打印错误/prog.go:8:10: no new variables on left side of :=这是因为变量a和b都已经被声明了，并且在第8行**:=**的左侧没有新变量。

变量也可以被赋予在运行时计算的值。考虑以下程序，

1
2
3
4
5
6
7
8
9
10
11
12
package main

import (  
    "fmt"
    "math"
)

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

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

1
Minimum value is  145.8

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

1
2
3
4
5
6
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
}
 Comments
Comment plugin failed to load
Loading comment plugin
  1. 变量
    1. 什么是变量
    2. 用初始值声明变量
    3. 类型判断
    4. 多变量声明
    5. 简写声明
© 2020 - 2024    Q7nl1s
Powered by Hexo & Theme Keep
Unique Visitor Page View
  1. 变量
    1. 什么是变量
    2. 用初始值声明变量
    3. 类型判断
    4. 多变量声明
    5. 简写声明