变量
1、为什么要变量
1.1、一个程序就是一个世界
1.2、变量是程序的基本组成单位
2、变量的介绍
2.1、变量的概念
变量相当于内存中一个数据存储空间的表示，你可以把变量看做是一个房间的门牌号，通过门牌号我们可以找到房间，同样的道理，通过变量名可以访问到变量(值)。
2.2、变量的使用步骤
1) 声明变量（定义变量）
2) 非变量赋值
3) 使用变量
3、变量快速入门
package main
import "fmt"
func main(){
// 定义变量
var i int
i = 10
fmt.Println("i = ", i)
}
4、变量使用注意事项
1) 变量表示内存中的一个存储区域
2) 该区域有自己的名称（变量名）和类型（数据类型）
3) Golang 变量使用的三种方式
- 指定变量类型，声明后若不赋值，使用默认值
package main
import "fmt"
func main(){
// 定义变量
var i int
// 默认值
fmt.Println("i = ", i)
}
- 根据值自行判断变量类型(类型推导)
var num = 10.11
fmt.Println("num = ", num)- 省略var，注意
:=左侧的变量不应该是已经声明过的，否则会导致编译错误
name := "tom"
// 等价于 var name string; name = "tom"
fmt.Println("name = ", name)- 多变量声明
package main
import "fmt"
func main() {
// 一次定义多个变量
var n1, n2, n3 int
n1 = 1
n2 = 2
n3 = 3
fmt.Println("n1 = ", n1, " n2 = ", n2, " n3 = ", n3)
// 一次定义并赋值多个变量
var n4, name = 100, "tom"
fmt.Println("n4 = ", n4, " name = ", name)
// 使用类型推导实现声明
n5, age := 100, 20
fmt.Println("n5 = ", n5, " age = ", age)
}4) 一次性什么多个全局变量
var n1 = 100
var n2 = 200
// 上面的声明方式，等价于下面
var (
n1 = 100
n2 = 200
)5) 该区域的数据值可以在同一类型范围内不断变化(重点)
6) 变量在同一个作用域(在一个函数或者在代码块)内不能重名
7) 变量=变量名+值+数据类型，这一点请大家注意，变量的三要素
8) Golang的变量如果没有赋初值，编译器会使用默认值,比如int默认值0 string默认值为空串，小数默认为0
5、变量的申明，初始化和赋值
(1) 声明变量
var 变量名 数据类型(2) 初始化变量
var a int = 45
var b = 400(3) 给变量赋值
var num int
num = 106、程序中 + 号的使用
1) 当左右两边都是数值型时，则做加法运算
2) 当左右两边都是字符串，则做字符串拼接
package main
import "fmt"
func main() {
var n1, n2 = 100, 200
fmt.Println("n1 + n2 = ", n1+n2)
var s1, s2 = "a", "b"
fmt.Println("a + b = ", s1+s2)
}7、数据类型的基本介绍
8、整数类型
8.1、基本介绍
简单的说，就是用于存放整数值的，比如0,-1,2345等等
8.2、案例演示
8.3、整数的各个类型
| 类型 | 有无符号 | 占用存储空间 | 表数范围 | 备注 |
|---|---|---|---|---|
| int8 | 有 | 1字节 | -128～127 | |
| int16 | 有 | 2字节 | -2^15~2^15-1 | |
| int32 | 有 | 4字节 | -2^31~2^31-1 | |
| int64 | 有 | 8字节 | -2^63~2^63-1 | |
| uint8 | 无 | 1字节 | 0～255 | |
| uint16 | 无 | 2字节 | 0～2^16-1 | |
| uint32 | 无 | 4字节 | 0～2^32-1 | |
| uint64 | 无 | 8字节 | 0～2^64-1 | |
| int | 有 | 32位系统 4字节 64位系统8字节 |
-2^31~2^31-1 -2^63~2^63-1 |
|
| unit | 无 | 32位系统 4字节 64位系统8字节 |
0~2^32-1 0~2^64-1 |
|
| rune | 有 | 与int32一样 | -2^31~2^31-1 | 表示unicode码 |
| byte | 无 | 与int8一样 | 0~255 | 当要存储字符时选用byte |
package main
import "fmt"
func main() {
var i int = 1
fmt.Println("i=", i)
// 测试 int8 的范围 -127~128
var j int8 = 127
fmt.Println("j=", j)
// 测试 uint8 的范围 0~255
var k uint8 = 277
fmt.Println("k=", k)
// 测试 int 的范围
var a int = 8900
fmt.Println("a=", a)
var b unit = 1
var c byte = 255
fmt.Println(b)
fmt.Println(c)
}
8.4、整型的使用细节
1) Golang 各整数类型分， 有符号和无符号, int unit 的大小和系统有关
2) Golang 的整数默认声明为int 类型
// 数字类型默认是int 类型
var c = 200
fmt.Printf("j的类型为 %T \n", c)
// fmt.Printf() 可以用于做格式化输出
// unsafe.Sizeof() 是 unsafe包的一个函数，可以返回变量的占用字节数
var d int64 = 11
fmt.Printf("d 的数据类型为 %T, d占用 %d 个字节", d, unsafe.Sizeof(d))3) Golang 程序中整数变量在使用时，遵守保小不保大原则，即: 在保证程序正确运行下，尽量使用占用空间小的数据类型【年龄】
4) bit: 计算机中的最小存储单位。 byte: 计算机中基本存储单元。 1 byte = 8 bit
9、小数类型/浮点型
9.1、基本介绍
小数类型就是用于存放小数的，比如1.20.23-1.911
9.2、案例
package main
import "fmt"
func main(){
var price float32 = 89.12
fmt.Println("price=", price)
}
9.3、分类
| 类型 | 占用存储空间 | 表数范围 |
|---|---|---|
| 单精度float32 | 4字节 | -3.403E38~3.403E38 |
| 双精度float64 | 8字节 | -1.798E308~1.798E308 |
1) 关于浮点数在机器中存放形式的简单说明,浮点数=符号位+指数位+尾数位
2) 尾数部分可能丢失，造成精度损失。如果我们要保存一个精度高的数，则应该选用float64
// 可能造成精度丢失
var num3 float32 = -123.0000901
var num4 float64 = -123.0000901
fmt.Println("num3=", num3, "num4=", num4)9.4、浮点型 使用细节
1) Golang 浮点类型有固定的范围和字段长度，不受具体OS的影响
2) Golang 浮点默认声明为float64 类型
var num5 = 1.1
fmt.Printf("num5的类型为%T", num5)3) 浮点型常量有两种表示方法
- 十进制: 56.12
- 科学计数方式：56.12 = 5.612E1
4) 通常情况下，应该使用float64，因为它比float32更精确。[开发中，推荐使用float64]
10、字符类型
10.1、基本介绍
Golang中没有专门的字符类型，如果要存储单个字符(字母)，一般使用byte来保存。字符串就是一串固定长度的字符连接起来的字符序列。
Go的字符串是由单个字节连接起来的。也就是说对于传统的字符串是由字符组成的，而Go的字符串不同，它是由字节组成的。
10.2、案例
var c1 byte = 'a'
var c2 byte = '0'
// 输出c1,c2 对应的码值
fmt.Println("c1=", c1)
fmt.Println("c2=", c2)
// 输出c1,c2 对于当的字符
fmt.Printf("c1=%c", c1)
fmt.Printf("c2=%c", c2)
var c3 int = '北'
fmt.Printf("c3= %c c3 对于的码值为=%d", c3, c3)1) 如果我们保存的字符在ASCII表的,比如[0-1,a-z,A-Z..]直接可以保存到byte
2) 如果我们保存的字符对应码值大于255,这时我们可以考虑使用int类型保存
3) 如果我们需要安装字符的方式输出，这时我们需要格式化输出，即fmt.Printf("%c",c1)
10.3、字符类型使用细节
1) 字符常量是用单引号('')括起来的单个字符
2) Go中允许使用转义字符'’来将其后的字符转变为特殊字符型常量
3) Go语言的字符使用UTF-8编码(英文字母-1个字节汉字-3个字节)
4) 在Go中，字符的本质是一个整数，直接输出时，是该字符对应的UTF-8编码的码值。
5) 可以直接给某个变量赋一个数字，然后按格式化输出时%c，会输出该数字对应的unicode字符
var c4 int = 22269
fmt.Printf("c4=%c\n", c4)
6) 字符类型是可以进行运行的，相当于一个整数，因为它都对应有Unicode码
var n1 = 10 + 'a'
fmt.Println("n1=", n1)
10.4、字符类型本质探讨
1) 字符型存储到计算机中，需要将字符对应的码值（整数）找出来
存储：字符--->对应码值---->二进制-->存储
读取：二进制---->码值---->字符-->读取
2) 字符和码值的对应关系是通过字符编码表决定的(是规定好)
3) Go语言的编码都统一成了utf-8。非常的方便，很统一，再也没有编码乱码的困扰了
11、布尔类型
11.1、基本介绍
1) 布尔类型也叫bool类型，bool类型数据只允许取值true和false
2) bool类型占1个字节。
3) bool类型适于逻辑运算，一般用于程序流程控制
11.2、案例
func main(){
var b = false
fmt.Println("b=", b)
fmt.Println("b 占用空间 = ", unsafe.Sizeof(b))
}
12 string 类型
12.1、基本介绍
字符串就是一串固定长度的字符连接起来的字符序列。Go的字符串是由单个字节连接起来的。Go语言的字符串的字节使用UTF-8编码标识Unicode文本
12.2、案例
func main(){
var addr string = "南京"
fmt.Println(addr)
}
12.3、细节
1) Go语言的字符串的字节使用UTF-8编码标识Unicode文本，这样Golang统一使用UTF-8编码
2) 字符串一旦赋值了，字符串就不能修改了
var str = "hello"
str[0] = 'a' // 是不允许的
3) 字符串的两种表示形式
- 双引号， 会转义
- 反引号，以字符串的原生形式输出，包括换行和特殊符号
4) 字符串拼接方式
var str = "hello " + "world"
str += " haha!"
5) 当一行字符串太长时，需要使用到多行字符串，可以如下处理
// 需要将加号 保留在上一行
str1 := "11" + "22" +
"33" + "44"
13、基本数据类型的默认值
13.1、基本介绍
在go中，数据类型都有一个默认值，当程序员没有赋值时，就会保留默认值，在go中，默认值又叫零值
| 数据类型 | 默认值 |
|---|---|
| 整数 | 0 |
| 浮点数 | 0 |
| 字符串 | "" |
| 布尔类型 | false |
14、基本数据类型的相互转换
14.1、介绍
Golang和java/c不同，Go在不同类型的变量之间赋值时需要显式转换。也就是说Golang中数据类型不能自动转换
14.2、语法
表达式T(v)将值v转换为类型T
14.3、案例
package main
import "main"
func main(){
var i int32 = 100
var n1 float32 = float32(i)
var n2 int8 = int8(i)
var n3 int64 = int64(i)
fmt.Printf("i=%v, n1=%v, n2=%v, n3=%v", 1, n2, n2, n3)
}
14.4、注意事项
1) Go 中，数据类型的转换可以是从表示范围小-->表示范围大，也可以范围大--->范围小
2) 被转换的是变量存储的数据(即值)，变量本身的数据类型并没有变化！
var i int32 = 100
var n3 int64 = int64(i)
fmt.Printf("i = %v, i = %T", i, i)
3) 在转换中，比如将int64转成int8【-128---127】，编译时不会报错，只是转换的结果是按溢出处理，和我们希望的结果不一样。因此在转换时，需要考虑范围.
15、基本数据类型和string的转换
15.1、介绍
在程序开发中，我们经常将基本数据类型转成string,或者将string转成基本数据类型。
15.2、基本类型转string类型
方式1: fmt.Sprintf("%参数"， 表达式)
var num int = 99
var num2 float64 = 22.33
var b bool = true
var myChar byte = 'j'
var str string
str = fmt.Sprintf("%d", num)
fmt.Printf("str type %T str=%q\n", str, str)
str = fmt.Sprintf("%f", num2)
fmt.Printf("str type %T str=%q\n", str, str)
str = fmt.Sprintf("%t", b)
fmt.Printf("str type %T str=%q\n", str, str)
str = fmt.Sprintf("%c", myChar)
fmt.Printf("str type %T str=%q\n", str, str)
方式2：使用strconv 包的函数
var num1 int = 99
var num2 float64 = 23.456
var b bool = true
str = strconv.FormatInt(int64(num1), 10)
fmt.Printf("str type %T str=%q\n", str, str)
str = strconv.FormatFloat(num2, 'f', 10, 64)
fmt.Printf("str type %T str=%q\n", str, str)
str = strconv.FormatBool(b)
fmt.Printf("str type %T str=%q\n", str, str)
//将int类型数据转换为对应的字符串表示。
str = strconv.Itoa(int(num2))
15.3、string类型转基本数据类型
var str string = "true"
var b bool
b,_ = strconv.ParseBool(b)
fmt.Printf("b type %T, b = %v\n", b, b)
var str2 string = "123456"
var n1 int64
var n2 int
n1, _ = strconv.ParseInt(str2, 10, 64)
n2 = int(n1)
fmt.Printf("n1 type %T, n1 = %v\n", n1, n1)
fmt.Printf("n2 type %T, n2 = %v\n", n2, n2)
var str3 string = "123.44"
var f1 float64
f1, _ = strconv.ParseFloat(str3, 64)
fmt.Printf("f1 type %T, f1 = %v\n", f1, f1)
15.4、注意事项
在将String类型转成基本数据类型时，要确保String类型能够转成有效的数据，比如我们可以把"123",转成一个整数，但是不能把"hello"转成一个整数，如果这样做，Golang直接将其转成0，其它类型也是一样的道理.float=>0 bool=>false
也就是，如果转换失败的话，使用默认值赋值，不管原来是否有值。
16、指针
16.1、介绍
1) 基本数据类型，变量存的就是值，也叫值类型
2) 获取变量的地址，用&
var num int //获取num的地址：&num
3) 指针类型，指针变量存的是一个地址，这个地址指向的空间存的才是值
var ptr *int = &num
4) 获取指针类型所指向的值，使用：*
var ptr *int // 使用 *ptr 或者 ptr 指向的值
16.2、注意事项
1) 值类型,都有对应的指针类型，形式为数据类型，比如int的对应的指针就是*int,float32对应的指针类型就是*float32,依次类推
2) 值类型包括：基本数据类型int系列,float系列,bool,string、数组和结构体struct
17、值类型和引用类型
17.1、值类型和引用类型的说明
1) 值类型：基本数据类型int系列,float系列,bool,string、数组和结构体struct
2) 引用类型：指针、slice切片、map、管道chan、interface等都是引用类型
17.2、值类型和引用类型的使用特点
1) 值类型： 变量直接存储值，内存通常在栈中分配
2) 引用类型：变量存储的是一个地址，这个地址对应的空间才真正存储数据(值)，内存通常在堆上分配，当没有任何变量引用这个地址时，该地址对应的数据空间就成为一个垃圾，由GC来回收
18、标识符的命名规范
18.1、标识符概念
Golang对各种变量、方法、函数等命名时使用的字符序列称为标识符
凡是自己可以起名字的地方都叫标识符
18.2、标识符的命名规则
1） 由26个英文字母大小写，0-9，_组成
2） 数字不可以开头。
var num int //ok
var 3num int //error
3) Golang中严格区分大小写
4) 标识符不能包含空格
5) 下划线**_**本身在Go中是一个特殊的标识符，称为空标识符。可以代表任何其它的标识符，但是它对应的值会被忽略(比如：忽略某个返回值)。所以仅能被作为占位符使用，不能作为标识符使用
var _ int = 50
fmt.Println(_) // 报错
18.3、标识符命名注意事项
1） 包名：保持package的名字和目录保持一致，尽量采取有意义的包名，简短，有意义，不要和标准库不要冲突2）变量名、函数名、常量名：采用驼峰法
3）如果变量名、函数名、常量名首字母大写，则可以被其他的包访问；如果首字母小写，则只能在本包中使用(注：可以简单的理解成，首字母大写是公开的，首字母小写是私有的),在golang没有public,private等关键字。
19、系统保留关键字
20、系统的预定义标识符
