🌷 博主 libin9iOak带您 Go to Golang Language.✨
🦄 个人主页——libin9iOak的博客🎐
🐳 《面试题大全》 文章图文并茂🦕生动形象🦖简单易学!欢迎大家来踩踩~🌺
🌊 《IDEA开发秘籍》学会IDEA常用操作,工作效率翻倍~💐
🪁 希望本文能够给您带来一定的帮助🌸文章粗浅,敬请批评指正!🐥
100天精通Golang(基础入门篇)
- 标题:
- 引言:
- 摘要:
- 基本语法——变量
- 一、变量的使用
- 1.1 什么是变量
- 1.2 声明变量
- 多变量声明
- 1.3 注意事项
- 基本语法——常量constant
- 一、常量的使用
- 1.1 常量声明
- 名词解释:
- 1.2 iota
- 今日小结
- 学习总结:
- 结语
标题:
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语言 的世界 ~