Go语言变量与标识符探秘：灵活存储数据
目录
标识符
命名规则
命名约定
标识符的使用示例
变量
常见的变量类型
变量声明和赋值
变量的初始化
标准声明
批量声明
类型推导
匿名变量
示例代码
总结
更多关于Go的相关技术点，敬请关注公众号：CTO Plus后续的发文，有问题欢迎后台留言交流。
原文：Go语言变量与标识符探秘：灵活存储数据
由于不少粉丝在后台留言咨询关于Go的开发技术资料，所以在周末加深夜赶忙抽了点时间，规划了下关于Go系列的文章内容，我想大概分为三个阶段内容，第一阶段为Go的整个的语法特性。第二阶段就是Go的高级进阶内容涉及到分布式高并发这块。第三阶段就是后端开发，Web框架以及数据库操作部分。
以前的几篇文章中也对Go做了大概的分享介绍包括一些开源项目和学习资料，详细的请参考文末的推荐阅读。
第一阶段一共近60篇大致内容如下：
【Go第一阶段】
-
《Go语言的高级特性，发展趋势，以及推荐最热门的开源项目》
-
《Go 1.21稳定版和新特性详解》
-
《Go的多端开发环境与编译器的搭建详解（图文）》
-
《Go编码，规范先行》
-
《Go的代码包以及自定义包的开发详细介绍》
-
《Go的命令操作总结教程》
-
《Go语言的打印输出方法总结》
-
《Go语言变量探秘：灵活存储数据》
-
《Go语言常量解密：恒定不变的值》
-
《深入了解Go语言的数据类型》
-
《Go语言字符串操作大揭秘：高效处理文本》
-
《Go的流程控制（if、for、switch、goto）全面解析与刨坑》
-
《Go中字符串的遍历技巧：轻松操作文本》
-
《Go语言gconv类型转换：无缝转换数据》
-
《使用strconv进行Go的 int、float、string类型相互转换：灵活转换数据类型》
-
《Go的运算符解密：探索计算的奥秘》
-
《Go的表达式解析：理解代码的核心》
-
《Go的切片（slice）技巧：灵活操作有序集合》
-
《深入理解与深度解析Go语言的切片（Slice）：探索底层机制》
-
《Go的Slice使用技巧：提升代码效率》
-
《Go的范围（range）遍历揭秘：掌握迭代技巧，高效处理数据集合》
-
《Go的rune解析：深入了解字符处理》
-
《Go语言Map（集合）操作大揭秘：掌握高效映射技巧》
-
《Go语言关键字解析：理解关键代码元素》
-
《Go语言映射技巧：灵活操作数据集合》
-
《Go语言赋值与（深浅）拷贝解析：深入分析数据处理》
-
《解析Go语言的数组：高效处理有序数据》
-
《Go的数组初始使用方法以及作为函数参数的使用方法》
-
《Go内置数据结构数组（array）、切片（slice）、字典（map）之间的区别和特点对比》
-
《Go的错误处理艺术：深入探讨Go语言的错误处理机制》
-
《浅谈Golang饱受争议的error：探讨其优缺点和应用场景》
-
《Go指针的奇妙世界：解析Go语言中的指针用法》
-
《Go方法的魅力：掌握Go语言中的方法使用技巧》
-
《Go模块化编程探秘：Go语言中模块的设计与使用》
-
《Go函数的奇妙之旅：深入理解Go语言中的函数特性》
-
《Go函数与方法的区别：揭秘它们的共性与差异》
-
《Go递归函数的魅力：探索Go语言中递归的妙用》
-
《Go高效内置函数大揭秘：开发中常用的Go语言内置函数》
-
《Go函数式编程探秘：优劣势与模块应用实战详解》
-
《Go高阶函数的魅力：掌握Go语言中的函数式编程》
-
《Go的高阶函数的作用以及使用详细介绍》
-
《Go接口（interface）的奇妙世界：深入理解Go语言中的接口特性》
-
《Go垃圾回收的黑盒解析：探究Go语言中的垃圾回收机制》
-
《Go快速集成日志模块：Go语言框架中的日志模块集成指南》
-
《Go结构体（struct）解析：掌握Go语言中结构体的使用技巧》
-
《Go性能测试技巧大揭秘：优化Go语言程序的性能》
-
《Go调试&单元测试：Go语言开发中的调试和测试技巧》
-
《Go时间操作大全解析：掌握时间处理的技巧》
-
《Go函数闭包底层实现：深入探讨Go语言中闭包的原理》
-
《Go并发安全的奥秘：深入理解Go语言中的并发安全性sync.Map的实现原理》
-
《Go并发编程基础之上下文的奇妙世界：什么是上下文以及探索Go语言中上下文的应用与实践》
-
《Go的包管理器工具mod》
-
《Go语言的包管理工具对比：Go Modules和dep》
-
《Go依赖管理工具dep》
-
《Go内存管理与垃圾回收机制剖析》
-
《如何在 Go 中使用日志包》
-
《Go执行体间的通信》
-
《Go协程：并行计算》
更多关于Go的相关技术点，敬请关注公众号：CTO Plus后续的发文，有问题欢迎后台留言交流。
Go语言是一种静态类型的编程语言，变量在Go中用于存储和操作数据。在Go中，变量必须先声明后使用，并且每个变量都有一个特定的类型。
程序运行过程中的数据都是保存在内存中的，如果我们想要在代码中操作某个数据时就需要去内存上找到这个变量，但是如果我们直接在代码中通过内存地址去操作变量的话，代码的可读性会非常差而且还容易出错，所以我们就利用变量将这个数据的内存地址保存起来，以后直接通过这个变量就能找到内存上对应的地址和数据了。
Go语言是一门静态类型的编程语言，因此在使用变量时需要先声明其类型。变量在Go语言中是程序中最基本的组成部分之一，它们用于存储程序中的数据。
更多关于Go的相关技术点，敬请关注公众号：CTO Plus后续的发文，有问题欢迎后台留言交流。
本文我将详细介绍Go语言中的标识符、变量、变量命名规则，包括变量的声明、赋值、类型推导以及常见的变量类型等方面内容，并使用代码示例做了演示。
下一篇将总结介绍下关于Go的作用域、生命周期、类型转换方面的内容。
标识符
在编程语言中标识符就是程序员定义的具有特殊意义的词，比如变量名、常量名、函数名等等。Go语言中标识符由字母数字和_(下划线）组成，并且只能以字母和_开头。 举几个例子：abc, _, _123, a123。
Go语言的标识符是用来命名变量、常量、函数、类型等程序实体的名称。在Go语言中，标识符具有一些规则和约定，下面我们来详细了解一下。
命名规则
在Go语言中，标识符（变量）的命名需要遵循一些规则，规则如下：
1. 标识符（变量名）由一个或多个字母、数字或下划线组成。
2. 标识符（变量名）的第一个字符必须是字母或下划线，不能是数字。
3. 标识符（变量名）区分大小写，例如name和Name是不同的标识符（变量）。
4. Go语言的关键字不能用作标识符（变量名），如if、for等。
5. 标识符（变量名）应该具有描述性，能够清晰地表达变量的含义（见名知意）。
关于关键字的介绍和使用可以参考公众号CTO Plus文章《看这一篇就够了 总结Go关键字作用、特性以及使用方式详解》。
一般而言，Go语言的命名风格采用驼峰命名法，即首字母小写，后续单词首字母大写，例如userName、studentAge。
命名约定
除了命名规则外，Go语言还有一些命名约定，用于提高代码的可读性和可维护性。
1. 使用驼峰命名法：Go语言推荐使用驼峰命名法来命名标识符。驼峰命名法分为两种形式：首字母小写的驼峰命名法（例如myVariable）用于私有变量和局部变量，首字母大写的驼峰命名法（例如MyVariable）用于公共变量和全局变量。
2. 使用有意义的名称：标识符的名称应该具有描述性，能够清晰地表达其用途和含义。避免使用单个字母或无意义的名称。
3. 遵循命名约定：Go语言有一些命名约定，例如使用单个字符的名称用于迭代变量（例如i、j、k），使用err作为错误变量的名称等。遵循这些约定可以提高代码的可读性。
4. 避免使用缩写：尽量避免使用缩写来命名标识符，除非缩写是广为人知的。使用完整的单词可以提高代码的可读性。
标识符的使用示例
下面是一些使用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 []
} 需要注意的是，这些默认值只适用于变量在声明时没有被显式赋值的情况。如果在声明变量时显式赋予了初始值，那么变量将被初始化为该初始值。如下面的批量变量初始化标准格式如下：
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 []
}
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
更多精彩，关注我公号，一起学习、成长
