名人说：莫道桑榆晚，为霞尚满天。------刘禹锡（刘梦得，诗豪）
创作者：Code_流苏(CSDN)（一个喜欢古诗词和编程的Coder😊）目录
1、注释
①为什么要写注释？
官方点儿来说，在编程中，注释是用来解释代码的目的和功能，以及某些实现的逻辑和原因。注释能够帮助其他开发者更好地理解和维护代码，同时也是自己未来回顾代码时的重要提示。良好的注释习惯可以提高代码的可读性和可维护性。
在咱们日常生活与工作中，写注释的作用无非两点：
- 自己看得懂
自己看得懂，是因为咱们开发一个项目，工程量大，代码量很多，如果不加注释，过了一段时间，就会感叹自己写了什么，看的两眼懵懵。如果加了注释，一看这个代码是做这个的，功能比如是增删改查等等，立马就清晰明了了。
- 别人看得懂
别人看得懂，在于在公司企业里，虽然会要求有独立开发的能力，但是实际上大厂往往分工很细，团队一起完成，这样也就涉及到了团队之间的项目对接，这个时候，你把未注释的代码发过去，对面微微一笑，显然，可读性比较差。因此，注释也要让别人能看懂咱们写的代码。
②单行注释
Go语言中的单行注释使用 // 符号。例如：
go
// 这是单行注释
// 输出Hello,World!
fmt.Println("Hello, World!")③多行注释
多行注释或块注释可以使用 /* 和 */ 包裹一段文字。例如：
go
/*
这是一个多行注释。
可以跨越多行。
同样实现的是 输出Hello,World!
*/
fmt.Println("Hello, World!")一个小案例，使用go语言输出Hello World!：
go
//Code_流苏(CSDN)
package main
import "fmt"
//单行注释
/*多行注释 与C、C++相同*/
func main() {
fmt.Println("Hello World!")
}
2、变量
①变量的定义
在Go语言中，变量可以通过 var 关键字来定义，格式为 var 变量名 变量类型。Go语言也支持类型推断，所以可以不显式声明变量类型。例如：
go
var a int = 10 // 显式类型声明
var b = 20 // 类型推断\案例1 ：var定义单个变量
go
package main
import "fmt"
func main() {
// var用来声明变量name string是变量的类型
var name string = "yueliusu"
//给name重新赋值
name = "123"
//输出打印name，并换行
fmt.Println(name)
}
案例2 ：var定义多个变量
go
package main
import "fmt"
func main() {
//var关键字定义多个变量
var (
name string
age int
addr string
)
name = "yueliusu"
age = 21
addr = "henan"
fmt.Println(name, age, addr)
}
案例3 ：短变量声明：=方式来定义变量
在Go语言中，还可以使用短变量声明的方式来定义变量，例如在函数内部使用:=来进行变量的定义和初始化。但在全局作用域中，或者需要显式指定变量类型的场景下，就需要像上述示例那样使用var关键字进行定义。
go
package main
import "fmt"
func main() {
//:= 短变量声明 自动推导 自动声明变量的类型
name := "yueliusu" //通过所赋的值，自动识别出为string类型，说明name要声明为string类型
age := 21 //通过所赋的值，自动识别出为int类型，说明age要声明为int类型
fmt.Println(name, age)
fmt.Printf("%T,%T", name, age)
}
②交换
在C、C++、JAVA等语言中，我们在进行变量交换的时候，一般会考虑使用临时变量，来作为交换的中间者，例如下图，我们要实现A与B交换，那么可以先将A的值给C，然后B的值给A，最后再将C的值给B，这样变量交换就完成了。
但是在Go语言中，可以利用平行赋值 的特性来交换两个变量的值，无需使用临时变量。例如：
go
a, b := 1, 2
a, b = b, a // 交换a和b的值案例：交换a,b的值，
go
package main
func main() {
//var定义变量a b，将其声明为int类型，并分别赋值100 200
var a int = 100
var b int = 200
//交换前
println("交换前 a =", a, "a =", b) //a = 100 a = 200
//平行赋值
b, a = a, b
//交换后
println("交换后 a =", a, "b =", b) //a = 200 b = 100
}
③变量的本质
在Go语言中，变量的本质是一块用于存储数据的内存空间。
变量赋值实际上是改变这块内存空间存储的值。
案例：打印变量
go
package main
import "fmt"
func main() {
var num int
num = 100
//打印变量的内存地址 %p
fmt.Printf("num:%d,内存地址:%p \n", num, &num) //&为取地址
num = 200
fmt.Printf("num:%d,内存地址:%p", num, &num)
// 打印内存地址的方式之一。 Print f格式化输出
// 第一个参数 输出字符串
// % 占位符。
// 占位符的数量，要和后面待输出的数量保持一致
// %d 数字 int d
// %p 内存地址，num需要取出变量的地址。
// %s 字符串。
// \n 换行
}
可以看到咱们定义的变量，其实是在内存中开辟了一个空间，而这个空间里可以存放数据。如图0x开头的那就是所开辟空间的地址，而100、200则是这个空间中存放的数据。
④匿名变量
在Go语言中，匿名变量用一个下划线 _ 表示，它可以忽略函数返回值时的占位符，不占用命名空间，也不会分配内存。
go
_, b := 5, 7 // 忽略第一个返回值案例：匿名变量的实现与打印输出
go
package main
import "fmt"
func test() (int, int) {
return 100, 200
}
//Go 语言中，匿名变量（或称为空白标识符）是一个特殊的变量：_。
//它用于在不需要使用到某个变量值的场合。
//使用匿名变量的好处是可以避免编译器错误，比如当函数返回多个值而你只需要其中一部分时。
func main() {
//_为匿名变量的显示方式
//a, b := test()
//fmt.Println(a, b)
a, _ := test()
fmt.Println(a)
_, b := test()
fmt.Println(b)
fmt.Println(a, b)
}
/*匿名变量不占用命名空间，不会分配内存，因此不存在重复定义的问题。
它通常仅用于忽略函数的返回值或忽略循环中的部分变量。*/
//在函数的调用中，每一次出现的匿名变量都是独立的，它们之间不共享值。
⑤变量的作用域
变量的作用域是指程序中变量可以被访问的范围。在Go语言中，变量可以有三种作用域或身份：
- 局部变量
局部变量在函数内部定义，只在该函数内部有效；
- 全局变量
全局变量在函数外部定义，整个包都可以访问；
- 形式参数
形式参数在函数定义中，作为函数的输入。
案例：作用域
go
package main
import "fmt"
// 全局变量
var name string = "zhangsan"
func main() {
// =表示赋值，将等号右边的值赋值给左边的值
// 局部变量
var age int = 18
var name string = "lisi"
//输出打印出来是局部变量name的值
fmt.Println(name, age)
//输出打印出来是全局变量name的值
aaa()
}
func aaa() {
fmt.Println(name)
}
此外，咱们还需要知道一个原则，变量声明中时需要注意的，就近原则。
案例：就近原则
go
package main
import "fmt"
// Go语言程序中全局变量与局部变量名称可以相同，但是函数体内的局部变量会被优先考虑。
// string int float64 浮点数（小数）
var a float64 = 3.14
func main() {
var a float64 = 2.18
fmt.Println(a) //2.18
}
从输出结果上我们可以看出来，首先全局声明了a（全局变量），并进行了赋值，后面又在main函数中再次声明了a（局部变量），之后输出的值为后者的值2.18，也就是在一个变量同时进行全局和局部声明的话，在输出时，会就近输出。
⑥常量
在Go语言中，常量是使用 const 关键字定义的，一旦定义不能被修改。常量可以是字符、字符串、布尔或数值类型。
简单来说，常量就是不能变化的量。例如下面咱们定义一个圆周率π = 3.14，那么通过const定义后，它便不能修改了。
go
const Pi = 3.14案例：常量的定义与打印输出
go
package main
import (
"fmt"
)
func main() {
//常量使用const来声明
const URL string = "https://yueliusu.blog.csdn.net/" //显示定义
const URL2 = "https://yueliusu.blog.csdn.net/" //隐式定义
const a, b, c = 3.14, "yueliusu", false //同时定义多个常量
fmt.Println(URL)
fmt.Println(URL2)
fmt.Println(a, b, c)
}
⑦iota
在Go语言中，iota 是一个特殊的常量，它用于在 const 关键字下创建一系列相关的常量。当在一个 const 块中使用 iota 时，它会自动从0开始计数，每定义一个常量，iota 的值就会自增1。
go
package main
import "fmt"
// iota 常数计数器
// 在Go语言中，iota 是一个特殊的常量，它用于在 const 关键字下创建一系列相关的常量。
// 当在一个 const 块中使用 iota 时，它会自动从0开始计数，每定义一个常量，iota 的值就会自增1。
func main() {
const (
a = iota //0
b //1
c //2
d = "haha"//haha (3)
e //haha (4)
f = 100 //100 (5)
g //100 (6)
h = iota //7
i //8
)
const (
j = iota //0
k //1
l //2
)
fmt.Println(a, b, c, d, e, f, g, h, i, j, k, l)
}
3、总结
1.注释，给自己看也给别人看，良好习惯
2.变量的定义 var 变量名 变量类型
3.变量的赋值 变量 = 变量值
4.变量定义，短变量声明 ：= ，只能用在变量中，可以自动推导基本数据类型、只能用在局部变量中
5.变量的本质- 内存空间，变量的赋值-往空间里放东西
6.匿名变量 _
7.变量的作用域 ：全局变量、局部变量 （同名-就近原则）
8.常量的定义和场景 （const）无法修改的值才会设置为常量，方便使用，通常使用大写
很感谢你能看到这里，如有相关疑问，还请下方评论留言。
Code_流苏(CSDN) （一个喜欢古诗词和编程的Coder😊）
希望本篇内容能对大家有所帮助，如果大家喜欢的话，请动动手点个赞和关注吧，非常感谢你们的支持！