本文为译文。原文地址：types

下面是go里面的基础数据类型

bool
Numberic Types
int8, int16, int32, int64, int
uint8, uint16, uint32, uint64, uint
float32, float64
complex64, complex128
byte
rune
string

有符号整数

type

meaning

size

range

int8

8位有符号整形

8bits -> 1byte

-128~127

int16

16位有符号整醒

16bits -> 2byte

-32768 to 32767

int 32

32位有符号整醒

32bits -> 4byte

-2147483648 to 2147483647

int64

64位有符号整醒

64bits -> 8 byte

-9223372036854775808 to 9223372036854775807

int

要么是32bits 要么是64bits。具体依赖于所在的平台。当你想使用整形的时候，应该第一考虑int，除非有具体的场景需要。

32bits | 64 bits

-2147483648 to 2147483647 in 32 bit systems | -9223372036854775808 to 9223372036854775807 in 64 bit systems

package main

import "fmt"

func main() {  
    var a int = 89
    b := 95
    fmt.Println("value of a is", a, "and b is", b)
}

上面a的数据类型为int,b的数据类型是根据其值做推导出来的。我们已经说了int的大小在32位系统里是32位，在64位系统里是64位。现在让我们来验证这声明。

变量的类型可以在Printf函数中使用%T来打印。大小的话，go有一个unsafe包，其有个Sizeof函数。这个函数会返回变量占了几个字节。unsafe包应该尽量避免被使用，因为存在一些可移植问题。此处我们出于教程的目的，先暂时使用。

package main

import (  
    "fmt"
    "unsafe"
)

func main() {  
    var a int = 89
    b := 95
    fmt.Println("value of a is", a, "and b is", b)
    fmt.Printf("type of a is %T, size of a is %d", a, unsafe.Sizeof(a)) //type and size of a
    fmt.Printf("\ntype of b is %T, size of b is %d", b, unsafe.Sizeof(b)) //type and size of b
}

value of a is 89 and b is 95  
type of a is int, size of a is 4  
type of b is int, size of b is 4

从上面的结果我们可以看出，变量a和b都是字节，所以是int32。以上程序的输出结果可能会不同，如果你运行上面的程序在64位操作系统上。可能输出就会是8了。（此处译者在自己的x64电脑试了，确实是8）

无符号整形

type

meaning

size

range

uint8

8位无符号整形

8bits -> 1byte

0 to 255

uint16

16位无符号整形

16bits -> 2byte

0 to 65535

uint 32

32位无符号整醒

32bits -> 4byte

0 to 4294967295

uint64

64位无符号整醒

64bits -> 8 byte

0 to 18446744073709551615

uint

要么是32bits 要么是64bits。具体依赖于所在的平台。当你想使用整形的时候，应该第一考虑int，除非有具体的场景需要。

32bits | 64 bits

0 to 4294967295 in 32 bit systems | 18446744073709551615 in 64 bit systems

floating point types 浮点型

float32: 32bit浮点型数字。
float64:64位浮点型数字。(float64是浮点数的默认类型)

package main

import (
"fmt" )

func main() {
a, b := 5.67, 8.97 fmt.Printf("type of a %T b %T\n", a, b) sum := a + b diff := a - b fmt.Println("sum", sum, "diff", diff)
```
no1, no2 := 56, 89
fmt.Println("sum", no1+no2, "diff", no1-no2)
```
}

a、b的类型是根据其值做类型推导得到的。在这个例子中，a和b的类型是float64。因为float64是浮点型的默认类型。

其他的数字类型

byte is an alias of uint8
rune is an alias of int32

我们会在学习string的时候，更加详细的讨论bytes 和 rune.

类型转换

go对于明确的类型是非常严格的。这里没有自动的类型提升或转换。我们一块看下下面的例子

package main

import (  
    "fmt"
)

func main() {  
    i := 55      //int
    j := 67.8    //float64
    sum := i + j //int + float64 not allowed
    fmt.Println(sum)
}

上面的代码在C语言中是完全合法的。但是在go里就会报错了。你会看到./prog.go:10:11: invalid operation: i + j (mismatched types int and float64)

修复的办法就是让i、j具有同样的类型。让我们把j转换为int。T(v)就是把v的值转换为类型T

package main

import (  
    "fmt"
)

func main() {  
    i := 55      //int
    j := 67.8    //float64
    sum := i + int(j) //j is converted to int 
    fmt.Println(sum) //122 
}

相同的例子就是赋值操作。要分配一个变量到另一个数据类型，则需要显示的类型转换。

package main

import (  
    "fmt"
)

func main() {  
    i := 10
    var j float64 = float64(i) //this statement will not work without explicit conversion
    fmt.Println("j", j)
}

4 types in go

有符号整数

无符号整形

floating point types 浮点型

其他的数字类型

类型转换