一開始直接上圖，直覺的看下基本資料類型
整型
表格表示
| 類型 | 有無符号 | 占用的存儲空間 | 數值範圍 | 描述 |
|---|---|---|---|---|
| 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會隐式的給你加上 ;分号
歡迎大家關注下個人的「公衆号」：獨醉貪歡