2-5 Go --- 基本数据类型 （数字类型之 int 整形，浮点数 float）

一、数字类型

• 整形、浮点数、复数。
• 不同类型的数字不能做运算。

二、整形分为两大类：

• 按长度分为：int —— int8、int16、int32、int64。
• 无符号整形：uint —— uint8、uint16、uint32、uint64。

---

• int/uint 类型有：int8/uint8、int16/uint16、int32uint32、int64/uint64。
• int8/uint8 大小是 1字节。
• int16/uint16 大小是 2字节。
• int32/uint32 大小是4字节。
• int64/uint64 大小是8字节。
• int 和 uint 可以根据操作系统的位数调节 int/uint 对应的类型。32位的操作系统对应 int32/uint32（4字节），64位的操作系统对应 int64/uint64（8字节)。
• fmt.Printf("%T",变量名) —— 查看变量类型。
• "\n"：转译字符，换行符。

package main

import "fmt"

func main() {
    var n1 int8 = 10      // int8 类型赋值 10
    var n2 int16 = 10      // int16 类型赋值 10
    var n3 int32 = 10      // int32 类型赋值 10
    var n4 int64 = 10      // int64 类型赋值 10
    fmt.Println(n1, n2, n3, n4)      // int8、int16、int32、int64都是输出10

    // fmt.Printf（）括号里分两部分，前面第一部分字符串形式输出，第二部分变量名。
    // "%T"：查看值类型。第一部分有多少个 %T，第二部分就对应多少个变量名。
    fmt.Printf("%T,%T,%T,%T\n", n1, n2, n3, n4)      
}
//输出结果：
PS C:\Users\86186\go\src\chapter2\2.5> go run .\main.go
10 10 10 10
int8,int16,int32,int64

• 同类型进行运算。

package main

import "fmt"

func main() {
    var n1 int8 = 10
    var n11 int8 = 20 
    fmt.Println("n1 + n11 =", n1+n11)
}
//输出结果：
PS C:\Users\86186\go\src\chapter2\2.5> go run .\main.go
n1 + n11 = 30

• 不同类型的不能运算。

package main

import "fmt"

func main() {
    var n1 int8 = 10
    var n2 int16 = 10   
    fmt.Println("n1 + n2 =", n1+n2)      //不同类型相加会报错 。
}
//输出结果：
PS C:\Users\86186\go\src\chapter2\2.5> go run .\main.go
# command-line-arguments
.\main.go:13:29: invalid operation: n1 + n2 (mismatched types int8 and int16)
// 提示 int8 和 int16 类型不匹配。

• 如果一定要进行不同类型的运算，需要强制类型转换。
  类型（变量名/值），强制转换类型。

package main

import "fmt"

func main() {
    var n1 int8 = 10
    var n2 int16 = 10

    // int8(n2) ，强制把 n2 的 int16 转换为 int8。
    // 这样n1 和 n2 都是 int8，同类型可以进行运算。
    fmt.Println("n1 + n2 =", n1+int8(n2))      

    // int16(n1) ，强制把 n1 的 int8 转换为 int16。
    // 这样n1 和 n2 都是 int16，同类型可以进行运算。
    fmt.Println("n2 + n1 =", n2+int16(n1))
}
//输出结果：
PS C:\Users\86186\go\src\chapter2\2.5> go run .\main.go
n1 + n2 = 20
n2 + n1 = 20

• int型 是 int8、int16、int32、int64 的统称。也有 int 这个类型，int 可以根据操作系统的位数调节 int 对应的类型。32位的操作系统对应 int32（int32类型是4字节），64位的操作系统对应 int64（int64类型是8字节）。

package main

import "fmt"

func main() {
    var n5 int = 10
    fmt.Printf("%T\n", n5)      // 查看变量类型
}
## 输出结果
PS C:\Users\86186\go\src\chapter2\2.5> go run .\main.go
int      // n5 是 int 类型。

• int 类型的值范围。int 是有符号类型，它的值可以是负数也可以是正数。为什么不是一个 int 类型代表整个整数类型，而有 int8、int16、int32、int64之分。从他们的值范围也可以看出，当存储100这个数值时，不需要用到 int32 和 int64 这么大的内存存储空间，善于管控资源。通过 math 包下的方法可以查看 int 类型值的范围。

package main

import (
    "fmt"
    "math"      //导入math 包
)

func main() {
    fmt.Println(math.MinInt8, " to ", math.MaxInt8)      // int8值的范围
    fmt.Println(math.MinInt16, " to ", math.MaxInt16)       // int16值的范围
    fmt.Println(math.MinInt32, " to ", math.MaxInt32)       // int32值的范围
    fmt.Println(math.MinInt64, " to ", math.MaxInt64)       // int64值的范围
}
//输出结果：
PS C:\Users\86186\go\src\chapter2\2.5> go run .\main.go
-128  to  127
-32768  to  32767
-2147483648  to  2147483647
-9223372036854775808  to  9223372036854775807

