一、数字类型
- 整形、浮点数、复数。
- 不同类型的数字不能做运算。
二、整形分为两大类：
- 按长度分为：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
网友评论