Go语言变量与标识符探秘：灵活存储数据

package main

import "fmt"

func myFunction(age int) int {
  var count int
  return count + age
}

func simple_variable() {
  var age int = 28
  var name string = "SteveRocket"

  fmt.Println("name:", name, "age:", age) // name: SteveRocket age: 28
  fmt.Println(myFunction(age))            // 28
}

func main() {
  simple_variable()
}

在上面的示例中，我们使用了一些标识符，例如age、name、myFunction和count。这些标识符遵循了Go语言的命名规则和约定，具有描述性，并且易于理解和维护。

接下来介绍下变量的声明、赋值和命名规则。

变量

Go 语言是静态类型的，go的变量要先声明再使用，变量声明时必须明确变量的类型。Go 语言与其他语言显著不同的一个地方在于，Go 语言的类型在变量后面。比如C/C++、java 中，声明一个整体一般写成 int a = 1，在 Go 语言中，需要这么写，如下代码示例：

func main() {
  var num int      // // 声明一个保存整型的变量num，如果没有赋值，默认为0
  fmt.Println(num) // 0

  var num2 int = 123 // 声明时赋值
  fmt.Println(num2)  // 123

  //因为 456 是 int 类型，所以赋值时，num3 自动被确定为 int 类型，所以类型名可以省略不写
  var num3 = 456    // 声明时赋值
  fmt.Println(num3) // 456

  var nick_name string  // 声明一个保存字符串类型的变量nick_name
  fmt.Println(nick_name) // 空字符串
  // 更简单的声明赋值
  name := "SteveRocket"
  fmt.Println(name) // SteveRocket

  var isNull bool  // 声明一个保存布尔类型的变量isNull，默认为false
  fmt.Println(isNull)
}

更多关于Go的相关技术点，敬请关注公众号：CTO Plus后续的发文，有问题欢迎后台留言交流。

常见的变量类型

变量（Variable）的功能是存储数据。不同类型的变量保存的数据类型可能会不一样。Go语言提供了多种数据类型，用于存储不同类型的数据。常见的变量类型（数据类型）包括：

整数类型：int、int8、int16、int32、int64、uint、uint8、uint16、uint32、uint64等。
浮点数类型：float32、float64。
布尔类型：bool，取值为true或false。
字符串类型：string。
字符类型：byte，用于表示ASCII字符。

关于数据类型的详细介绍关注公众号CTO Plus后面的文章《深入了解Go语言的数据类型》

除了以上基本的数据类型外，Go语言还提供了复合类型，如数组、切片、映射、结构体等，用于存储多个值或不同类型的值。

关于复合数据类型的详细介绍请关注公众号CTO Plus后面的文章：

《Go语言Map（集合）操作大揭秘：掌握高效映射技巧》
《Go的切片（slice）技巧：灵活操作有序集合》
《深入理解与深度解析Go语言的切片（Slice）：探索底层机制》
《Go的Slice使用技巧：提升代码效率》
《Go语言映射技巧：灵活操作数据集合》
《解析Go语言的数组：高效处理有序数据》
《Go的数组初始使用方法以及作为函数参数的使用方法》
《Go内置数据结构数组（array）、切片（slice）、字典（map）之间的区别和特点对比》

Go语言中的每一个变量都有自己的类型，并且变量必须经过声明才能开始使用，接下来介绍下变量的声明和赋值。

变量声明和赋值

在Go语言中，变量的声明使用关键字var，使用var关键字声明变量时，需要指定变量的名称和类型，其语法如下：

var 变量名类型

例如，声明一个整数类型的变量age：

var age int

变量声明后，可以通过赋值操作给变量赋初值。赋值使用等号=，例如：

age = 25

也可以在声明变量的同时进行赋值，这称为变量的初始化，例如：

var name string = "John"

在函数内部，可以使用。

在Go语言中，变量的声明可以使用var关键字，也可以使用更简略的符号 := 方式声明并初始化变量（短变量声明）进行简化。在使用简短声明（:=）方式时，可以省略关键字var和类型声明，例如：

age := 25

name := "SteveRocket"

在使用:=符号进行简化时，变量的类型会根据所赋的值（右侧的值）自动推导出变量的类型。

