02-Go语言基础之变量
标识符与关键字
在编程语言中标识符就是程序员定义的具有特殊意义的词，比如变量名、常量名、函数名等等。
Go语言中标识符由字母数字和_(下划线）组成，并且只能以字母和_开头。
举几个例子：abc, _, _123, a123。
关键字是指编程语言中预先定义好的具有特殊含义的标识符。 关键字和保留字都不建议用作变量名。
Go语言中有25个关键字，自定义变量不得使用如下名字。
break default func interface select
case defer go map struct
chan else goto package switch
const fallthrough if range type
continue for import return var
保留关键字，如内置函数等
Constants:
true false iota nil
Types:
int int8 int16 int32 int64
uint uint8 uint16 uint32 uint64 uintptr
float32 float64 complex128 complex64
bool byte rune string error
Functions:
make len cap new append copy close delete
complex real imag
panic recover
变量
变量是对内存中数据存储空间的表示，如同门牌号对应着房间，同样的，变量名字对应变量的值。
变量使用步骤
1.声明变量，定义变量
2.给与变量赋值
3.使用变量
变量数据类型
变量Variable的作用是存储数据，不同的数据需要保存的类型不一样，如工资，年龄，姓名，家庭住址等。
常见的变量数据类型有，整数，浮点数，字符串，布尔值等。
变量声明
不同于Python等其他语言，定义变量与使用非常简洁，Go作为编译型语言，需要严格声明变量后，且必须使用。
案例
package main
import "fmt"
func main() {
var name string //声明变量名 name
name = "超哥" //给与变量赋值
fmt.Println("name的值是：", name) //使用变量
}
// 运行结果
name的值是： 超哥
变量使用过程
代码读取
变量加载到内存 name 指向 内存地址的值"超哥"
1）变量含有名字，变量类型
变量定义方式
定义变量与类型，不赋值，含有默认值
语法：var 语句定义变量的列表，类型在后面，可以定义局部变量也可以，也可全局变量
var name string
var age int
var dbStatus bool
变量批量声明
go语言支持批量声明变量，注意这里只是等于定义了变量的名字，类型，而没有赋值操作。
var 变量名 变量类型
var 变量名,变量名,变量名 int // 一次定义三个int类型变量
var(
name string
age int
salary float32
isOk bool
)
变量初始化
注意，这里只是定义了三个变量，以及设定了变量的类型，不赋值的话，每种数据类型有自己的默认值。
package main
import "fmt"
func main() {
var age int
fmt.Println("age的值是：", age)
var name string
fmt.Println("name的值是：", name)
var salary float64
fmt.Println("salary的值是：", salary)
}
执行结果
age的值是： 0
name的值是：
salary的值是： 0
声明变量且赋值
package main
import "fmt"
func main() {
var age int
age=18
fmt.Println("age的值是：", age)
var name string
name="www.yuchaoit.cn"
fmt.Println("name的值是：", name)
var salary float64
salary=5400.68
fmt.Println("salary的值是：", salary)
}
结果
age的值是： 18
name的值是： www.yuchaoit.cn
salary的值是： 5400.68
编译器自动推导变量类型
go支持让你偷懒不写变量类型，go编译器根据等于号右边的值，判断变量类型。
package main
import "fmt"
func main() {
var num, num1 = 10, 11
fmt.Println("两个数字分别是：", num, num1)
var name, age, addr = "www.yuchaoit.cn", 18, "北京朝阳"
fmt.Println(name, age, addr)
}
/*
结果
两个数字分别是： 10 11
www.yuchaoit.cn 18 北京朝阳
*/
短变量声明
- 注意，只能在函数内部使用该语法
- 全局作用域下，必须用var关键字定义变量
package main
import "fmt"
// 定义全局变量
var name1 = "于超老师"
func main() {
//定义局部变量，简短声明
name := "超哥"
fmt.Println("name的值是：", name)
//上述段声明等于如下完整过程
var name2 string
name2 = "超哥"
fmt.Println("name2的值是：", name2)
//打印全局定义变量
fmt.Println("全局变量name1", name1)
}
/*
name的值是： 超哥
name2的值是： 超哥
全局变量name1 于超老师
*/
短变量声明也支持多个变量
package main
import "fmt"
func main() {
//一次性声明多个变量，int默认值
var n1, n2, n3 int
fmt.Println(n1, n2, n3)
//声明多个变量，且赋值
var c1, c2, c3 = "chaoge", 18, 99.99
fmt.Println(c1, c2, c3)
//短声明多个变量
a1, a2, a3 := "yu", 17, 100.0
fmt.Println(a1, a2, a3)
}
/*
0 0 0
chaoge 18 99.99
yu 17 100
*/
一次性声明多个全局变量
package main
import "fmt"
// 声明全局变量方式1
var n1 = 100
var n2 = 200
var n3 = 300
// 声明全局变量方式2
var (
d1, d2, d3 = 1, 2, 3
)
// 声明全局变量方式3
var (
c1 = 100
c2 = 200
c3 = 300
)
func main() {
fmt.Println("主程序main执行中")
fmt.Println(n1, n2, n3)
fmt.Println(d1, d2, d3)
fmt.Println(c1, c2, c3)
}
/*
主程序main执行中
100 200 300
1 2 3
100 200 300
*/
匿名变量
- go使用下划线作为特殊标识，等于丢弃变量的值，称为匿名变量（anonymous variable）
- 一般常用于函数的返回值丢弃
package main
import "fmt"
func t1() (int, string) {
return 10, "www.yuchaoit.cn"
}
func main() {
x, _ := t1()
_, y := t1()
fmt.Println("x=", x)
fmt.Println("y=", y)
}
/*
x= 10
y= www.yuchaoit.cn
*/
常见数据类型变量默认值
package main
import "fmt"
func main() {
// 只声明变量，不赋值，只有默认值
var age int
var name string
var gender bool
var salary float64
fmt.Println("age默认值 :", age)
fmt.Println("name默认值 :", name)
fmt.Println("gender默认值 :", gender)
fmt.Println("salary默认值 :", salary)
}
/*
age默认值 : 0
name默认值 :
gender默认值 : false
salary默认值 : 0
*/
综合变量练习
package main
import "fmt"
// 全局变量，允许定义后不用也行。
// 只申明变量名，不赋值，由编译器生成默认值
var serverName string
var serverIp string
var serverPort int
// 多变量声明，可自动推导变量类型
var (
sName = "db-51"
sIp = "10.0.0.100"
sPort = 3306
)
/*
多行注释语法
*/
var devName, devIp, devPort = "dev-ci", "10.0.0.77", 22
func main() {
// 注意，go里面定义字符串，是双引号
// go里的单引号，用于定义字符
// 简短声明只能在函数内，注意符号
s1 := "鸡你太美"
s2 := 'j' //打印的是ascii值
fmt.Println("字符串s1", s1)
// ./main.go:30:2: s2 declared but not used
fmt.Println("字符s2", s2)
//函数内的变量必须使用，不使用则报错
fmt.Println("全局变量打印", sName, sIp, sPort)
fmt.Println("全局变量打印", serverIp, serverPort, serverName)
fmt.Println("全局变量打印", devIp, devPort, devName)
// 声明类型后，必须赋值对应数据，否则报错
var opsServer string
// 修改变量值
opsServer = "slb-100"
opsServer = "slb-101"
opsServer = "slb-102"
fmt.Println("opsServer值：", opsServer)
}
/*
字符串s1 鸡你太美
字符s2 106
全局变量打印 db-51 10.0.0.100 3306
全局变量打印 0
全局变量打印 10.0.0.77 22 dev-ci
opsServer值： slb-102
*/
常量
上一节学习了变量，主要保存经常变化的值；
而常量是用于定义程序运行期间，不会改变的值。
定义常量语法区别是使用关键字const，并且必须赋值。
常量代表只读的，不可修改的值，用const关键字定义。
如同用常量定义 "π"之类的常数。
常量如同变量一样，可以批量声明，或者一组相关的常量。
常量的计算都在编译期间完成，并非运行期间！减少运行时的工作。
未使用的常量不会引发编译错误。
案例
package main
import (
"fmt"
)
//常量定义且赋值，完整写法
const World string = "世界"
// 多常量初始化
const x, y int = 1, 2
// 常量类型推断，字符串类型
const s1 = "Hello golang"
// 常量组
const (
e = 2.718
pi = 3.1415
b bool = true
)
// 常量组，可以除了第一个外其他的常量右边的初始化表达式可以省略
// 如果省略初始化表达式，默认使用前面常量的表达式
// 与上一个常量相同
const (
c1 = 1
c2
c3
c4 = "c44444"
c5
)
// 常量也可以定义函数的返回值
const (
f1 = "abc" //长度为3的字符串类型
f2 = len(f1) //返回长度的函数结果
)
func main() {
fmt.Println(World)
fmt.Println(x, y)
fmt.Println(s1)
fmt.Println(e, pi, b)
fmt.Println(c1, c2, c3, c4, c5)
fmt.Println(f1, f2)
}
/*
世界
1 2
Hello golang
2.718 3.1415 true
1 1 1 c44444 c44444
abc 3
*/
Iota常量生成器
常量声明可以使用iota常量生成器初始化，它用于生成一组以相似规则初始化的常量，但是不用每行都写一遍初始化表达式。
在一个const声明语句中，在第一个声明的常量所在的行，iota将会被置为0，然后在每一个有常量声明的行加一。
下面是来自time包的例子，它首先定义了一个Weekday命名类型，然后为一周的每天定义了一个常量，从周日0开始。
在其它编程语言中，这种类型一般被称为枚举类型。
// A Weekday specifies a day of the week (Sunday = 0, ...).
type Weekday int
const (
Sunday Weekday = iota
Monday
Tuesday
Wednesday
Thursday
Friday
Saturday
)
案例1
package main
import (
"fmt"
)
const (
Sunday = iota
Monday //通常省略后续行表达式
Tuesday
Wednesday
Thursday
Friday
Saturday
)
func main() {
fmt.Println(Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday)
}
// 0 1 2 3 4 5 6
案例2
如果iota表达式被打断，需要显示恢复
package main
import (
"fmt"
)
// iota在const关键字出现时将被重置为0。
// const中每新增一行常量声明将使iota计数一次
const (
A = iota //初始0
B // +1
C = "c" //iota枚举被打断 ，为 c
D // c，与上 相同。
E = iota // 4，显式恢复。注意计数包含了 C、D 两个，此时为4 。
F // 恢复iota 加一，此时为5
)
func main() {
fmt.Println(A, B, C, D, E, F)
// 0 1 c c 4 5
}
案例3
package main
import "fmt"
// iota在const关键字出现时将被重置为0。
// const中每新增一行常量声明将使iota计数一次
const (
n1 = iota //0
n2 = 100 //100
n3 = iota //2
n4 //3
)
// iota重新定义
const n5 = iota //0
func main() {
fmt.Println(n1, n2, n3, n4)
fmt.Println(n5)
}
/*
结果
0 100 2 3
0
*/
案例4
同样可以使用下划线，跳过某个常量值
一个方便查询的进制换算表
package main
import "fmt"
// iota在const关键字出现时将被重置为0。
// const中每新增一行常量声明将使iota计数一次
/*
<< 左移操作
1 << 10 表示将1的二进制，向左移动10位，也就是变为10000000000，换算十进制就是1024。
*/
const (
_ = iota
KB = 1 << (10 * iota) // 1024
MB = 1 << (10 * iota) // 1 << 20
GB = 1 << (10 * iota) // 1 << 30
TB = 1 << (10 * iota)
PB = 1 << (10 * iota)
)
func main() {
fmt.Println(KB, MB, GB, TB, PB)
// 1024 1048576 1073741824 1099511627776 1125899906842624
}
/*
结果
*/
案例5
多个iota定义在一行，迷惑考题。
package main
import "fmt"
// iota在const关键字出现时将被重置为0。
// const中每新增一行常量声明将使iota计数一次
const (
a, b = iota + 1, iota + 2 // 1,2
c, d = iota + 1, iota + 2 // 2,3
e, f //3,4
)
func main() {
fmt.Println(a, b)
fmt.Println(c, d)
fmt.Println(e, f)
}
/*
结果
1 2
2 3
3 4
*/