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