名人说：莫道桑榆晚，为霞尚满天。——刘禹锡（刘梦得，诗豪）
创作者：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 main

import "fmt"

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

2、变量

①变量的定义

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

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

案例1 ：var定义单个变量

package main

import "fmt"

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

案例2 ：var定义多个变量

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关键字进行定义。

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

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

案例：交换a,b的值，

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语言中，变量的本质是一块用于存储数据的内存空间。

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

案例：打印变量

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

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

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

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

• 局部变量

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

• 全局变量

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

• 形式参数

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

案例：作用域

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)
}

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

案例：就近原则

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定义后，它便不能修改了。

const Pi = 3.14

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

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。

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😊）
希望本篇内容能对大家有所帮助，如果大家喜欢的话，请动动手点个赞和关注吧，非常感谢你们的支持！