一开始直接上图，直观的看下基本数据类型

整型

表格表示

用"math"包中的常量打印出整型的范围

官方文档的截图

示例代码

package mainimport (    "fmt"    "math")func main(){    fmt.Println("int8 min = ", math.MinInt8, " int8 max = ", math.MaxInt8)    fmt.Println("int16 min = ", math.MinInt16, " int16 max = ", math.MaxInt16)    fmt.Println("int32 min = ", math.MinInt32, " int32 max = ", math.MaxInt32)    fmt.Println("int64 min = ", math.MinInt64, " int64 max = ", math.MaxInt64)    fmt.Println("Uint8 max = ", math.MaxUint8)    fmt.Println("Uint16 max = ", math.MaxUint16)    fmt.Println("Uint32 max = ", math.MaxUint32)    //fmt.Println(" Uint64 max = ", math.MaxUint64)    }

在官方文档中，Uint64是有的，但是在我本机中，我打印就溢出，所以这个还需要你们在这里的电脑中测试一下，是否能打印处理来

用"unsafe"包打印整型的存储大小

官方文档的截图

示例代码

package mainimport (    "fmt"    "unsafe")func main(){    var sizeofInt8 int8    var sizeofInt16 int16    var sizeofInt32 int32    var sizeofInt64 int64    fmt.Println("int8 所占的字节数 = ", unsafe.Sizeof(sizeofInt8))    fmt.Println("int16 所占的字节数 = ", unsafe.Sizeof(sizeofInt16))    fmt.Println("int32 所占的字节数 = ", unsafe.Sizeof(sizeofInt32))    fmt.Println("int64 所占的字节数 = ", unsafe.Sizeof(sizeofInt64))    var sizeofint int    fmt.Println("int 所占的字节数 = ", unsafe.Sizeof(sizeofint))    var sizeofUint8 uint8    var sizeofUint16 uint16    var sizeofUint32 uint32    var sizeofUint64 uint64    fmt.Println("Uint8 所占的字节数 = ", unsafe.Sizeof(sizeofUint8))    fmt.Println("Uint16 所占的字节数 = ", unsafe.Sizeof(sizeofUint16))    fmt.Println("Uint32 所占的字节数 = ", unsafe.Sizeof(sizeofUint32))    fmt.Println("Uint64 所占的字节数 = ", unsafe.Sizeof(sizeofUint64))    }

在这里，因为我用的是64位的笔记本，所以int 打印的是8个字节

用"fmt"包的 Printf 格式化输出整型的默认值

官方文档的截图

示例代码

package mainimport (    "fmt")func main(){    var defaultValueInt8 int8    var defaultValueInt16 int16    var defaultValueInt32 int32    var defaultValueInt64 int64    fmt.Printf("int8 的默认值是 = %v\n", defaultValueInt8)    fmt.Printf("int16 的默认值是 = %v\n", defaultValueInt16)    fmt.Printf("int32 的默认值是 = %v\n", defaultValueInt32)    fmt.Printf("int64 的默认值是 = %v\n",defaultValueInt64)    var defaultValueint int    fmt.Printf("int 的默认值是 = %v\n", defaultValueint)    var defaultValueUint8 uint8    var defaultValueUint16 uint16    var defaultValueUint32 uint32    var defaultValueUint64 uint64    fmt.Printf("Uint8 的默认值是 = %v\n", defaultValueUint8)    fmt.Printf("Uint16 的默认值是 = %v\n", defaultValueUint16)    fmt.Printf("Uint32 的默认值是 = %v\n", defaultValueUint32)    fmt.Printf("Uint64 的默认值是 = %v\n", defaultValueUint64)    }

浮点型

官方文档的截图

这是打印 float 范围的常量

示例代码

package mainimport (    "fmt"    "math"    "unsafe")func main(){    //打印 float 的取值范围    fmt.Println("float32的最小值 = ",math.SmallestNonzeroFloat32," 最大值为 = ", math.MaxFloat32)    fmt.Println("float64的最小值 = ",math.SmallestNonzeroFloat64," 最大值为 = ", math.MaxFloat64)    //打印 float 所占存储空间的大小    var sizeoffloat32 float32    var sizeoffloat64 float64    fmt.Println("float32所占的存储空间为：",unsafe.Sizeof(sizeoffloat32))    fmt.Println("float64所占的存储空间为：",unsafe.Sizeof(sizeoffloat64))    //打印 float 的默认值    fmt.Printf("float32的默认值为：%v\n", sizeoffloat32)    fmt.Printf("float64的默认值为：%v\n", sizeoffloat64)}

我把取值范围，所占存储空间大小，默认值都写在同一个文件中，你可以把代码复制进编译器运行一遍，至于里面用到的一些包和方法，上面有截图，你可以去上面看一下

上面打印出来的取值范围用的是科学计数法^[1]

Go浮点型赋值的时候

0.123 是可以等价为 .123，只有小数点前为0可以使用

字符型

字符型跟别的编程语言不一样，这里的字符不是用的char来存储，用的是byte来存储，而且存储的范围只有 -128 ~ 127，存储的是ASCII表^[2]所展示的内容

示例代码

package mainimport (    "fmt"    "unsafe")func main(){    var sizeofByte byte    //打印出byte的存储大小    fmt.Println("byte所占的存储空间为：", unsafe.Sizeof(sizeofByte))    //打印出byte的默认值    fmt.Printf("byte的默认值为：%q", sizeofByte)}

这里的 %q，是可以把原本基本类型的格式也打印出来(个人理解)

如果我们各种情况打印字符的话，那会是什么情形？

package mainimport (    "fmt")func main(){    var testByte byte = 'a'    //打印 testByte的值，不用格式化输出    fmt.Println("testByte不是格式化输出的值为：", testByte)    //打印 testByte的值，用格式化输出    fmt.Printf("testByte格式化输出的值为：%c\n", testByte)    var testByte2 byte     //用 %q格式化打印 testByte2的值    fmt.Printf("testByte2的值为：%q\n", testByte2)    //用 %c格式化打印 testByte2的值    fmt.Printf("testByte2的值为：%c\n", testByte2)}

第一个输出，是输出字符在 ASCII中十进制的表示，a的十进制是97

第二个用格式化输出，用的%c，是输出了相应的Unicode代码表示的字符

第三个和第四个输出的是byte的默认值，但是两者有不同的区别，用%q有把 '' 也给输出了，但是%c没有

思考题：因为 byte只能存储一个字节，而汉字一般占用的是3-4个字节，那么该用什么来存储？

package mainimport (    "fmt")func main(){    var testA int = '帅'    fmt.Println("testA的值为：", testA)    fmt.Printf("testA用格式化输出：%c", testA)}

答案是用整型来接收，byte实质上等于int8，而且存储在计算机时，计算机不是存储的字符，而是字符所代表的ASCII表的十进制的数字，那用整型就可以存储更大的汉字了，因为最后在计算机也是存储的是数字

布尔类型

布尔类型也是叫 bool类型，它只有两个值，true或者是false

bool只占存储空间的1个字节

示例代码

package mainimport (    "fmt"    "unsafe")func main(){    var testbool bool     fmt.Println("testbool的默认值是：", testbool)    fmt.Println("testbool所占存储空间的大小是：", unsafe.Sizeof(testbool))}

补充：bool常用于循环、条件语句中

字符串

示例代码

在上面的字符那里，我们每次只能写一个字符，而字符串可以让你，一次性多写很多个字符

package mainimport (    "fmt"    "unsafe")func main(){    var testString string      fmt.Println("testString的默认值是：", testString)    fmt.Println("testString所占存储空间的大小是：", unsafe.Sizeof(testString))    fmt.Printf("testString的默认值是，用格式化输出：%s\n", testString)    fmt.Printf("testString的默认值是，用格式化输出：%q", testString)}

在上面，string 默认的大小是16个字节，而我们格式化输出 %s，是说直接输出这个字符串内容，但是由于我们没有赋值，它默认是空，所以输出空白，但我们用了%q去输出内容，输出了双引号，输出了它的格式""

有个需要注意的点：字符串一经创建，就不能修改

字符串拼接

package mainimport (    "fmt")func main(){    var hello string = "hello"    var world string = " world"    var helloworld string = hello + world    fmt.Println(helloworld)}

输出的是：hello world

有个注意点：如果有多个字符串拼接，如果太长了，你要换行，需要把 + 号，放在前一个字符串的后面，而不能连 + 号也换行了，不然会报错解释：因为Go语言中，执行代码的时候，在你不添加 ;分号的时候，换行就等于是新的语句了，而上面的代码，Go会隐式的给你加上 ;分号

References

[1] 科学计数法: https://baike.baidu.com/item/%E7%A7%91%E5%AD%A6%E8%AE%B0%E6%95%B0%E6%B3%95/1612882?fromtitle=%E7%A7%91%E5%AD%A6%E8%AE%A1%E6%95%B0%E6%B3%95&fromid=756685&fr=aladdin[2] ASCII表: https://baike.baidu.com/item/ASCII/309296?fromtitle=ascii%E7%A0%81&fromid=99077&fr=aladdin