Go语言中的变量需要声明后才能使用，同一作用域内不支持重复声明。并且Go语言的变量声明后必须使用。

在Go语言中，变量的赋值可以使用=符号进行，例如：

age := 18

age = 20

在赋值时，需要注意变量的类型必须与所赋的值的类型一致，否则会导致编译错误。

同时，Go语言还支持多重赋值，例如：

a, b := 1, 2

a, b = b, a

在上面的代码中，我们使用多重赋值将a和b的值互换了。

完整代码示例：

package main

import "fmt"

// go语言中推荐使用驼峰命名
var studentName string

func variable() {
  Age := 30        // 变量区分大小写
  fmt.Println(Age) // 30

  age := 28
  fmt.Println(age) // 28
  age = 30         // 赋值
  fmt.Println(age) //30
  age = 25.0       // 重新赋值
  fmt.Println(age) // 25

  //在赋值时，需要注意变量的类型必须与所赋的值的类型一致，否则会导致编译错误。
  //age = 25.55  // cannot use 25.55 (untyped float constant) as int value in assignment (truncated)

  fmt.Println(age, Age) // 25 30
  age, Age = Age, age
  fmt.Println(age, Age) // 25 30
}

func main() {
  variable()
}

更多关于Go的相关技术点，敬请关注公众号：CTO Plus后续的发文，有问题欢迎后台留言交流。

变量的初始化

Go语言在声明变量的时候，会自动对变量对应的内存区域进行初始化操作。每个变量会被初始化成其类型的默认值，例如：

整型变量的默认值为0。
浮点型变量的默认值为0.0。
字符串变量的默认值为空字符串""。
布尔型变量的默认值为false。
切片、函数、指针变量的默认值为nil。

func variable_default_value() {
  var name string
  var age int
  var isNull bool
  var salary float64
  // 切片
  var slice []int
  // 函数
  var fn func()
  // 指针变量
  var ptr *int
  fmt.Println(name, age, isNull, salary, slice, fn, ptr) // 输出结果："" 0 false 0 [] <nil> <nil>
}

需要注意的是，这些默认值只适用于变量在声明时没有被显式赋值的情况。如果在声明变量时显式赋予了初始值，那么变量将被初始化为该初始值。如下面的批量变量初始化标准格式如下：

var 变量名类型 = 表达式

var name2, age2, wechat = "SteveRocket", 28, "CTO Plus"

标准声明

Go语言的变量声明格式为：

var 变量名变量类型

变量声明以关键字var开头，变量类型放在变量的后面，行尾无需分号。举个例子：

var name string

var age int

var isNull bool

批量声明

每声明一个变量就需要写var关键字会比较繁琐，go语言中还支持批量变量声明：

// 批量声明变量

var (

num1 int

name string

age int32

isNull bool

salary float32

)

类型推导

有时候我们会将变量的类型省略，这个时候编译器会根据等号右边的值来推导变量的类型完成初始化。

var name = "SteveRocket"

var age = 18

匿名变量

在使用多重赋值时，如果想要忽略某个值，可以使用匿名变量（anonymous variable）。匿名变量用一个下划线_表示，例如：

func annoymous_variable(salary float64) (int, string, bool, float64) {
  return 28, "SteveRocket", true, salary
}
func main() {
  age, _, sex, _ := annoymous_variable(0)
  fmt.Println(age, sex) // 28 true
  //_, _, _, _ := annoymous_variable(0)  // no new variables on left side of :=
  _, _, _, salary := annoymous_variable(0)
  fmt.Println(salary)
}

匿名变量不占用命名空间，不会分配内存，所以匿名变量之间不存在重复声明，在Python中同样也可以作为一个占位符使用。

示例代码

下面是一个使用变量的示例代码，如下：

package main

import "fmt"

// 全局变量studentName  go语言中推荐使用驼峰命名
var studentName string

// 批量声明全局变量
// 声明全局变量建议使用批量声明，方便追加
var (
  num1   int
  name   string
  age    int32
  isNull bool
  salary float32
)

// 声明变量
var myName string
var myAge int
var isSex bool

