【第五篇】Golang 从菜鸟到大咖的必经之路_Go 语言数据类型的基本介绍

一、数据类型的基本介绍：（思维导图）

二、数据类型：

一、基本介绍：

简单来说，就是用于存放数值的，比如 0，-1,2345 等等

---

二、案例演示：

一、整数的各个类型：

类型	有无符号	占用存储空间	表数范围	备注
int 8	有	1 字节	-128~127	-2^7-2^7-1
int 16	有	2 字节	-2^15~2^15-1
int 32	有	4 字节	-2^31~2^31-1
int 64	有	8 字节	-2^63~2^63-1

疑问：这个占用字节数不一样，对整型（int）有什么影响么？

答：占用的存储空间不一样，直接导致了表示数的范围不一样。

package main

import "fmt"

// 演示golang中 整数类型的使用
func main() {

	var i int = 1
	fmt.Println("i=", i)

	// 测试
	// var j int8 = 127
	// var j int8 = 128
	var j int8 = -128
	// var j int8 = -129 // 这里如果写int的话是可以正常输出的
	fmt.Println("j=", j)

}

• int 的无符号类型：

package main

import "fmt"

// 演示golang中 整数类型的使用
func main() {

	var i int = 1
	fmt.Println("i=", i)

	// 测试 int8的范围，-128~127
	// var j int8 = 127
	// var j int8 = 128
	// var j int8 = -128
	// var j int8 = -129 // 这里如果写int的话是可以正常输出的

	// 其它的，int16、int32、int64类推......
	// var j int8 = 127
	// fmt.Println("j=", j)

	// 测试一下，uint8的范围(0-255)，其它的以此类推
	var k uint8 = 256
	fmt.Println("k=", k)
}

• int 的其它类型的说明：

类型	有无符号	占用存储空间	表数范围	备注
int	有	32位系统4个字节64位系统8个字节	-2^312^31-1-2^632^63-1
uint	无	32位系统4个字节64位系统8个字节	02^32-102^64-1
rune	有	与 int 32 一样	-2^31~2^31-1	等价 int 32 ,表数一个Unicode码
byte	无	与 uint8 等价	0~255	当要存储字符时选用byte

package main

import "fmt"

// 演示golang中 整数类型的使用
func main() {

	var i int = 1
	fmt.Println("i=", i)

	// 测试一下，uint8的范围(0-255)，其它的以此类推
	var k uint8 = 255
	fmt.Println("k=", k)

	// int ,uint ,rune ,byte 的使用
	var a int = 8900
	fmt.Println("a=", a)
	var b uint = 1
	var c byte = 255
	fmt.Println("b=", b, "c=", c)
}

---

二、整型的使用细节：

1. Golang 各整数类型分：

• 有符号
• 无符号
• int 、uint 的大小和系统有关

\

1. Golang 的整数默认声明为int型

package main

import "fmt"

// 演示golang中 整数类型的使用
func main() {
	// 整型的使用细节：
	var n1 = 100 // ?n1 是什么类型？
	// 这里我们介绍一下，如何查看某个变量的数据类型
	// fmt.Printf() 用于格式化输出
	fmt.Printf("n1 的类型: %T", n1)
}

1. 如何在程序查看某个变量的字节大小和数据类型（使用较多）

package main

import (
	"fmt"
	"unsafe" //这里引入了新的包 unsafe ,用于输出字节数
)

// 演示golang中 整数类型的使用
func main() {
	// 整型的使用细节：
	var n1 = 100 // ?n1 是什么类型？
	// 这里我们介绍一下，如何查看某个变量的数据类型
	// fmt.Printf() 用于格式化输出
	fmt.Printf("n1 的类型: %T", n1)

	// 如何在程序中查看某个变量的占用字节大小和数据类型（使用较多）
	// unsafe.Sizeof(n1) 是 unsafe包的一个函数，可以返回n1变量占用的字节数
	var n2 int64 = 10
	fmt.Printf("n2 的类型: %T  n2占用的字节数是 %d", n2, unsafe.Sizeof(n2))
}

