go基础语法
【1】、注释
我们为什么要写注释？
一个项目，是很多组成的。写的时候，你能看懂的。 半年、一年 （时间久了，自己写代码看不懂了）
对接、项目很多时候都是多人协作完成。（很难沟通，直接读懂代码是比较困难）
在刚开始学习的时候，不喜欢写注释。
什么是注释： 来描述我当前这个代码是做什么的，或者一些批注
写注释是一个十分良好的习惯，我们都应该按照要求给自己代码写好注释，为了自己，也为了他人。很多大公司里也是对注释有严格要求的。
// 单行注释
/*
多行注释
*/
// 代表是main包，下面如果存在 main 函数，那么就是程序的入口
package main
// 导入了一个 fmt 包，可以通过它来调用打印函数、输出一行话....
import "fmt"
// main函数 func 函数 main 函数的名字 () 没有参数
func main() {
// 打印了一句helloworld
fmt.Println("Hello,World！")
}
【2】、变量
1、变量的定义
程序 ： 我们向电脑说了一段话，需要电脑才能理解 （沟通机制 ，xxx语言 -- 汇编 -- 机器码）
电脑实际上识别的是机器码 ： 0 1 1 1 0 1 （高低电频）
机器码 ： 穿孔纸带
汇编：早些时候，现在的很多机器硬件底层代码，都是汇编
人能读懂的代码：英文、中文
将我们的语言和机器进行对接 （C、Java、Go ---> 编译器 --> 计算机中去执行：无需理解的，我们只需要写我们能看懂的代码即可 ）
我们理解的世界、和计算机的世界要一一对应：
定义：一切都是需要去定义的。
计算机也需要去定义一些东西。
名字（变量）
name = 张三
name = 李四
计算机也需要这样来认识我们写的代码，也需要一个格式
通过 var 关键字来定义变量
变量名字 需要告诉计算机这个信息（变量）是什么类型的，数据类型：数字、字符串、小数.... = "变量的值"
**公式：定义变量 var 变量名 变量类型 **
package main
import "fmt"
func main() {
var name string = "zhangsan"
var age int = 18
var a string
// string类型变量不赋值，默认是空字符串
var b int
// int类型变量不赋值，默认是0
// 可以同时定义多个变量 var()
var (
addr string
phone string
)
fmt.Printf("%s,%d\n", name, age)
name = "wangwu"
// 使用变量，直接打印即可
fmt.Printf("%s\n", a)
fmt.Printf("%d\n", b)
}
短变量的申明方式（语法糖，方便开发人员开发）
package main
import "fmt"
func main() {
// 只定义变量，不使用可以吗. 理论可以，实际在Go语言中不行。
// 无意义代码，报错！
// 问题1 ：能不能不写数据类型
// 问题2 ：不用var 直接定义变量呢？
// 自动推导，一个短变量声明
name := "kuangshen"
age := 18
// 语法糖（偷懒，简化开发！）
// := 相当于快递定义变量。如果给这个变量赋值了，那么会自动推导它的类型
// var 、 数据类型的定义都被省略的。
// 数据类型 go语言中基本的数据类型。
fmt.Println(name)
fmt.Println(age)
// 定义了变量name2
var name2 string
// 在快速声明中，如果 := 左边的变量已经存在了，那么它将无法创建，无法重新定义
name3 := "qinjiang222"
fmt.Println(name2)
fmt.Println(name3)
name3 = "zhangsan666"
}
小结
1、定义变量使用定式 var 变量名称 变量数据类型
2、给变量赋值 。 定义的时候直接赋值、 通过变量名来赋值、
3、语法糖 ：= 。 可以通过它来快速定义变量，如果是基本数据类型，字符串、数字，它会自动推导类型
2、变量的交换
package main
import "fmt"
func main() {
/* 在编程中遇到的第一个问题：变量交换
var a int = 100
var b int = 200
var t int
t = a
a = b
b = t
*/
// 在Go语言中，程序变量交换，也有语法糖
var a int = 100
var b int = 200
// fmt.Println 可以传递多个参数，用逗号隔开，直接打印
fmt.Println("a=", a, ",b=", b)
// 把a,b赋值给b,a 语法糖, 底层本质还是用到了临时变量。简化我们的开发
b, a = a, b
fmt.Println("交换后 a=", a, ",b=", b)
// 复杂的问题都给我们简单化了，我们开发很轻松，编译器帮我们在底层处理。
}
3、从内存地址理解变量
package main
import "fmt"
func main() {
// 变量到底是个什么玩意？
// num 实际上是一片内存空间
// 我们想要看一个变量的内存地址，只需要在变量名前加上 & 即可。
// 取地址符 （指针）
var num int
num = 1000
// 思考：这个num在计算机中是什么样子的。 num
fmt.Printf("num的值:%d,内存地址:%p\n", num, &num)
num = 2000
fmt.Printf("num的值:%d,内存地址:%p\n", num, &num)
// 汇编。理解一切
var name string
name = "张三"
// 思考：这个num在计算机中是什么样子的。 num
fmt.Printf("num的值:%s,内存地址:%p\n", name, &name)
name = "李四"
fmt.Printf("num的值:%s,内存地址:%p\n", name, &name)
// 打印内存地址的方式之一。 Print f格式化输出
// 内存
// 第一个参数 输出字符串
// % 占位符。
// 占位符的数量，要和后面待输出的数量一直
// %d 数字 int d
// %p 内存地址，num需要取出变量的地址。
// %s 字符串。
// \n 换行
//fmt.Printf("num的值:%d",num)
}
4、匿名变量
package main
import "fmt"
// 变量 ( 有名字、没有名字：匿名 )
// 十分特殊、匿名变量 （黑洞，一切东西丢进去，任何赋值给匿名变量的值都会被丢弃）
// _ 下划线，就是匿名变量在Go语言中
func main() {
a, b := test()
fmt.Println("a=", a, "b=", b)
// 我只想要test返回的第一个结果，此时就需要使用匿名变量
c, _ := test()
fmt.Println("c=", c)
_, d := test()
fmt.Println("d=", d)
}
// test 函数名 (参数1、参数2....)
func test() (int, int) {
return 1, 2
}
5、变量的作用域
package main
import "fmt"
// 全局变量：在当前的go文件中生效
// 定义在go文件中的非函数内，在package和import下面
// 全局变量在定义时必选使用var，不能使用语法糖
// 全局变量和局部变量是可以重名的，局部变量优先
var c int
func main() {
var a int = 3
var b int = 4
c = a + b
fmt.Printf("a=%d,b=%d,c=%d\n", a, b, c)
fmt.Printf("%p\n", &c) // 这里的c是全局变量
b = 2
c := a + b
fmt.Printf("a=%d,b=%d,c=%d\n", a, b, c)
fmt.Printf("%p\n", &c)
}
0xc683c8
a=3,b=4,c=7
0xb383c8
a=3,b=2,c=5
0xc00001a0f0
【3】、常量
常量： 不能变化的量。 这个变量是一个特殊的变量，无法改变的。 关键字 const
两个区别：变量的定义使用 var 、常量的定义是使用const
是什么机制导致他无法改变的？
Go语言底层的约定，实际上它是可以改变的，需要跳过常量名，直接找到内存地址，进行修改值。
package main
import "fmt"
func main() {
const URL string = "www.baidu.com"
const url string = "www.baidu.com"
// 对于常量来说，我们约定一般使用大写字母
// 常量不能使用语法糖定义
// 隐式定义，不加数据类型
const URL2 = "www.jd.com"
fmt.Println(URL, URL2)
// 常量允许定义之后不去使用，这就能说明常量和变量的内存地址是不一样的
}
1、特殊的常量
iota
// 特殊的常量 iota 常量计数器
package main
import "fmt"
func main() {
// iota 默认值是0，在一组const中，那么他会+1
// 可以理解为iota是计算常量的个数
const (
a = iota
b = iota
c = iota
// 0 1 2
d = 0
e = iota
// 0 1 2 0 4
// 在定义const的时候，如果下面的常量没有赋值，默认沿用上一个常量定义的赋值
f
g
h = iota
// 0 1 2 0 4 5 6 7
)
const (
i = iota
j = 0
k = iota
// 0 0 2
)
fmt.Println(i, j, k)
fmt.Println(a, b, c, d, e, f, g, h)
}