🌷 博主 libin9iOak带您 Go to Golang Language.✨
🦄 个人主页——libin9iOak的博客🎐
🐳 《面试题大全》 文章图文并茂🦕生动形象🦖简单易学！欢迎大家来踩踩~🌺
🌊 《IDEA开发秘籍》学会IDEA常用操作，工作效率翻倍~💐
🪁 希望本文能够给您带来一定的帮助🌸文章粗浅，敬请批评指正！🐥
标题：
Go语言中的变量与常量详解：声明、赋值和使用
引言：
Go语言是一门简洁高效的编程语言，对于初学者来说，理解变量和常量的概念是非常重要的。本篇博客将深入探讨Go语言中变量和常量的声明、赋值和使用，帮助读者掌握这些基本概念，为编写高质量的Go程序打下坚实基础。
摘要：
本文将详细介绍Go语言中变量和常量的使用方法。首先，我们将介绍变量的声明和赋值的不同形式，并解释类型推断和简短声明的特点。然后，我们将探讨常量的声明和使用，包括不同类型常量的定义和常量组中的iota常量。最后，我们将总结学习过程中的关键点，帮助读者加深对Go语言中变量和常量的理解。
基本语法——变量
一、变量的使用
1.1 什么是变量
变量是为存储特定类型的值而提供给内存位置的名称。在go中声明变量有多种语法。
所以变量的本质就是一小块内存，用于存储数据，在程序运行过程中数值可以改变.
1.2 声明变量
var名称类型是声明单个变量的语法。
以字母或下划线开头，由一个或多个字母、数字、下划线组成
声明一个变量
第一种，指定变量类型，声明后若不赋值，使用默认值
var name type name = value
第二种，根据值自行判定变量类型(类型推断Type inference)
如果一个变量有一个初始值，Go将自动能够使用初始值来推断该变量的类型。因此，如果变量具有初始值，则可以省略变量声明中的类型。
var name = value
第三种，省略var, 注意 :=左侧的变量不应该是已经声明过的(多个变量同时声明时，至少保证一个是新变量)，否则会导致编译错误(简短声明)
name := value // 例如 var a int = 10 var b = 10 c : = 10
这种方式它只能被用在函数体内，而不可以用于全局变量的声明与赋值
示例代码：
package main import "fmt" func main() { // 基本数据类型 var a int = 10 // 整型 var b float64 = 3.14 // 浮点型 var c bool = true // 布尔型 var d string = "Hello Go!" // 字符串类型 fmt.Println("Integer:", a) fmt.Println("Float:", b) fmt.Println("Boolean:", c) fmt.Println("String:", d) // 引用类型 var e []int // 切片类型 e = []int{1, 2, 3} fmt.Println("Slice:", e) var f map[string]int // 映射类型 f = map[string]int{"a": 1, "b": 2, "c": 3} fmt.Println("Map:", f) var g chan int // 通道类型 g = make(chan int) fmt.Println("Channel:", g) var h func(int) int // 函数类型 h = func(x int) int { return x * 2 } fmt.Println("Function:", h) var i *int // 指针类型 num := 42 i = &num fmt.Println("Pointer:", *i) }
运行结果:
Integer: 10 Float: 3.14 Boolean: true String: Hello Go! Slice: [1 2 3] Map: map[a:1 b:2 c:3] Channel: 0xc000086120 Function: 0xe8e300 Pointer: 42
注意:
遇见如下错误的解决方案,先点修复,再点运行 就可以正常 执行
多变量声明
第一种，以逗号分隔，声明与赋值分开，若不赋值，存在默认值
var name1, name2, name3 type name1, name2, name3 = v1, v2, v3
第二种，直接赋值，下面的变量类型可以是不同的类型
var name1, name2, name3 = v1, v2, v3
第三种，集合类型
var ( name1 type1 name2 type2 )
代码 案例 :
package main import "fmt" func main() { // 第一种方式：逗号分隔的声明和赋值 var name1, name2, name3 string name1, name2, name3 = "libin9iOak", "Bob", "Alice" // 第二种方式：直接赋值，类型可以不同 var age1, age2, age3 = 20, 30, 40 // 第三种方式：集合类型 var ( score1 int score2 int ) score1, score2 = 99, 90 // 输出变量的值 fmt.Println("Name1:", name1) fmt.Println("Name2:", name2) fmt.Println("Name3:", name3) fmt.Println("Age1:", age1) fmt.Println("Age2:", age2) fmt.Println("Age3:", age3) fmt.Println("Score1:", score1) fmt.Println("Score2:", score2) }
结果:
Name1: libin9iOak Name2: Bob Name3: Alice Age1: 20 Age2: 30 Age3: 40 Score1: 99 Score2: 90 进程 已完成，退出代码为 0
1.3 注意事项
- 变量必须先定义才能使用
- go语言是静态语言，要求变量的类型和赋值的类型必须一致。
- 变量名不能冲突。(同一个作用于域内不能冲突)
- 简短定义方式，左边的变量名至少有一个是新的
- 简短定义方式，不能定义全局变量。
- 变量的零值。也叫默认值。
- 变量定义了就要使用，否则无法通过编译。
如果在相同的代码块中，我们不可以再次对于相同名称的变量使用初始化声明，例如：a := 20 就是不被允许的，编译器会提示错误 no new variables on left side of :=，但是 a = 20 是可以的，因为这是给相同的变量赋予一个新的值。
如果你在定义变量 a 之前使用它，则会得到编译错误 undefined: a。如果你声明了一个局部变量却没有在相同的代码块中使用它，同样会得到编译错误，例如下面这个例子当中的变量 a：
func main() { var a string = "abc" fmt.Println("hello, world") }
尝试编译这段代码将得到错误 a declared and not used
此外，单纯地给 a 赋值也是不够的，这个值必须被使用，所以使用
在同一个作用域中，已存在同名的变量，则之后的声明初始化，则退化为赋值操作。但这个前提是，最少要有一个新的变量被定义，且在同一作用域，例如，下面的y就是新定义的变量
package main import ( "fmt" ) func main() { x := 140 fmt.Println(&x) x, y := 200, "abc" fmt.Println(&x, x) fmt.Print(y) }
运行结果：
0xc04200a2b0 0xc04200a2b0 200 abc
基本语法——常量constant
一、常量的使用
1.1 常量声明
常量是一个简单值的标识符，在程序运行时，不会被修改的量。
const identifier [type] = value
显式类型定义： const b string = "abc" 隐式类型定义： const b = "abc"
package main import "fmt" func main() { const LENGTH int = 10 // 声明一个名为LENGTH的常量，类型为int，值为10 const WIDTH = 5 // 隐式类型定义的常量，类型会根据赋值自动推断 var area int // 声明一个名为area的变量，类型为int const a, b, c = 1, false, "str" // 多重赋值的常量 area = LENGTH * WIDTH // 计算面积 fmt.Printf("面积为：%d\n", area) fmt.Println(a, b, c) // 打印多重赋值的常量 }
运行结果：
面积为 : 50 1 false str
常量可以作为枚举，常量组
const ( Unknown = 0 Female = 1 Male = 2 )
常量组中如不指定类型和初始化值，则与上一行非空常量右值相同
package main import "fmt" func main() { const ( Unknown = 0 // 未知 Female = 1 // 女性 Male = 2 // 男性 ) fmt.Println(Unknown, Female, Male) const ( x uint16 = 16 // 声明一个类型为uint16的常量x，值为16 y // 与上一行的非空常量右值相同类型和值，即uint16类型的16 s = "abc" // 声明一个类型为string的常量s，值为"abc" z // 与上一行的非空常量右值相同类型和值，即string类型的"abc" f // 与上一行的非空常量右值相同类型和值，即string类型的"abc" ) fmt.Printf("%T, %v\n", y, y) // 打印y的类型和值 fmt.Printf("%T, %v\n", z, z) // 打印z的类型和值 fmt.Printf("%T, %v\n", f, f) // 打印f的类型和值 }
运行结果：
0 1 2 uint16, 16 string, abc string, abc
名词解释:
在Go语言中，%T和%v是格式化打印的占位符，用于在fmt.Printf和相关函数中格式化输出变量的类型和值。
%T用于打印变量的类型。例如，%T会打印出变量的具体类型，如int、string、bool等。%v用于打印变量的值。它会根据变量的具体类型，以合适的格式打印出变量的值。
在示例代码中，我们使用了fmt.Printf函数来打印变量的类型和值，并使用%T和%v来指定打印格式。
例如，fmt.Printf("%T, %v\n", y, y)中的%T表示打印变量y的类型，%v表示打印变量y的值。
请注意，fmt.Printf中的格式化占位符有很多其他选项，可以根据需要进行更多的格式化输出。这里我们只介绍了%T和%v这两个占位符的用法。
希望这样解释能帮助您理解%T和%v的含义和用途。
常量的注意事项：
- 常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型
- 不曾使用的常量，在编译的时候，是不会报错的
- 显示指定类型的时候，必须确保常量左右值类型一致，需要时可做显示类型转换。这与变量就不一样了，变量是可以是不同的类型值
1.2 iota
iota，特殊常量，可以认为是一个可以被编译器修改的常量
iota 可以被用作枚举值：
const ( a = iota b = iota c = iota )
第一个 iota 等于 0，每当 iota 在新的一行被使用时，它的值都会自动加 1；所以 a=0, b=1, c=2 可以简写为如下形式：
const ( a = iota b c )
iota 用法
package main import "fmt" func main() { const ( a = iota //0 b //1 c //2 d = "ha" //独立值，iota += 1 e //"ha" iota += 1 f = 100 //iota +=1 g //100 iota +=1 h = iota //7,恢复计数 i //8 ) fmt.Println(a,b,c,d,e,f,g,h,i) }
运行结果：
0 1 2 ha ha 100 100 7 8
以上示例展示了iota的枚举值和用法，以及使用中断和恢复iota计数。请注意，iota在每个const块中都是独立计数的，且后续自增值按行序递增。此外，iota的类型默认为int，可以根据需要显式指定类型。
希望这样的解释能够帮助您理解iota的概念和用法。
如果中断iota自增，则必须显式恢复。且后续自增值按行序递增
自增默认是int类型，可以自行进行显示指定类型
数字常量不会分配存储空间，无须像变量那样通过内存寻址来取值，因此无法获取地址.
今日小结
在Go语言中，变量用于存储特定类型的值，并提供一个内存位置的名称。在Go中声明变量有多种语法形式。变量本质上是一小块内存，用于存储数据，在程序运行过程中数值可以改变。
声明变量的语法有三种形式：
- 指定变量类型，并在后续赋值，如果不赋值则使用默认值：
var name type name = value
- 根据值自行判定变量类型（类型推断）：
var name = value
- 使用简短声明（省略
var），左侧的变量必须是新变量，不能是已经声明过的：
name := value
需要注意的是，简短声明方式只能用在函数体内部，不能用于全局变量的声明和赋值。
在Go中，常量是指在程序运行期间不会被修改的值。常量的声明使用const关键字，语法形式为：
const identifier [type] = value
常量可以是布尔型、数字型（整数型、浮点型和复数）和字符串型。常量的值在编译时确定，不可以被修改。
在常量组中，可以省略类型和初始化值，如果省略则与上一行非空常量右值相同。常量组中的iota是一个特殊常量，它可以被认为是一个可以被编译器修改的常量。iota常量可以被用作枚举值，每当iota在新的一行被使用时，它的值都会自动加1。
学习总结：
通过本文的学习，我们深入了解了Go语言中变量和常量的声明、赋值和使用。我们学习了三种不同形式的变量声明方式，包括指定类型后赋值、类型推断和简短声明。我们还了解了常量的声明和使用，以及常量组中的特殊常量iota的应用。这些知识将帮助我们编写更具可读性和可维护性的Go程序。在实践中，我们应该根据需求选择合适的变量类型和使用恰当的常量，以提高代码的效率和可靠性。
通过本篇博客的学习，相信读者对Go语言中的变量和常量有了更深入的了解，并且可以在实际项目中灵活运用。掌握好变量和常量的概念，将为我们进一步学习和应用Go语言打下坚实基础。
希望这篇博客能够对读者有所帮助，如果有任何疑问或进一步的讨论，欢迎留言交流。
结语
通过今天的学习，您已经踏上了Golang的学习之旅。在未来的日子里，您将探索Golang的各个方面，从基础概念到高级技巧，从实际应用到性能优化。
学习一门编程语言是一个持续的过程，每一天都是您向Golang的精通迈进的重要一步。我鼓励您坚持每天学习，保持热情和好奇心，解决挑战并享受成功的喜悦。
在您的学习旅程中，不要忘记参与社区和与其他Golang开发者交流。分享您的见解和经验，向他人学习，并在开源项目或实际应用中展示您的技能。
如果您在学习过程中遇到困难或有任何问题，不要犹豫向社区和专家寻求帮助。持续学习，勇敢探索，您将在Golang领域取得令人瞩目的成就。
最后，感谢您的阅读和支持！祝愿您在未来的每一天中都能够成为一名精通Golang的开发者！
期待听到您在学习过程中的进展和成就。如果您需要进一步的帮助，请随时告诉我。祝您在学习Golang的旅程中取得巨大成功！
如果您在学习过程中有任何疑惑，请点击下方名片，带您一对一快速入门 Go语言 的世界 ~