1. Golang 程序中整型变量在使用时，遵守保小不保大

• 即：在保证程序正确运行下，尽量使用占用空间小的数据类型。【如：年龄】

package main

import (
	"fmt"
)

// 演示golang中 整数类型的使用
func main() {

	// Golang 程序中整型变量在使用时，遵守保小不保大
	// 即：在保证程序正确运行下，尽量使用占用空间小的数据类型。【如：年龄】
	var age byte = 100 // 在实际开发中呢，尽量选择合适的，节省运行时间
	fmt.Println("age=", age)

}

1. bit：计算机中的最小存储单位。
2. byte：计算机中基本存储单元【二进制再详细说】

• 1 byte = 8 bit

---

三、小数类型/浮点型：

一、基本介绍

小数类型就是用于存放小数的，比如说：1.2 2.3 3.5

二、案例演示

package main

import (
	"fmt"
)

// 演示 golang 中小数类型使用：
func main() {

	var price float32 = 89.12
	fmt.Println("price=", price)
}

三、小数类型分类（了解）

类型	占用存储空间	表数范围
单精度float32	4字节	-3.403E38~3.403E38
双精度float64	8字节	-1.798E308~1.798E308

关于上图的说明：

1. 关于浮点数在机器中存放形式的简单说明，浮点数=符号位+指数位+尾数位

1. 1. 浮点数都是有符号的。

package main

import (
	"fmt"
)

// 演示 golang 中小数类型使用：
func main() {

	var price float32 = 89.12
	fmt.Println("price=", price)

	var num1 float32 = -0.00089
	var num2 float32 = -78009656.09
	fmt.Println("num1=", num1, "num2=", num2)
}

1. 尾数部分可能丢失，造成精度损失。-123.0000091（搞金融的一定要注意，注意！！！！）

package main

import (
	"fmt"
)

// 演示 golang 中小数类型使用：
func main() {

	var price float32 = 89.12
	fmt.Println("price=", price)

	var num1 float32 = -0.00089
	var num2 float32 = -78009656.09
	fmt.Println("num1=", num1, "num2=", num2)

	// 尾数部分可能丢失，造成精度损失。-123.0000091（搞金融的一定要注意，注意！！！！）
	var num3 float32 = -123.0000901
	var num4 float64 = -123.0000901
	fmt.Println("num3=", num3, "num4=", num4)
}

说明：float64 的精度比float32的要准确

说明：如果我们要保存一个精度高的数，则应该选用float64

1. 浮点型的存储分为三部分：符号+指数位+尾数位，在存储过程中，精度会有丢失

四、浮点型使用细节

1. Golang 浮点类型有固定的范围和字段长度，不受具体OS（操作系统）的影响。
2. Golang 的浮点型默认声明为 float 64 类型。

package main

import (
	"fmt"
)

// 演示 golang 中小数类型使用：
func main() {
    
	// Golang 的浮点型默认声明变量为float64 类型
	var num5 = 1.1
	fmt.Printf("num5的数据类型是 %T", num5)
}

1. 浮点数常量有两种表示形式：

1. 1. 十进制数形式：如：5.12 .512（必须有小数点儿）
   2. 科学计数法形式：如：5.1234e2 = 5.12 * 10^2 ，5.12E-2 = 5.12/10^2

package main

import (
	"fmt"
)

// 演示 golang 中小数类型使用：
func main() {

	// Golang 的浮点型默认声明变量为float64 类型
	// var num5 = 1.1
	// fmt.Printf("num5的数据类型是 %T", num5)

	// 十进制数形式：如：5.12 .512（必须有小数点）
	num6 := 5.12
	num7 := .123 // => 0.123
	fmt.Println("num6=", num6, "num7=", num7)
}

package main

import (
	"fmt"
)

