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是新变量,所以允许使用:=运算符重新赋值。

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

相关推荐

TypeScript:let和const变量声明

在开始介绍let和const变量声明前,有必要先了解下JavaScript里的var变量声明。var变量声明全局声明var声明在函数体外,所声明的变量为全局变量。var name = "张三"; var所声明的全局变量会作为window的一个属性,可以使用"."来引用。如上例的name引用:console.log(window.

TypeScript:变量声明之解构赋值

解构(Destructuring)是ES6新增的特性。数组和对象(Object)的一个作用是把一些值组合打包在一起。与之相对,解构就类似把数组里的值或对象的属性解包。使用解构赋值语法可以很简便地把数组的值或对象的属性赋值给单独的变量。语法var a, b, rest; [a, b] = [10, 20]; console.log

Java 9模块声明中requires and requires transitive的区别

可读性(Readability)首先要理解模块的可读性module bar{     requires drink; } bar requires drink意味着:bar模块强制要求存在drink模块,这称为可靠配置。bar模块可以读入drink模块的文件,这称为可读性。bar模块可以访问drink模块的代码,这称为

Angular入口组件(entry component)和声明式组件的区别

Angular的声明式组件和入口组件的区别体现在两者的加载方式不同。声明式组件是通过组件声明的selector加载入口组件(entry component)是通过组件的类型动态加载声明式组件声明式组件会在模板里通过组件声明的selector加载组件。示例@Component({   selector: 'a-cmp',   templat

Go语言日志框架logrus封装

logrus在github上是一个star数比较高的go日志框架,简单封装如下:package logimport ( "fmt" "github.com/Sirupsen/logrus" "runtime" "strings")var logger = logrus.New()// 封装logrus.Fieldstype Fields logrus.Fieldsfunc SetLogLevel(

shell脚本变量的使用

问var=value 在export前后的差在哪? 这次让我们暂时丢开command line,先了解一下bash变量(variable)吧…所谓的变量,就是利用一个固定的”名称”(name),来存取一段可以变化的”值”(value)。1. 变量设定(set)在bash中, 你可以用”=”来设定或者重新定义变量的内容: name=value 在设定变量的时候,得遵守如

Go语言把map接口转换为google.protobuf.Struct

以下是go语言把map[string]interface{}转换为google.protobuf.Struct:package pbimport ( "fmt" "reflect" st "github.com/golang/protobuf/ptypes/struct")// ToStruct转换map[string]interface{} 为ptypes.Structfunc ToStruct

R语言根据name删除dataframe的列

根据名字删除dataframe里的列,可以使用subset函数。分为两种方式使用:1、知道想保留的列,使用subset显示保留。df <- data.frame(a = 1:10, b = 2:11, c = 3:12)df <- subset(df, select = c(a, c))示例中保留了a和c列2、指定删除的列,如上面例子中,要删除a和c列,如下:df <- subs

MySQL设置会话变量:把查询结果赋值给变量

MySQL设置变量有两种方式:会话变量和存储过程变量。1、使用set或select直接赋值,变量名以@开头例如:set @var=1; 可以在一个会话的任何地方声明,作用域是整个会话,称为用户变量。2、以declare关键字声明的变量,只能在存储过程中使用,称为存储过程变量。例如: declare var1 int default 0; 主要用在存储过程中,或者是给存储传参数中。两者的区别是: 在