// 批量初始化变量(一次初始化多个变量)
var name2, age2, wechat = "SteveRocket", 28, "CTO Plus"

func variable() {
  Age := 30        // 变量区分大小写
  fmt.Println(Age) // 30

  age := 28
  fmt.Println(age) // 28
  age = 30         // 赋值
  fmt.Println(age) //30
  age = 25.0       // 重新赋值
  fmt.Println(age) // 25

  //在赋值时，需要注意变量的类型必须与所赋的值的类型一致，否则会导致编译错误。
  //age = 25.55  // cannot use 25.55 (untyped float constant) as int value in assignment (truncated)

  fmt.Println(age, Age) // 25 30
  age, Age = Age, age
  fmt.Println(age, Age) // 25 30
}

func variable02() {
  // 非全局变量（局部变量）声明了就必须使用，不使用就无法编译通过（全局变量声明或初始化了不使用也可以编译通过）
  // 不使用报错：blog declared and not used
  var blog = "https://mp.weixin.qq.com/s/0yqGBPbOI6QxHqK17WxU8Q"
  fmt.Println(blog)

  //同一个作用域，不能重复声明同名变量
  //blog := "" // no new variables on left side of :=
  blog = "" // 但可以重新赋值
  fmt.Println(blog)

}
func variable_default_value() {
  var name string
  var age int
  var isNull bool
  var salary float64
  // 切片
  var slice []int
  // 函数
  var fn func()
  // 指针变量
  var ptr *int
  fmt.Println(name, age, isNull, salary, slice, fn, ptr) // "" 0 false 0 [] <nil> <nil>
}

func annoymous_variable(salary float64) (int, string, bool, float64) {
  // 匿名变量 是一个特殊的变量： _
  // 匿名变量使用_指定，用来作为一个占位符，匿名变量不占用命名空间，不会分配内存，所以匿名变量之间不存在重复声明
  return 28, "SteveRocket", true, salary
}

func main() {
  variable()
  variable02()
  variable_default_value()
  age, _, sex, _ := annoymous_variable(0)
  fmt.Println(age, sex) // 28 true
  //_, _, _, _ := annoymous_variable(0)  // no new variables on left side of :=
  _, _, _, salary := annoymous_variable(0)
  fmt.Println(salary)
}

在上述示例中，我们完整的演示了变量的声明、匿名变量的使用、变量的初始化、简短变量的类型推导等使用方法，以及通过赋值操作给这些变量赋初值，并使用fmt.Println()函数将变量的值打印到标准输出。

关于Go语言的打印输出更多的使用方法可以参考公众号CTO Plus这篇文章：《Go语言的打印输出方法总结》

更多关于Go的相关技术点，敬请关注公众号：CTO Plus后续的发文，有问题欢迎后台留言交流。

总结

经过上述的文章内容介绍，下面总结了一些关于变量的使用注意事项：

注意事项

函数外的每个语句必须以关键字开始（var、const、func等）。
:= 不能在函数外使用。
_ 多用于占位，标识值可以忽略。
在Go语言中，不同类型的变量在声明时会被赋予默认值，整型变量的默认值为0，浮点型变量的默认值为0.0，字符串变量的默认值为空字符串""，布尔型变量的默认值为false，切片、函数、指针变量的默认值为nil。
如果在声明变量时显式赋予了初始值，那么变量将被初始化为该初始值，并且要在代码中被使用，否则编译出错。

总的来说，Go语言中的变量用于存储和操作数据，需要先声明后使用。变量的声明使用关键字var，可以通过赋值操作给变量赋初值。变量的命名需要遵循一定的规则，且应具有描述性。Go语言提供了多种数据类型，用于存储不同类型的数据。通过合理使用变量，可以方便地管理和操作数据。

同时Go语言的标识符是用来命名变量、常量、函数、类型等程序实体的名称。标识符具有一些命名规则和约定，例如使用驼峰命名法、使用有意义的名称、遵循命名约定等。遵循这些规则和约定可以提高代码的可读性和可维护性。

希望本文对您理解Go语言的标识符（变量）有所帮助！

云原生&微服务专栏
https://blog.csdn.net/zhouruifu2015/category_5704941

更多精彩，关注我公号，一起学习、成长