Go语言支持整型和浮点型数字,并且原生支持复数,其中位的运算采用补码。
Go也有基于架构的类型,例如:intuintuintptr

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

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

Go语言中没有float类型。(Go语言中只有float32float64)没有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
  • float64

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
43
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(ui32), -math.MaxFloat32, math.MaxFloat32)
fmt.Printf("%T %dB %v->%v\n", f64, unsafe.Sizeof(ui64), -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
fmt.Printf("%b \n", a) // 1010 占位符%b表示二进制

// 八进制 以0开头
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
}

运行结果:

1
2
3
4
5
10 
1010
77
ff
FF

浮点型

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

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

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

import (
"fmt"
"math"
)

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

运行结果:

1
2
3.141593
3.14

复数

complex64和complex128

1
2
3
4
5
6
var c1 complex64
c1 = 1 + 2i
var c2 complex128
c2 = 2 + 3i
fmt.Println(c1)
fmt.Println(c2)

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