// 演示 golang 中小数类型使用：
func main() {

	// Golang 的浮点型默认声明变量为float64 类型
	// var num5 = 1.1
	// fmt.Printf("num5的数据类型是 %T", num5)

	// 十进制数形式：如：5.12 .512（必须有小数点）
	num6 := 5.12
	num7 := .123 // => 0.123
	fmt.Println("num6=", num6, "num7=", num7)

	// 科学计数法形式：
	num8 := 5.1234e2   //？ 5.123 * 10^2
	num9 := 5.1234e2   //？ 5.123 * 10^2
	num10 := 5.1234e-2 //？ 5.123 / 10^2
	fmt.Println("num8=", num8, "num9=", num9, "num10=", num10)
}

1. 通常情况下，应该使用 float64 ，因为它比float32更准确。【开发中，推荐使用 float64】

---

四、字符类型：

一、基本类型：

• Golang 中没有专门的字符类型，如果要存储单个字符（字母），一般使用byte来保存。
• 字符串就是一串固定长度的字符连接起来的字符序列。Golang 的字符串是由单个字节连接起来的。也就是说对于传统的字符串由字符组成的，而 Golang 的字符串不同，它是由字节组成的。

二、案例演示：

package main

import "fmt"

// 演示 golang 中字符类型使用：
func main() {

	var c1 byte = 'a'
	var c2 byte = '0' // 字符的0

	fmt.Println("c1=", c1)
	fmt.Println("c2=", c2)
	fmt.Println("")
	// 这里直接输出的结果，如下，为什么会输出97呢？这是当我们输出byte值，就是直接输出的对应字符的ASCLL码值
	// c1= 97
	// c2= 48
	// 如果我们希望输出对应字符，需要使用格式化输出
	fmt.Printf("c2=%c\nc2=%c", c1, c2)
	fmt.Println("")

	// var c3 byte = '北' // 这个时候就会输出overflow 溢出
	var c3 int = '北'
	fmt.Printf("c3=%c", c3)

	fmt.Println("")

	// C3 对应的码值：
	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）

三、字符类型使用细节：

1. union code 编码的应用就是UTF -8 ，Golang 用的就是UTF-8 对字符进行记录的。
2. 字符常量是用单引号（""）括起来的单个字符。例如：var c1 byte = ‘a’ var c2 int = ‘中’ var c3 byte = '9'
3. Go 中允许使用转义字符“/”来将其后的字符串转变为特殊字符型常量。例如：var c3 char = '\n' // '\n' 表示换行符。
4. Go 语言的字符使用 UTF-8 编码，如果想查询字符对应的 UTF-8 码值：英文字母-1字节，汉子-3个字节
5. 在Go中，字符的本质是一个整数，直接输出时，是该字符对应的UTF-8编码的码值。
6. 可以直接给某个变量赋一个数字，然后格式化输出时%c，会输出该数字对应的Unicode字符。

package main

import "fmt"

// 演示 golang 中字符类型使用：
func main() {

	var c4 int = 22269 // 22269 ---> 国
	fmt.Printf("c4=%c", c4)
}

ASCLL 码查询网站链接：

www.toolscat.com/wiki/ascii

1. 字符类型是可以进行运算的，相当于一个整数，因为它都对应有Unicode码

package main

import "fmt"

// 演示 golang 中字符类型使用：
func main() {

	var c4 int = 22269 // 22269 ---> 国
	fmt.Printf("c4=%c", c4)
	fmt.Println("")

	// 字符类型是可以进行运算的，相当于一个整数，运输时是按照码值来运行的
	var n1 = 10 + 'a' // 10	+ 97 = 107
	fmt.Println("n1=", n1)
}

四、字符类型本质探讨：

1. 字符型，存储到计算机中，需要将字符对应的码值（整数）找出来

1. 1. 存储：字符 ----> 对应码值 ---->二进制 ---->存储
   2. 读取：二进制 ----> 码值 ----> 字符 ---->读取

1. 字符和码值的对应关系是通过字符编码表决定的（是规定好）
2. Golang 语言的编码都统一成了 UTF-8 。非常的方便，很统一，再也没有编码乱码的困扰了

---

五、布尔类型：

一、基本介绍：

1. 布尔类型也叫bool类型，bool数据类型只允许取值 true 和 false
2. bool类型占 1个字节
3. bool类型适用于逻辑运算，一般用于程序流程控制【注：这个后面会详细介绍】

1. 1. if 条件控制语句：
   2. for 循环控制语句：

二、案例演示：

package main

import (
	"fmt"
	"unsafe"
)

// 演示 golang 中布尔类型的使用：
func main() {
	var b = false
	fmt.Println("b=", b)

	// 注意事项：
	// 1. bool 类型占用存储空间是一个字节
	fmt.Println("b 的占用空间 = ", unsafe.Sizeof(b))
	// 2. bool 类型只能取true 、false
}

• 使用细节说明：
• 不可以0或非0的整数替代false和true，这点和C语言不同

---

六、String类型：

一、基本类型：

1. 字符串就是一串固定长度的字符连接起来的字符序列。
2. Go 的字符串是由单个字符连接起来的。
3. Go 语言的字符串的字节使用 UTF-8 编码标识 Unicode 文本

二、案例演示：

package main

import "fmt"

// 演示 golang 中 string 类型使用
func main() {
	// string 的基本使用
	var address string = "北京长城 welcome to beijing hello world ! 123456"
	fmt.Println(address)
}

三、String 使用注意事项和细节：

1. Go 语言的字符串的字节使用UTF-8编码标识Unicode 文本，这样 Golang 统一使用 UTF-8 编码，中文乱码问题就不会再困扰程序员。
2. 字符串一旦赋值了，字符串就不能修改了：在 Go 中字符串是不可变的。

package main

import "fmt"

// 演示 golang 中 string 类型使用
func main() {
	// string 的基本使用
	var address string = "北京长城 welcome to beijing hello world ! 123456"
	fmt.Println(address)

	// 字符串一旦赋值了，字符串就不能修改了：在 Go 中字符串是不可变的。
	// var str = "hello"
	// str[0] = 'a' 这里就不能去修改str的内容，即go中的字符串是不可变的

	str2 := "abc\nabc"
	fmt.Println(str2)
}

1. 字符串的两种表示形式

1. 1. 双引号，会识别转义字符
   2. 反引号，以字符串的原生形式输出，包括换行和特殊字符，可以实现防止攻击、输出源代码等效果。

package main

import "fmt"

// 演示 golang 中 string 类型使用
func main() {
	// string 的基本使用
	var address string = "北京长城 welcome to beijing hello world ! 123456"
	fmt.Println(address)

	// 字符串一旦赋值了，字符串就不能修改了：在 Go 中字符串是不可变的。
	// var str = "hello"
	// str[0] = 'a' 这里就不能去修改str的内容，即go中的字符串是不可变的

	str2 := "abc\nabc"
	fmt.Println(str2)

	// 反引号，尝试输出代码文件，·· (Esc 下面的哪个符号)
	str3 := `package main

	import (
		"fmt"
		"unsafe"
	)
	
	// 演示 golang 中布尔类型的使用：
	func main() {
		var b = false
		fmt.Println("b=", b)
	
		// 注意事项：
		// 1. bool 类型占用存储空间是一个字节
		fmt.Println("b 的占用空间 = ", unsafe.Sizeof(b))
		// 2. bool 类型只能取true 、false
	}
	`
	fmt.Println(str3)
}

1. 字符串拼接方式：

package main

import "fmt"

// 演示 golang 中 string 类型使用
func main() {

	// 字符串拼接方式：
	var str = "hello" + "world"
	str += "haha!"
}

1. 当一行字符串太长时，需要使用到多行字符串，可以如下处理：

package main

import "fmt"

// 演示 golang 中 string 类型使用
func main() {
    
	// 当一个拼接的操作很长时，怎么办？可以分行写（这种+号应放在上面）
	var str4 = "hello" + "world" + "hello" +
		"world" + "hello" + "world" + "hello" +
		"world" + "hello" + "world"
	fmt.Println(str4)
}

---