100天精通Golang（基础入门篇）——第4天： Go语言中的变量与常量详解：声明、赋值和使用-阿里云开发者社区

🌷 博主 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语言的世界 ~

100天精通Golang（基础入门篇）——第4天： Go语言中的变量与常量详解：声明、赋值和使用

标题：

引言：

摘要：

基本语法——变量

一、变量的使用

1.1 什么是变量

1.2 声明变量

多变量声明

1.3 注意事项

基本语法——常量constant

一、常量的使用

1.1 常量声明

名词解释:

1.2 iota

今日小结

学习总结：

结语

热门文章

最新文章

相关课程

相关电子书

相关实验场景

推荐镜像

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

100天精通Golang（基础入门篇）——第4天： Go语言中的变量与常量详解：声明、赋值和使用

标题：

引言：

摘要：

基本语法——变量

一、变量的使用

1.1 什么是变量

1.2 声明变量

多变量声明

1.3 注意事项

基本语法——常量constant

一、常量的使用

1.1 常量声明

名词解释:

1.2 iota

今日小结

学习总结：

结语

热门文章

最新文章

相关课程

相关电子书

相关实验场景

推荐镜像