go变量和常量

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