go 常量与变量拓展

常量

package main

import (
	"fmt"
	"reflect"
)

var c3 int

func main() {
	// 变量 定义公式： var 变量名 数据类型 = 值
	// 1. go 语言中定义变量 : 通过 var 关键字定义变量，后面跟上变量的类型
	var name string = "张阿三"
	var age int = 20
	fmt.Println(name, age)

	// 2. 定义空变量
	var name1 string // 默认值 为 空字符串
	var age1 int     // 默认值 为 0
	fmt.Println(name1, age1)

	// 3. 定义多个变量
	var (
		name2 string
		age2  int
	)
	// 给 变量 赋值
	name2 = "李啊四"
	age2 = 30
	fmt.Println(name2, age2)
	// 修改变量值
	fmt.Println("修改变量值：")
	name2 = "王啊五"
	age2 = 40
	fmt.Println(name2, age2)

	// 4. 直接定义变量 且 忽略数据类型.  自动推到，一个短变量声明
	name3 := "赵啊六" // := 相当于快速定义变量 ，仅支持go语言中的基本数据类型。
	fmt.Println(name3)

	/*
		// 如果 已经定义的变量，再次使用 := 快速声明，出现异常。因为该变量已经被声明
		var name4 string
		name4:="123"
	*/

	/*
		// 小结：
			1. 定义变量 var 变量名称 数据类型
			2. 给变量赋值，定义的时候可以直接赋值, 或者通过变量名赋值
			3. := 赋值。 如果是基本数据类型，字符串，数字会自动推到出变量数据类型
	*/

	// 5. 变量交换,底层还是引入 第三个变量交换数据
	var a int = 100
	var b int = 200
	fmt.Println("交换前：", a, b)
	b, a = a, b
	fmt.Println("交换后：", a, b)

	// 6. 变量的内存地址
	// 打印变量内存地址方式1: fmt.Printf 格式化输出
	/*
			// fmt.Printf
			- 有多少个 % 占位符，后面要跟多少个变量
			- %d 数值类型 int
			- %s 字符串 string
			- %p 内存地址 . 加上：&变量
		 	- &  取地址符号
	*/

	var num int
	num = 100
	fmt.Println("打印数据类型:", reflect.TypeOf(num)) // 打印数据类型

	fmt.Printf("1数据值=：%d ，内存地址=：%p\n", num, &num)
	fmt.Println("num=", num)
	num = 200
	fmt.Printf("2数据值=：%d ，内存地址：%p\n", num, &num)
	fmt.Println("num=", num)

	// 7.匿名变量
	// 特殊的变量，给匿名变量赋值，该数据就会被丢失，匿名变量不占用内存
	// 格式：_ 下划线开头
	// 在函数中，可以直接使用
	a1, _ := test()
	fmt.Println(a1)

	// 8. 变量的 作用域：局部变量和全局变量
	/*
		局部变量：只在一定区域生效

		全局变量：只在当前go文件中生效
			- 全局变量必须使用 var 或者 const 定义
			- 不能使用 := 赋值全局变量

	*/
	var c1 int = 3
	var c2 int = 4
	fmt.Printf("全局就近原则c3数据值1：%d\n", c3)    // 使用全局变量
	fmt.Printf("全局就近原则c3内存地址1：%p\n", &c3) // 使用全局变量
	c3 = c1 + c2
	fmt.Printf("全局就近原则c3数据值2：%d\n", c3)    // 使用全局变量
	fmt.Printf("全局就近原则c3内存地址2：%p\n", &c3) // 使用全局变量
	fmt.Printf("c1:%d , c2: %d , c3:%d\n", c1, c2, c3)
	c2 = 1
	c3 := c1 + c2 // := 重新定义变量。 使用c3 新变量，就近原则
	fmt.Printf("c3内存地址：%p\n", &c3)
	fmt.Printf("c1:%d , c2: %d , c3:%d\n", c1, c2, c3)
	c1 = 1
	c3 = c1 + c2 // 使用c3 新变量，就近原则
	fmt.Printf("c3内存地址：%p\n", &c3)
	fmt.Printf("c1:%d , c2: %d , c3:%d\n", c1, c2, c3)

}

func test() (int, int) {

	return 1, 2
}

变量

package main

import "fmt"

const ConstVariable = "Hello, World!"

func main() {
	/*
		常量： 理论上不能改变，实际上修改内存数据是可以改变该数据值
			- 格式：关键字 const 定义变量，通常使用大写定义常量，
		 	- 一旦定义常量，是不允许发生数据变更的
			- 不允许使用 := 定义常量。 :=只作用于变量
			- 在编译期间就已经确定了其值，因此它们不会分配内存，也就不存在内存地址的概念
	*/

	//1. 常规格式 : const 常量名 常量类型 = 数据值
	const URL string = "www.baidu.com"
	//2. 隐式定义： 常量自动推到数据类型,基于基本数据类型
	const URL2 = "www.bytedance.com"

	//3. 场景： PI：3.14
	const PI = 3.14
	fmt.Printf("常量地址：%p\n", PI) // 不存在
	constAddress := ConstVariable
	fmt.Println("constAddress:", constAddress)
	fmt.Printf("Address of const: %X\n", &constAddress)
	constAddress = "123"
	fmt.Println("constAddress:", constAddress)
	fmt.Printf("Address of const: %X\n", &constAddress)

	//4. 特殊常量iota 常量计数器， const 定义多个常量，使用 iota 实现自动计数。
	const (
		a = iota
		b = iota
		c
		d = 0
		e = iota
		// 如果 定义的 常量没有赋值，则 沿用上面一个常量的定义的赋值。即：iota自动自增
		f // iota(4)+1=5
	)
	fmt.Println(a, b, c, d, e, f)
	const (
		i = iota
		j = 0
		k = iota
	)
	fmt.Println(i, j, k)
}