一、前言
Go系列文章：
Go专栏传送链接：https://blog.csdn.net/saintmm/category_12326997.html
二、数据类型总览
1、基本数据类型
基本数据类型大体来看有四种：数值型、字符型、布尔型、字符串。数值型又分为整数类型和浮点类型。
1）数值型-整数类型
用于存放整数值的，比如10,1002,-6712等等。
按数据范围进一步细分，整数类型又分：int8、int16、int32、int64。所谓的8/16/32/64只是用于表示数据临界范围
1> 有符号整数类型：
2> 无符号整数类型：
3> 其他整数类型：
4> PS:Go的整数类型，默认声明为int类型：
- Printf函数的作用是格式化，把age的类型填充到%T位置上。
5> 变量占用的字节数
使用unsafe包下的Sizeof()方法；
package main
import "fmt"
import "unsafe"
// 基础数据类型
func main() {
age := 18
fmt.Printf("age的类型是： %T", age)
fmt.Println();
fmt.Println("------------------")
fmt.Println(unsafe.Sizeof(age))
}
2、数值型-浮点类型
浮点类型用于存放小数，比如：3.14、0.33、-1.19等等。
1> 浮点类型种类
浮点类型有两种：32位float 和 64位float。
其底层存储空间和操作系统无关。
由于浮点类型底层存储：符号位+指数位+尾数位，所以尾数位只是存了 一个大概，很可能会出现精度的损失。
package main
import (
"fmt"
"unsafe"
)
// 基础数据类型
func main() {
float()
}
func float() {
// 定义浮点类型数据
var num1 float32 = 3.14
fmt.Println(num1)
//浮点数可以用十进制表示形式，也可以用科学计数法表示形式 E 大写小写都可以的
var num2 float32 = 314E-2
fmt.Println(num2)
//浮点数可能会有精度的损失，所以通常情况下，建议使用：float64
var num3 float32 = 234.000000916
fmt.Println(num3)
var num4 float64 = 234.000000916
fmt.Println(num4)
}
控制台输出如下：
2> PS:Go的浮点类型，默认声明为float64类型：
// golang中默认的浮点类型为：float64
num5 := 3.17
fmt.Printf("num5对应的默认的类型为：%T",num5)
当我们在IDEA声明一个float64数据类型的变量时，IDEA编译器会提示：
3、字符类型
Go中没有专门的字符类型；
如果要存储单个字符（字母、数字、标点等符号），底层对应的是ASCII码值，一般使用byte来保存；
Go中字符使用UTF-8编码，底层对应的是Unicode码值（Unicode是对应的字符集，UTF-8是Unicode的其中的一种编码方案），中文的码值可能会导致byte类型溢出，建议使用int 或 rune存在中文字符。
因此在 Go 语言中，字符可以被分成两种类型处理：
- 对占 1 个字节的英文类字符，可以使用byte（或者unit8）；
- 对占 1 ~ 4 个字节的其他字符，可以使用rune（或者int32），如中文、特殊符号等。
ASCII码表：
字符类型，本质上就是一个整数，也可以直接参与运算，输出字符的时候，会将对应的码值做一个输出：
想显示对应的字符，必须采用格式化输出：
var c4 byte = 'A'
fmt.Printf("c4对应的具体的字符为：%c",c4)
测试代码：
func char() {
// 定义字符类型的数据
var c1 byte = 'a'
// 字符类型，本质上就是一个整数，也可以直接参与运算，输出字符的时候，会将对应的码值做一个输出
// 输出97
fmt.Println(c1)
var c2 byte = '('
// 字母，数字，标点等字符，底层是按照ASCII进行存储。
// 输出 40
fmt.Println(c2 + 20)
var c3 int = '中'
// 汉字字符，底层对应的是Unicode码值，中字对应的码值为20013，byte类型溢出，可以用int存储
fmt.Println(c3)
var c4 byte = 'A'
// 想显示对应的字符，必须采用格式化输出
fmt.Printf("c4对应的具体的字符为：%c",c4)
}
4、布尔类型
布尔类型也叫bool类型，bool类型数据只允许取值true和false；
- 占1个字节
- 用于逻辑运算，大量使用于程序流程控制。
package main
import (
"fmt"
)
// 基础数据类型
func main() {
boolean()
}
func boolean() {
var b1 bool = true
fmt.Println(b1)
b2 := false
fmt.Println(b2)
b3 := 5 < 9
fmt.Println(b3)
}
控制台输出：
5、字符串类型
字符串是一串固定长度的字符连接起来的字符序列；
- 字符串是不可变的，指字符串一旦定义好，其中字符的值不能改变，但是字符串的引用可以改变。
- 如果字符串中没有特殊字符，字符串的表示形式用双引号“”
- 如果字符串中有特殊字符，字符串的表示形式用反引号 ``
- 字符串拼接可以直接使用加号
+
测试代码：
package main
import (
"fmt"
"unsafe"
)
// 基础数据类型
func main() {
typeString()
}
func typeString() {
// 1.定义一个字符串
var s1 string = "Hello world!"
fmt.Println(s1)
// 2. 字符串是不可变的, 指字符串一旦定义好，其中字符的值不能改变，但是字符串的引用可以改变。
s2 := "abc"
//s2[0] = 'q']
// 这里会改变字符串s2的引用
//s2 = "def"
fmt.Println(s2)
// 3.字符串的表示形式：
//（1）如果字符串中没有特殊字符，字符串的表示形式用双引号
s3 := "123ads"
fmt.Println(s3)
//（2）如果字符串中有特殊字符，字符串的表示形式用反引号 ``
s4 := `
package main
import "fmt"
func main() {
//
}`
fmt.Println(s4)
// 4.字符串拼接
s5 := "123" + "321asd"
fmt.Println(s5)
}
控制台输出：
2、复杂数据类型
复杂数据类型见后面的文章
三、类型转换
1、基本数据类型之间的转换
1）强制转换
Go在不同类型的变量之间赋值时需要显式转换，并且只有显式转换（强制转换）。
语法：表达式 T(v) 将值 v 转换为类型 T；
- T : 是数据类型
- v : 是需要转换的变量
- 强转后，变量v的类型不会发生改变
例如：将int转为float32
// 1. 进行类型转换：
var n1 int = 100
fmt.Println(n1)
var n2 float32 = float32(n1)
fmt.Println(n2)
// n1的类型还是int，只是将n1的值100转为了float32赋值给n2而已。
fmt.Printf("%T",n1)
1> 强转报错：数据溢出
<1> 编译通过，执行时会数据溢出
// 2. 强转报错：超过数据范围
var n3 int64 = 888888
var n4 int8 = int8(n3)
// 将int64转为int8，编译不会出错，但是会数据溢出
fmt.Println(n4)
2> 数据溢出自动判断
常量 + 一个变量，如果常量不超过相应类型的数据边界，可以编译通过；超过则编译不通过；
// 3. 数据溢出判断
var n5 int64 = 12
// 编译通过，但是结果可能会溢出
var n6 int8 = int8(n5) + 127
// 编译不会通过
var n7 int8 = int8(n5) + 128
fmt.Println(n7)
fmt.Println(n6)
即使 n5 变量你声明为负数，依旧编译不通过；
2）其他基本类型转string
其他基本类型转string有两种方式：
fmt.Sprintf("%参数", 表达式)，推荐使用；- 使用strconv包的函数；
1> fmt.Sprintf
从https://pkg.go.dev/[email protected]#Sprintf文档中可以看到各种参数占位符；
（1）int 转 string：
var n1 int = 6
var s1 string = fmt.Sprintf("%d",n1)
fmt.Printf("s1对应的类型是：%T ，s1 = %q \n",s1, s1)
（2）float32转 string：
var n2 float32 = 6.78
var s2 string = fmt.Sprintf("%f",n2)
fmt.Printf("s2对应的类型是：%T ，s2 = %q \n",s2, s2)
（3）bool 转 string：
var n3 bool = false
var s3 string = fmt.Sprintf("%t",n3)
fmt.Printf("s3对应的类型是：%T ，s3 = %q \n",s3, s3)
（4）byte 转 string：
var n4 byte = 'd'
var s4 string = fmt.Sprintf("%c",n4)
fmt.Printf("s4对应的类型是：%T ，s4 = %q \n",s4, s4)
控制台输出：
2> strconv
API文档：https://pkg.go.dev/[email protected]#FormatBool
var n1 int = 6
// 参数：第一个参数必须转为int64类型 ，第二个参数指定字面值的进制形式为十进制
var s1 string = strconv.FormatInt(int64(n1),10)
fmt.Printf("s1对应的类型是：%T ，s1 = %q \n",s1, s1)
var n2 float64 = 6.78
// 第二个参数：'f'表示格式化为（-ddd.dddd，不带指数形式） 第三个参数：9 保留小数点后面9位 第四个参数：表示这个小数是float64类型
var s2 string = strconv.FormatFloat(n2,'f',9,64)
fmt.Printf("s2对应的类型是：%T ，s2 = %q \n",s2, s2)
var n3 bool = true
var s3 string = strconv.FormatBool(n3)
fmt.Printf("s3对应的类型是：%T ，s3 = %q \n",s3, s3)
控制台输出：
3）string转其他基本类型
string转其他基本类型的方式为使用strconv包的函数，比如：strconv.ParseInt，strconv.ParseFloat
API文档：https://pkg.go.dev/[email protected]#ParseBool
// string --> bool
var s1 string = "true"
var b bool
// ParseBool函数的返回值有两个：(value bool, err error) ，value是我们得到的布尔类型的数据，err表示出现的错误
// 如果只关注布尔类型的数据，err可以用_标识符接收、直接忽略掉。
b , _ = strconv.ParseBool(s1)
fmt.Printf("b的类型是：%T,b=%v \n",b,b)
// string --> int64
var s2 string = "19"
var num1 int64
num1,_ = strconv.ParseInt(s2,10,64)
fmt.Printf("num1的类型是：%T,num1=%v \n",num1,num1)
// string --> float32/float64
var s3 string = "3.14"
var f1 float64
f1,_ = strconv.ParseFloat(s3,64)
fmt.Printf("f1的类型是：%T,f1=%v \n",f1,f1)
控制台输出：
PS：string向基本数据类型转换的时候，一定要确保string类型能够转成有效的数据类型，否则最后得到的结果为：对应类型的默认值
var s4 string = "golang"
var b1 bool
b1 , _ = strconv.ParseBool(s4)
fmt.Printf("b1的类型是：%T,b1=%v \n",b1,b1)
var s5 string = "golang"
var num2 int64
num2,_ = strconv.ParseInt(s5,10,64)
fmt.Printf("num2的类型是：%T,num2=%v \n",num2,num2)
控制台输出：
四、总结
基本数据类型的默认值（在Go中数据类型都有一个默认值，当程序员没有赋值时，就会保留默认值(默认值又叫零值)）为：
对比着看Java的基本数据类型
java的基本数据类型有8种：byte、short、int、long、float、double、boolean、char；
Go的基本类型有五种：
- 布尔型：关键字【bool】： true false
- 整数类型：又细分为有符号整数类型和无符号整数类型；
- 有符号整数类型（第一位代表正负）：int、int8、int16、int32、int64
- 无符号整数类型：uint、uint8、uint16、uint32、uint64
- 浮点类型：float32、float64
- 字符串：string
- 字符类型：byte（等同uint8，类似于一个别名），用于存放占 1 字节的 ASCII 字符，如英文字符，返回字符原始字节。
- rune（等同int32，只是一个别名），用于存放多字节字符，如占 3 字节的中文字符，返回字符 Unicode 码点值
Java和Go基本数据类型的映射为：
| Java | Go |
|---|---|
| byte（有符号型，字节数据类型） | byte（无符号型，等同uint8，类似一个别名） |
| short | int16 |
| int | int32 |
| long | int64 |
| float | float32 |
| double | float64 |
| boolean | bool |
| char（无符号型，字符数据类型） | uint16 |
PS：
- Go中整型的默认类型为int，int是32还是64位取决于操作系统的位数；
- Go没有float类型，只有float32和float64
- Go中string也是基本数据类型。