Go语言的变量与常量

[[391525]]

变量

go 语言的变量声明和大多数语言类似，通过 var 关键字声明变量，只是 go 语言作为静态类型语言，声明变量时需要指定其类型。

网站建设哪家好，找创新互联！专注于网页设计、网站建设、微信开发、微信小程序、集团企业网站建设等服务项目。为回馈新老客户创新互联还提供了浔阳免费建站欢迎大家使用！

下面的代码表示声明一个『name』变量，类型为『string』，并给其赋值『"Shenfq"』。

 
 
 
 

  
  
  
  
var name string = "Shenfq" 
 
 
 
 

如果我们不进行赋值，这变量会获得一个默认值，下面列举一些 go 语言中的基础类型及其默认值。

多变量声明

上面介绍 go 语言通过 var 关键字进行单个变量声明，我们还可以通过 var 关键字进行多个变量的声明：

 
 
 
 

  
  
  
  
// 声明两个变量为同一类型 
  
  
  
  
var firstName, lastName string 
  
  
  
  
// 给两个变量同时赋值 
  
  
  
  
firstName, lastName = "frank", "shen" 
 
 
 
 

 
 
 
 

  
  
  
  
// 声明两个变量为不同类型 
  
  
  
  
var ( 
  
  
  
  
  age int 
  
  
  
  
 name string 
  
  
  
  
) 
  
  
  
  
// 给两个变量同时赋值 
  
  
  
  
age, name = 25, "Shenfq" 
 
 
 
 

类型推导

如果我们在变量声明阶段，对变量进行了赋值操作，这时候我们是可以直接省略变量类型的，因为 go 在编译过程中会依据所赋予的初始值推导出其类型。

 
 
 
 

  
  
  
  
var age = 25 
  
  
  
  
 
  
  
  
  
fmt.Printf("age 类型为：%T", age) // age 类型为：int 
 
 
 
 

 
 
 
 

  
  
  
  
var ( 
  
  
  
  
  age = 18 
  
  
  
  
  name = "Shenfq" 
  
  
  
  
) 
  
  
  
  
fmt.Printf("age 类型为：%T", age) // age 类型为：int 
  
  
  
  
fmt.Printf("name 类型为：%T", name) // name 类型为：string 
 
 
 
 

简短格式

前面介绍了变量声明的时候，如果给定了初始值，go 在编译阶段可以进行类型推导。这种情况，go 提供了一种更简单的声明方式，通过 := 的方式进行变量声明，可以省略 var 关键字。

 
 
 
 

  
  
  
  
func main() { 
  
  
  
  
  age := 25 
  
  
  
  
 name := "Shenfq" 
  
  
  
  
} 
 
 
 
 

 
 
 
 

  
  
  
  
// 也可以进行多个变量同时赋值 
  
  
  
  
func main() { 
  
  
  
  
  age, name := 25, "Shenfq" 
  
  
  
  
} 
 
 
 
 

️注意事项一

这种声明方式只能用于函数体内，不能用于全局变量的声明。

 
 
 
 

  
  
  
  
// ️ 不能在全局使用这种方式声明变量 
  
  
  
  
age, name := 25, "Shenfq" 
  
  
  
  
 
  
  
  
  
// 只能在函数体内使用该方式 
  
  
  
  
func main() { 
  
  
  
  
 age, name := 25, "Shenfq" 
  
  
  
  
 fmt.Printf("age 类型为：%T", age) 
  
  
  
  
 fmt.Printf("name 类型为：%T", name) 
  
  
  
  
} 
 
 
 
 

 

warning

️注意事项二

已经声明过的变量，不能使用 := 的方式进行赋值。

 
 
 
 

  
  
  
  
func main() { 
  
  
  
  
  var age int 
  
  
  
  
 age := 25 
  
  
  
  
} 
 
 
 
 

 

已经声明过的变量，只能通过 = 的方式进行赋值。

 
 
 
 

  
  
  
  
func main() { 
  
  
  
  
  var age int 
  
  
  
  
 age = 25 
  
  
  
  
} 
 
 
 
 

全局变量与局部变量

简单来说，声明在函数体外的变量为全局变量，声明在函数体内的变量为局部变量。

局部变量如果有声明，没有进行使用，则不会通过编译。

 
 
 
 

  
  
  
  
func main() { 
  
  
  
  
  var age int 
  
  
  
  
} 
 
 
 
 

 

但是，全局变量是可以声明而不使用的。

 
 
 
 

  
  
  
  
var age int 
  
  
  
  
func main() { 
  
  
  
  
 name := "Shenfq" 
  
  
  
  
 //fmt.Printf("age 类型为：%T", age) 
  
  
  
  
 fmt.Printf("name 类型为：%T", name) 
  
  
  
  
} 
 
 
 
 

上面的代码中，我们声明了 age 全局变量，但是并未使用，可以正常编译。

空白标识符

前面介绍过，go 在变量赋值的时候，可以一次性对多个变量赋值。同时，go 的函数在 return 的时候，也能一次返回多个结果。

 
 
 
 

  
  
  
  
func double(num int) (string, int) { 
  
  
  
  
 var err string 
  
  
  
  
 if num < 0 { 
  
  
  
  
  err = "num 不能为负数" 
  
  
  
  
  return err, -1 
  
  
  
  
 } 
  
  
  
  
 result := num * 2 
  
  
  
  
 return err, result 
  
  
  
  
} 
 
 
 
 

