Go语言学习Day2：注释与变量

名人说：莫道桑榆晚，为霞尚满天。——刘禹锡（刘梦得，诗豪）
创作者：Code_流苏(CSDN)（一个喜欢古诗词和编程的Coder😊）

目录

1、注释
①为什么要写注释？
②单行注释
③多行注释

2、变量
①变量的定义
②交换
③变量的本质
④匿名变量
⑤变量的作用域
⑥常量
⑦iota

3、总结

1、注释

①为什么要写注释？

官方点儿来说，在编程中，注释是用来解释代码的目的和功能，以及某些实现的逻辑和原因。注释能够帮助其他开发者更好地理解和维护代码，同时也是自己未来回顾代码时的重要提示。良好的注释习惯可以提高代码的可读性和可维护性。

在咱们日常生活与工作中，写注释的作用无非两点：

自己看得懂

自己看得懂，是因为咱们开发一个项目，工程量大，代码量很多，如果不加注释，过了一段时间，就会感叹自己写了什么，看的两眼懵懵。如果加了注释，一看这个代码是做这个的，功能比如是增删改查等等，立马就清晰明了了。

别人看得懂

别人看得懂，在于在公司企业里，虽然会要求有独立开发的能力，但是实际上大厂往往分工很细，团队一起完成，这样也就涉及到了团队之间的项目对接，这个时候，你把未注释的代码发过去，对面微微一笑，显然，可读性比较差。因此，注释也要让别人能看懂咱们写的代码。

②单行注释

Go语言中的单行注释使用 // 符号。例如：

// 这是单行注释
// 输出Hello,World!
fmt.Println("Hello, World!")

③多行注释

多行注释或块注释可以使用 /* 和 */ 包裹一段文字。例如：

/*
这是一个多行注释。
可以跨越多行。
同样实现的是 输出Hello,World!
*/
fmt.Println("Hello, World!")

一个小案例，使用go语言输出Hello World!：

//Code_流苏(CSDN)
package mainimport "fmt"//单行注释
/*多行注释 与C、C++相同*/
func main() {fmt.Println("Hello World!")
}

2、变量

①变量的定义

在Go语言中，变量可以通过 var 关键字来定义，格式为 var 变量名变量类型。Go语言也支持类型推断，所以可以不显式声明变量类型。例如：

var a int = 10  // 显式类型声明
var b = 20      // 类型推断\

案例1 ：var定义单个变量

package mainimport "fmt"func main() {// var用来声明变量name string是变量的类型var name string = "yueliusu"//给name重新赋值name = "123"//输出打印name，并换行fmt.Println(name)
}

案例2 ：var定义多个变量

package mainimport "fmt"func main() {//var关键字定义多个变量var (name stringage  intaddr string)name = "yueliusu"age = 21addr = "henan"fmt.Println(name, age, addr)
}

案例3 ：短变量声明：=方式来定义变量

在Go语言中，还可以使用短变量声明的方式来定义变量，例如在函数内部使用:=来进行变量的定义和初始化。但在全局作用域中，或者需要显式指定变量类型的场景下，就需要像上述示例那样使用var关键字进行定义。

package mainimport "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语言中，可以利用平行赋值的特性来交换两个变量的值，无需使用临时变量。例如：

a, b := 1, 2
a, b = b, a  // 交换a和b的值

案例：交换a,b的值，

package mainfunc main() {//var定义变量a b，将其声明为int类型，并分别赋值100 200var a int = 100var 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语言中，变量的本质是一块用于存储数据的内存空间。

变量赋值实际上是改变这块内存空间存储的值。

案例：打印变量

package mainimport "fmt"func main() {var num intnum = 100//打印变量的内存地址 %pfmt.Printf("num:%d,内存地址:%p \n", num, &num) //&为取地址num = 200fmt.Printf("num:%d,内存地址:%p", num, &num)// 打印内存地址的方式之一。 Print  f格式化输出// 第一个参数 输出字符串// % 占位符。// 占位符的数量，要和后面待输出的数量保持一致// %d 数字 int d// %p 内存地址，num需要取出变量的地址。// %s 字符串。// \n 换行
}

可以看到咱们定义的变量，其实是在内存中开辟了一个空间，而这个空间里可以存放数据。如图0x开头的那就是所开辟空间的地址，而100、200则是这个空间中存放的数据。

④匿名变量

在Go语言中，匿名变量用一个下划线 _ 表示，它可以忽略函数返回值时的占位符，不占用命名空间，也不会分配内存。

_, b := 5, 7  // 忽略第一个返回值

案例：匿名变量的实现与打印输出

package mainimport "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语言中，变量可以有三种作用域或身份：

局部变量

局部变量在函数内部定义，只在该函数内部有效；

全局变量

全局变量在函数外部定义，整个包都可以访问；

形式参数

形式参数在函数定义中，作为函数的输入。

案例：作用域

package mainimport "fmt"// 全局变量
var name string = "zhangsan"func main() {// =表示赋值，将等号右边的值赋值给左边的值// 局部变量var age int = 18var name string = "lisi"//输出打印出来是局部变量name的值fmt.Println(name, age)//输出打印出来是全局变量name的值aaa()
}func aaa() {fmt.Println(name)
}

此外，咱们还需要知道一个原则，变量声明中时需要注意的，就近原则。

案例：就近原则

package mainimport "fmt"// Go语言程序中全局变量与局部变量名称可以相同，但是函数体内的局部变量会被优先考虑。
// string  int   float64  浮点数（小数）
var a float64 = 3.14func main() {var a float64 = 2.18fmt.Println(a) //2.18
}

从输出结果上我们可以看出来，首先全局声明了a（全局变量），并进行了赋值，后面又在main函数中再次声明了a（局部变量），之后输出的值为后者的值2.18，也就是在一个变量同时进行全局和局部声明的话，在输出时，会就近输出。

⑥常量

在Go语言中，常量是使用 const 关键字定义的，一旦定义不能被修改。常量可以是字符、字符串、布尔或数值类型。

简单来说，常量就是不能变化的量。例如下面咱们定义一个圆周率π = 3.14，那么通过const定义后，它便不能修改了。

const Pi = 3.14

案例：常量的定义与打印输出

package mainimport ("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。

package mainimport "fmt"// iota 常数计数器
// 在Go语言中，iota 是一个特殊的常量，它用于在 const 关键字下创建一系列相关的常量。
// 当在一个 const 块中使用 iota 时，它会自动从0开始计数，每定义一个常量，iota 的值就会自增1。
func main() {const (a = iota  //0b		 //1c		 //2d = "haha"//haha  (3)e		 //haha  (4)f = 100	 //100	 (5)	g		 //100	 (6)h = iota  //7i		 //8)const (j = iota //0k        //1l		//2)fmt.Println(a, b, c, d, e, f, g, h, i, j, k, l)
}