• 超出相应 int 类型的值范围会报错，这就需要更大的 int 类型存储数值。

package main

import "fmt"

func main() {
    var n1 int8 = 128
    var n11 int8 = -129
    fmt.Println(n1, n11)
}
//输出结果：
PS C:\Users\86186\go\src\chapter2\2.5> go run .\main.go
# command-line-arguments

 // 常量128溢出 int8，溢出就是超过了 int8 的值范围。
.\main.go:7:6: constant 128 overflows int8   
 // 常量-129溢出 int8，溢出就是超过了 int8 的值范围。  
.\main.go:8:6: constant -129 overflows int8

---

无符号整形：uint —— uint8、uint16、uint32、uint64，无符号型是从 0 到 正数，非负数。

uint 类型的值范围：
uint8  : 0 到 255 
uint16 : 0 到 65535 
uint32 : 0 到 4294967295 
uint64 : 0 到 18446744073709551615 

---

• 浮点数 —— 分为两大类：
• float32：float32 的浮点数最大范围约为 3.4e38，可以使用math.MaxFloat32 查看最大值。
• float64：float64 的浮点数最大范围约为 1.8e308，可以使用math.MaxFloat64 查看最大值。

package main

import (
    "fmt"
    "math"      //导入 math 包
)

func main() {
    fmt.Println(math.MaxFloat32)     //赋值 Float32 最大值到常量 fMax32。
    fmt.Println(math.MaxFloat64)     //赋值 Float64 最大值到常量 fMax64。

}

##输出结果：
PS C:\Users\86186\go\src\chapter2\2.5> go run .\main.go
3.4028234663852886e+38      //输出 float32 最大值
1.7976931348623157e+308    //输出 float64 最大值

• 没有定义 float 类型，默认类型是 Float64

package main

import "fmt"

func main() {
    var f1 = 3.14
    fmt.Printf("%T", f1)      //输出 f1 变量类型
}
##输出结果：
PS C:\Users\86186\go\src\chapter2\2.5> go run .\main.go
float64      //没有定义类型的 float 默认类型是 float64

• float32/64 的零值是 0。

package main

import (
    "fmt"
)

func main() {
    var f1 float32      //定义 float32 不赋值
    var f2 float64      //定义 float64 不赋值
    fmt.Println(f1)
    fmt.Println(f2)
}
//输出结果：
PS C:\Users\86186\go\src\chapter2\2.5> go run .\main.go
0      //float32 零值为0
0      //float64 零值为0

• float32 和 float64 类型不一样，不能进行运算。

package main

import (
    "fmt"
)

func main() {
    var f1 float32 = 1.3
    var f2 float64 = 3.14
    fmt.Println(f1 + f2)    
}
//输出结果：
# command-line-arguments

//f1 和 f2，float32 和 float64 类型不匹配。
.\main.go:10:17: invalid operation: f1 + f2 (mismatched types float32 and float64)      

• 如果 float32 和 float64 要运算，也要强制类型转换。

package main

import (
    "fmt"
)

func main() {
    var f1 float32 = 1.3
    var f2 float64 = 3.14
    fmt.Println(f1 + float32(f2))      //强制把 f2 转换为 float32
    fmt.Println(f2 + float64(f1))      //强制把 f1 转换为 float64 
}
//输出结果：
PS C:\Users\86186\go\src\chapter2\2.5> go run .\main.go
4.44      // float32 运算结果
4.439999952316285      // float64 运算结果

• Printf("%f") 占位符输出内容。

package main

import (
    "fmt"
)

func main() {
    var f2 float64 = 3.145
    // Printf 前面是字符串输出，%f是 float 浮点型占位符，\n是换行符。
    // 占位符就是先为后面变量的值占住一个固定的位置，等待后面传输变量进来。
    //占位符的位置就会显示变量的值。 
    fmt.Printf("f2:%f\n", f2)      //%f 的位置显示 f2 变量的值
    fmt.Printf("f2：%.2f", f2)     //%.2f 的位置只保留2位小数显示 f2 变量的值
}
//输出结果：
PS C:\Users\86186\go\src\chapter2\2.5> go run .\main.go
f2:3.145000      //f2的值
f2：3.15      //四舍五入，只保留小数点后两位。

---

• 复数 —— 分为两大类：
• complex64 和 complex128。
• 复数有实部和虚部。

package main

import "fmt"

func main() {
    var c1 complex64
    c1 = 3 + 5i      //3是实部，5i是虚部
    var c2 complex128
    c2 = 4 + 8i
    fmt.Printf("%v,%T\n", c1, c1)      //%v结构体，%T值的类型，\n换行。
    fmt.Printf("%v,%T\n", c2, c2)
}
//输出结果：
PS C:\Users\86186\go\src\chapter2\2.5> go run .\main.go
(3+5i),complex64
(4+8i),complex128