🌷 博主 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中声明变量有多种语法形式。变量本质上是一小块内存，用于存储数据，在程序运行过程中数值可以改变。

声明变量的语法有三种形式：

1. 指定变量类型，并在后续赋值，如果不赋值则使用默认值：

   var name type
   name = value
   

2. 根据值自行判定变量类型（类型推断）：

   var name = value
   

3. 使用简短声明（省略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语言 的世界 ~