Go的基本数据类型入门看这一篇就差不多了

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

整型

表格表示

类型	有无符号	占用的存储空间	数值范围	描述
int8	有	1字节	-128 ~ 127
int16	有	2字节	-32768 ~ 32767
int32	有	4字节	-2147483648 ~ 2147483647
int64	有	8字节	-9223372036854775808 ~ 9223372036854775807
int	有	32位系统4字节 64位系统8字节	32位系统看int32 64位系统看int64
byte	无	1字节，与int8等价	0 ~ 255	byte也用来存储字符
rune	有	4字节	同int32	相当于 Unicode下的 int32
uint8	无	1字节	0 ~ 255
uint16	无	2字节	0 ~ 65535
uint32	无	4字节	0 ~ 4294967295

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

官方文档的截图

示例代码

package main

import (
	"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 main

import (
	"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 main

import (
	"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)	
}

---

浮点型

类型	占用的存储空间	取值范围	描述
float32	4字节		单精度
float64	8字节		双精度
这里说的精度，表示的是小数点后，能显示的位数精确到哪几位

官方文档的截图

这是打印 float 范围的常量

示例代码

package main

import (
	"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)
}

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

上面打印出来的取值范围用的是**科学计数法**

Go浮点型赋值的时候

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

---

字符型

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

示例代码

package main

import (
	"fmt"
	"unsafe"
)

func main(){

	var sizeofByte byte
	//打印出byte的存储大小
	fmt.Println("byte所占的存储空间为：", unsafe.Sizeof(sizeofByte))

	//打印出byte的默认值
	fmt.Printf("byte的默认值为：%q", sizeofByte)
}

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

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

package main

import (
	"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 main

import (
	"fmt"
)

func main(){

	var testA int = '帅'
	fmt.Println("testA的值为：", testA)

	fmt.Printf("testA用格式化输出：%c", testA)

}

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

布尔类型

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

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

示例代码

package main

import (
	"fmt"
	"unsafe"
)

func main(){

	var testbool bool 
	fmt.Println("testbool的默认值是：", testbool)

	fmt.Println("testbool所占存储空间的大小是：", unsafe.Sizeof(testbool))

}

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

字符串

示例代码

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

package main

import (
	"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 main

import (
	"fmt"
)

func main(){

	var hello string = "hello"
	var world string = " world"

	var helloworld string = hello + world

	fmt.Println(helloworld)

}

输出的是：hello world

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

---

欢迎大家关注下个人的「公众号」：独醉贪欢