Go语言数字类型

Go语言支持整型和浮点型数字，并且原生支持复数，其中位的运算采用补码。

Go也有基于架构的类型，例如：int、uint、uintptr。

这些类型的长度都是根据运行程序所在的操作系统类型所决定的。

  • int和uint在32位操作系统上，他们均使用32位(4个字节)，在64位操作系统上，它们均使用64位(8个字节)。
  • uintptr的长度被设定为足够存放一个指针即可。

Go语言中没有float类型。（Go语言中只有float32和float64）没有double类型。

与操作系统架构无关的类型都有固定的大小，并在类型的名称中就可以看出来：

整数：

  • int8 (-128 -> 127)
  • int16 (-32768 -> 32767)
  • int32 (-2147483648 -> 2147483647)
  • int64 (-9223372036854775808 -> 9223372036854775807)

无符号整数：

  • uint8 (0 -> 255)
  • uint16 (0 -> 65535)
  • uint32 (0 -> 4294967295)
  • uint64 (0 -> 18446744073709551615)

浮点型（IEEE-754标准）：

  • float32 (+-1e-45 -> +-3.4* 1e38)
  • float64 (+-5* 1e-324 -> 107* 1e308)

int类型是计算最快的一种类型。

整型的零值为0，浮点型的零值为0.0。

实例

下面实例演示了，各个数字类型的长度和取值范围

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
package main

import (
	"fmt"
	"math"
	"unsafe"
)

func main() {
	var i8 int8
	var i16 int16
	var i32 int32
	var i64 int64
	var ui8 uint8
	var ui16 uint16
	var ui32 uint32
	var ui64 uint64

	fmt.Printf("%T %dB %v~%v\n", i8, unsafe.Sizeof(i8), math.MinInt8, math.MaxInt8)
	fmt.Printf("%T %dB %v~%v\n", i16, unsafe.Sizeof(i16), math.MinInt16, math.MaxInt16)
	fmt.Printf("%T %dB %v~%v\n", i32, unsafe.Sizeof(i32), math.MinInt32, math.MaxInt32)
	fmt.Printf("%T %dB %v~%v\n", i64, unsafe.Sizeof(i64), math.MinInt64, math.MaxInt64)

	fmt.Printf("%T %dB %v~%v\n", ui8, unsafe.Sizeof(ui8), 0, math.MaxUint8)
	fmt.Printf("%T %dB %v~%v\n", ui16, unsafe.Sizeof(ui16), 0, math.MaxUint16)
	fmt.Printf("%T %dB %v~%v\n", ui32, unsafe.Sizeof(ui32), 0, math.MaxUint32)
	fmt.Printf("%T %dB %v~%v\n", ui64, unsafe.Sizeof(ui64), 0, uint64(math.MaxUint64))

	var f32 float32
	var f64 float64
	fmt.Printf("%T %dB %v~%v\n", f32, unsafe.Sizeof(f32), -math.MaxFloat32, math.MaxFloat32)
	fmt.Printf("%T %dB %v~%v\n", f64, unsafe.Sizeof(f64), -math.MaxFloat64, math.MaxFloat64)

	var ui uint
	ui = uint(math.MaxUint64) //再+1会导致overflows错误
	fmt.Printf("%T %dB %v~%v\n", ui, unsafe.Sizeof(ui), 0, ui)

	var imax, imin int
	imax = int(math.MaxInt64) //再+1会导致overflows错误
	imin = int(math.MinInt64) //再+1会导致overflows错误
	fmt.Printf("%T %dB %v~%v\n", imax, unsafe.Sizeof(imax), -imin, imax)
}

运行结果：

1
2
3
4
5
6
7
8
9
10
11
12
int8 1B -128~127
int16 2B -32768~32767
int32 4B -2147483648~2147483647
int64 8B -9223372036854775808~9223372036854775807
uint8 1B 0~255
uint16 2B 0~65535
uint32 4B 0~4294967295
uint64 8B 0~18446744073709551615
float32 4B -3.4028234663852886e+38~3.4028234663852886e+38
float64 8B -1.7976931348623157e+308~1.7976931348623157e+308
uint 8B 0~18446744073709551615
int 8B -9223372036854775808~9223372036854775807

以二进制、八进制或十六进制浮点数的格式定义数字

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package main

import "fmt"

func main() {
	//十进制
	var a int = 10
	fmt.Printf("%d \n", a) // 10	%d	代表十进制
	fmt.Printf("%b \n", a) //	1010	%b	代表二进制

	//八进制
	var b int = 077
	fmt.Printf("%o	\n", b) //	77

	//十六进制	以0x开头
	var c int = 0xff
	fmt.Printf("%x	\n", c) //	ff
	fmt.Printf("%X	\n", c) //	FF
}

浮点型

Go语言支持两种浮点型数：float32和float64。这两种浮点型数据格式遵循IEEE 754标准：float32的浮点数的最大范围约为3.4e38，可以使用常量定义：math.MaxFloat32。float64的浮点数的最大范围约为1.8e308,可以使用一个常量定义：math.MaxFloat64。

打印浮点数时，可以使用fmt包配合动词%f，代码如下：

1
2
3
4
5
6
7
8
9
10
11
package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Printf("%f \n", math.Pi)   //3.141593
	fmt.Printf("%.2f \n", math.Pi) //3.14
}

复数

complex64和complex128

1
2
3
4
5
6
7
8
9
10
11
12
13
package main

import "fmt"

func main() {
	var c1 complex64
	c1 = 1 + 2i
	var c2 complex128
	c2 = 2 + 3i
	fmt.Println(c1) //(1+2i)
	fmt.Println(c2) //(2+3i)

}

复数有实部和虚部，complex64的实部和虚部为32位，complex128的实部和虚部为64位。