Go语言:变量的声明

在计算机语言中,变量是以可读的名称表示保存值的存储位置。变量存储的值都有对应的类型,它的类型决定了变量存储值的空间以及操作。在Go语言中,它的命名需要符合Go语言:标识符命名规则

变量在使用之前,需要先声明变量。Go语言提供了多种声明变量的方式,主要分为:

  1. 使用关键词var基本格式声明变量
  2. 多变量的声明
  3. 使用简短赋值符:=声明变量

下面介绍变量的多种声明方式

声明变量的基本格式

GO语言声明变量的基本格式是使用 var 关键字声明,如下:

var variable_name type = expression

其中:

  • variable_name:表示变量名,需把variable_name替换为实际使用的变量名。
  • type:表示变量类型,需把type替换为实际使用变量类型,如string,int等等。
  • expression:在等号右边,是对变量进行赋值的表达式,即对变量赋初始值。

示例:

package main

import "fmt"

func main() {
    var i int = 8
    fmt.Println(i)
}

示例中,定义了变量i,它的类型为整型int,赋初始值为8。所以打印输出结果为:

8

变量缺省值

在声明变量时,是可以不赋初始值,其格式为:

var variable_name type

当变量声明时,没有显式赋初始值,Go语言会使用变量类型的默认值初始化变量,该默认值也称为该类型的零值。因为默认值是在变量未显式初始化时赋值,也称为缺省值。如int类型的变量缺省值为0,string类型的变量缺省值为空字符串“”。

示例:

package main

import "fmt"

func main() {
    var i int
    fmt.Println(i)
}

输出结果:

0

因为变量的缺省值是由变量类型决定,所以当变量声明没有显式赋初始值时,必须指定其类型。

变量的类型推断

从变量的缺省值我们知道,类型决定了变量的缺省值。反过来,变量的值也能确定变量的类型。所以,Go语言中允许我们在声明变量时,不显式指定变量的类型。这种方式称为变量的类型推断。其格式是:

var variable_name = expression

以下为基本类型数值对应的Go语言类型

变量值类型Go语言的基本类型
整数int
浮点数float64
 复数complex128
字符串string
字符int32 或者 rune

对于Array,Pointer和Structure类型,Go语言也会根据值做类型推断。

示例:

package main

import "fmt"

func main() {
    var a = 123      //int
    var b = "bstring" //string
    var c = 5.6      //float64
    var d = true     //bool
    var e = 'a'      //rune
    var f = 3 + 5i   //complex128
    var g = mystruct{name: "test"}  //main.MyStruct

    fmt.Printf("Type: %T Value: %v\n", a, a)
    fmt.Printf("Type: %T Value: %v\n", b, b)
    fmt.Printf("Type: %T Value: %v\n", c, c)
    fmt.Printf("Type: %T Value: %v\n", d, d)
    fmt.Printf("Type: %T Value: %v\n", e, e)
    fmt.Printf("Type: %T Value: %v\n", f, f)
    fmt.Printf("Type: %T Value: %v\n", g, g)
}

type mystruct struct {
    name string
}

多变量声明

多变量声明根据多个变量的类型是否相同分为两种:

  1. 相同类型的变量声明
  2. 不同类型的变量声明

单个变量的缺省值声明和类型推断同样适用于多变量声明,在此就不重复说明。

相同类型的多变量声明

对于多个变量的声明,如果它们的类型是相同的,可以使用以下格式声明:

var name1, name2, …..,nameN type = value1, value2, …..,valueN

示例:

package main

import "fmt"

func main() {
    var a, b int = 8, 9
    var c,d int
    fmt.Println(a)
    fmt.Println(b)
    fmt.Println(c)
    fmt.Println(d)
}

输出结果:

8
9
0
0

不同类型多变量声明

对于多个变量的声明,如果它们的类型不同,可以使用以下示例格式:

package main

import "fmt"

func main() {
    var (
        a int
        b int    = 10
        c string = "cstring"
    )

    fmt.Println(a)
    fmt.Println(b)
    fmt.Println(c)
}

先声明var关键词,接着在括号里声明变量,声明的变量可以赋初始值,如果不赋初始值,则使用类型的缺省值。

输出结果:

0
10
cstring

多变量声明的类型推断

多变量声明的类型推断格式:

var name1, name2,…,nameN = value1,value2,…,valueN

各个变量的类型由它各自的值确定,示例:

import "fmt"

func main() {
    var a, b, c = 10, true, "cstring"
    fmt.Println(a)
    fmt.Println(b)
    fmt.Println(c)
}

这种赋值常常使用在返回多个变量的方法上,如:

var f,err = os.Open(filename)

其中,f为os.Open返回的文件和错误err。

简短变量声明

Go 提供了另一种声明变量的方法,它使用 := 运算符。当使用 := 运算符时,var 关键词和类型信息都可以省略。以下是此类声明的格式:

 variable_name := expression

简短变量声明,既省略了var关键词,并且使用了Go语言的类型推断特性。以上类型推断的示例可以改写为:

package main

import "fmt"

func main() {
    a := 123      //int
    b := "bstring" //string
    c := 5.6      //float64
    d := true     //bool
    e := 'a'      //rune
    f := 3 + 5i   //complex128
    g := mystruct{name: "test"}  //main.MyStruct

    fmt.Printf("Type: %T Value: %v\n", a, a)
    fmt.Printf("Type: %T Value: %v\n", b, b)
    fmt.Printf("Type: %T Value: %v\n", c, c)
    fmt.Printf("Type: %T Value: %v\n", d, d)
    fmt.Printf("Type: %T Value: %v\n", e, e)
    fmt.Printf("Type: %T Value: %v\n", f, f)
    fmt.Printf("Type: %T Value: %v\n", g, g)
}

type mystruct struct {
    name string
}

:=运算符使用说明

使用:=运算符需要满足以下条件:

1. := 运算符仅在函数中可用。在函数之外是不允许的。

2. 使用 := 声明的变量不能多次使用 := 运算符重新声明。以下示例会报错:

a := 1
a := 2

3. := 运算符可声明多个变量。

a,b := 1, 2

4. 在多变量声明的情况下,如果至少一个变量是新的,则 := 也可以再次用于特定变量。

a, b := 1, 2
b, c := 3, 4

注意:第二行代码变量b虽然已被声明赋值,但由于c是新变量,所以允许使用:=运算符重新赋值。

版权声明:著作权归作者所有。

thumb_up 0 | star_outline 0 | textsms 0