上面我们实现了一个 double 函数，该函数接受一个 int 类型的变量(num)，返回两个值，一个为异常提示(string 类型)，一个为 num * 2 的结果。如果 num < 0 ， 则提示 num 不能负数。

 
 
 
 

  
  
  
  
func main() { 
  
  
  
  
 err, res := double(10) 
  
  
  
  
 if err != "" { 
  
  
  
  
  fmt.Printf(err) 
  
  
  
  
 } else { 
  
  
  
  
  fmt.Printf("结果为：%v", res) 
  
  
  
  
 } 
  
  
  
  
} 
 
 
 
 

如果，我们并不关心 err ，只想执行 double 之后，输出其结果。

 
 
 
 

  
  
  
  
func main() { 
  
  
  
  
 err, res := double(10) 
  
  
  
  
 fmt.Printf("结果为：%v", res) 
  
  
  
  
} 
 
 
 
 

 

运行后，我们会收到一个编译错误，err 变量并未使用。这时候，就需要用到空白标识符(_)。

 
 
 
 

  
  
  
  
func main() { 
  
  
  
  
 _, res := double(10) 
  
  
  
  
 fmt.Printf("结果为：%v", res) 
  
  
  
  
} 
 
 
 
 

我们可以通过 _ 来接受 err 值，这个地方的值就会被抛弃掉，就能顺利通过编译。

常量

常量就是不会发生变化的变量，一旦声明就不会改变。go 语言中，常量的声明只需要将变量声明时的 var 关键字替换为 const 关键字。

 
 
 
 

  
  
  
  
// 隐式类型定义 
  
  
  
  
const PI = 3.14 
  
  
  
  
// 显式类型定义 
  
  
  
  
const PI2 float  = 3.14 
 
 
 
 

多常量声明

与变量类似，常量也支持一次性声明多个。

 
 
 
 

  
  
  
  
func main() { 
  
  
  
  
 const ( 
  
  
  
  
  PI = 3.14 
  
  
  
  
  PI2 = 3.14 
  
  
  
  
 ) 
  
  
  
  
 fmt.Printf("结果为：%v\n", PI) 
  
  
  
  
 fmt.Printf("结果为：%v\n", PI2) 
  
  
  
  
} 
 
 
 
 

 

如果一次声明多个常量时，某个常量如果为进行赋值，默认会与上一个常量的值进行同步。下面代码的运行结果，与上面的代码一致。

 
 
 
 

  
  
  
  
func main() { 
  
  
  
  
 const ( 
  
  
  
  
  PI = 3.14 
  
  
  
  
  PI2 
  
  
  
  
 ) 
  
  
  
  
 fmt.Printf("结果为：%v\n", PI) 
  
  
  
  
 fmt.Printf("结果为：%v\n", PI2) 
  
  
  
  
} 
 
 
 
 

特殊常量

有个叫做 iota 的特殊常量，在常量的赋值过程中，会进行累加。

 
 
 
 

  
  
  
  
func main() { 
  
  
  
  
 const ( 
  
  
  
  
  A = iota 
  
  
  
  
  B 
  
  
  
  
  C 
  
  
  
  
 ) 
  
  
  
  
 fmt.Println(A, B, C) // 0 1 2 
  
  
  
  
} 
 
 
 
 

在 iota 累加的过程中，可以对其进行打断。

 
 
 
 

  
  
  
  
func main() { 
  
  
  
  
 const ( 
  
  
  
  
  A = iota 
  
  
  
  
  B 
  
  
  
  
  C = "Shenfq" 
  
  
  
  
    D 
  
  
  
  
    E 
  
  
  
  
 ) 
  
  
  
  
 fmt.Println(A, B, C, D, E) 
  
  
  
  
} 
 
 
 
 

这时候输出的结果为：

这是由于我们将常量 C 修改为了字符串 "Shenfq"，常量 D、E 会默认与上一条常量保持同步，所以会得到上述结果。但是， iota 是支持重新恢复累加，只需要在指定位置重新赋值一次 iota 即可。

 
 
 
 

  
  
  
  
func main() { 
  
  
  
  
 const ( 
  
  
  
  
  A = iota 
  
  
  
  
  B 
  
  
  
  
  C = "Shenfq" 
  
  
  
  
  D = iota // 恢复累加状态 
  
  
  
  
  E 
  
  
  
  
 ) 
  
  
  
  
 fmt.Println(A, B, C, D, E) 
  
  
  
  
} 
 
 
 
 

由于 C 占用了原本 2 的位置，所以 D 恢复后，也是从 3 开始的。

iota 这种累加的特性，特别像我们在其他语言中使用的枚举，所以在 go 语言中，我们可以直接将 iota 当做枚举来使用。

 
 
 
 

  
  
  
  
type ButtonType int 
  
  
  
  
const ( 
  
  
  
  
  Default ButtonType = iota 
  
  
  
  
  Primary 
  
  
  
  
  Warning 
  
  
  
  
  Error 
  
  
  
  
) 
 
 
 
 

标题名称：Go语言的变量与常量
网站网址：http://www.csdahua.cn/qtweb/news12/38212.html

网站建设、网络推广公司-快上网，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 快上网