基本类型

本节介绍下Golang中的基本数据类型，Golang中的基本数据类型包含如下几种：

布尔类型

• bool

数值类型

• int8, int16, int32, int64, int

• uint8, uint16, uint32, uint64, uint

• float32, float64

• complex64, complex128

• byte

• rune

字符串类型

• string

布尔类型

Golang中布尔类型用bool表示，值为true或false。

package main

import "fmt"

func main() {
    var a bool = true
    b := false
    fmt.Println("a:", a, "b:", b)
    c := a && b
    fmt.Println("c:", c)
    d := a || b
    fmt.Println("d:", d)
}

Go Playground在线运行

这段程序中bool类型的变量a赋值为true，变量b赋值为false。

c赋值为a && b，&&运算符表示与操作，当a，b均为true时才返回true。

||运算符表示或操作，当a，b其中之一为true即返回true。

前面程序的输出为：

a: true b: false
c: false
d: true

有符号整型

所谓有符号是指表示的值可正可负。

int8 用8个比特表示的有符号整数类型 内存占用 8比特 表示范围 -128 ~ 127

int16 用16比特表示的有符号整数类型 内存占用 16比特 表示范围 -32768 ~ 32767

int32 用32比特表示的有符号整数类型 内存占用 32比特 表示范围 -2147483648 ~ 2147483647

int64 用64比特表示的有符号整数类型 内存占用 64比特 表示范围 -9223372036854775808 ~ 9223372036854775807

int 用32或64比特表示的有符号整数类型，具体是32位还是64位取决于操作系统 内存占用 同int32或int64 表示范围 同int32或int64

package main

import "fmt"

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

Go Playground在线运行 这段程序的输出如下：

value of a is 89 and b is 95

前面这段程序中变量a显示声明为int类型，变量b通过我们赋予的初始值(95)自动推断，Golang中整型值的默认类型是int，这点下面的程序也有体现。

我们可以通过fmt.Printf方法的%T格式化参数来打印出变量的类型。还可以通过unsafe.Sizeof获取变量占用的字节数(字节即byte，一个字节等于8个比特)。注意慎用unsafe包，有可能有兼容性问题，这点根据包名称其实也能看出来。

下面的这段程序输出变量a、b的类型和占用的字节数。

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
}

Go Playground在线运行 该程序输出如下：

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均为int类型，并且占用了4个字节。但是如果是在64比特的系统上运行，将看到占用8个字节(64比特)。

无符号整型

uint8 用8个比特表示的无符号整数类型 内存占用 8比特 表示范围 0 ~ 255

uint16 用16个比特表示的无符号整数类型 内存占用 16比特 表示范围 0 ~ 65535

uint32 用32个比特表示的无符号整数类型 内存占用 32比特 表示范围 0 ~ 4294967295

uint64 用64个比特表示的无符号整数类型 内存占用 64比特 表示范围 0 ~ 18446744073709551615

uint 用32或64比特表示的无符号整数类型，具体是32位还是64位取决于操作系统 内存占用 同uint32或uint64 表示范围 同uint32或uint64

浮点类型

float32 用32比特表示的浮点数类型 float64 用64比特表示的浮点数类型 Golang浮现值的默认类型是float64。下面的程序中变量a、b通过赋的初值自动推断数据类型，可以看出其数据类型确实为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)
}

Go Playground在线运行 该程序输出如下：

type of a float64 b float64
sum 14.64 diff -3.3000000000000007
sum 145 diff -33

复数类型

complex64 实部和虚部均为float32的复数类型 complex128 实部和虚部均为float64的复数类型

Golang内置函数complex用来创建复数类型。定义如下，入参为浮点类型：

func complex(r, i FloatType) ComplexType

该函数接收浮点类型的实部r和虚部i两个参数，并返回复数类型。注意两个参数浮点类型必须严格一致，要么都是float32，要么都是float64。如果入参均为float32则返回值为complex64；如果入参均为float64，则返回值为complex128。

Golang为我们提供了复数简写语法糖，可以更加直观简洁的创建复数：

c := 6 + 7i

package main

import (  
    "fmt"
)

func main() {  
    c1 := complex(5, 7)
    c2 := 8 + 27i
    cadd := c1 + c2
    fmt.Println("sum:", cadd)
    cmul := c1 * c2
    fmt.Println("product:", cmul)
}

Go Playground在线运行 这段程序的输出如下，大家可以手动算一下确认正确与否：

sum: (13+34i)
product: (-149+191i)

其他数值类型

byte uint8类型的别名 rune int32类型的别名

这两个数值类型我们后面章节详细讨论字符串时再介绍。

字符串类型

Golang中字符串可以看作字节(byte)集合，这样说可能不太容易理解，后面章节我们详细讨论字符串时再介绍。现在我们可以把字符串类型看作是字符集合。

package main

import (  
    "fmt"
)

func main() {  
    first := "Naveen"
    last := "Ramanathan"
    name := first +" "+ last
    fmt.Println("My name is",name)
}

Go Playground在线运行 这段程序中，first赋值为字符串Naveen，last赋值为字符串Ramanathan。字符串可以通过+运算符拼接。改程序输出如下：

My name is Naveen Ramanathan

当然了，字符串还有很多其他非常重要的使用方法，后面章节我们会再单独详细介绍。

强制类型转换

Golang是强类型的编程语言，并且不支持类型自动转换。

package main

import (  
    "fmt"
)

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

Go Playground在线运行 这段程序中的写法在C语言中其实是合法的，但是在Golang中却行不通。变量i是int类型，变量j是float64类型。前面程序中将两个不同类型的变量直接相加，执行会报错：

invalid operation: i + j (mismatched types int and float64)

我们可以通过强制类型转换将变量j转换为与变量i相同的int类型再进行相加，强制类型转换的语法为T(v)。

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)
}

Go Playground在线运行 现在可以正常输出结果：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)
}

Go Playground在线运行

前面程序中i首先进行了强制类型转换然后才赋值为了不通类型的变量j，执行结果如下：

j 10