go系列教程-类型

下面是 Go 支持的基本类型：

bool
数字类型
int8, int16, int32, int64, int
uint8, uint16, uint32, uint64, uint
float32, float64
complex64, complex128
byte
rune
string
bool

1、bool 类型表示一个布尔值，值为 true 或者 false。

2、有符号整型

int8：表示 8 位有符号整型
大小：8 位
范围：-128～127

int16：表示 16 位有符号整型
大小：16 位
范围：-32768～32767

int32：表示 32 位有符号整型
大小：32 位
范围：-2147483648～2147483647

int32：表示 32 位有符号整型
大小：32 位
范围：-2147483648～2147483647

int：根据不同的底层平台（Underlying Platform），表示 32 或 64 位整型。除非对整型的大小有特定的需求，否则你通常应该使用 int 表示整型。
大小：在 32 位系统下是 32 位，而在 64 位系统下是 64 位。
范围：在 32 位系统下是 -2147483648～2147483647，而在 64 位系统是 -9223372036854775808～9223372036854775807。

package main

import (
    "fmt"
    "unsafe"
)

func main() {
    var a int = 89
    b := 95
    fmt.Sprintf("value of a is", a, "and is b\n", b)
    // a 的类型和大小
    fmt.Printf("type of a is %T, size of a is %d\n", a, unsafe.Sizeof(a))
    // b 的类型和大小
    fmt.Printf("type of b is %T, size of b is %d\n", b, unsafe.Sizeof(b))
}

在线运行程序

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

从上面的输出，我们可以推断出 a 和 b 为 int 类型，且大小都是 64 位（8 字节）。
如果你在 32 位系统上运行上面的代码，会有不同的输出。在 32 位系统下，a 和 b 会占用 32 位（4 字节）的大小。

3、无符号整型

uint8：表示 8 位无符号整型
大小：8 位
范围：0～255

uint16：表示 16 位无符号整型
大小：16 位
范围：0～65535

uint32：表示 32 位无符号整型
大小：32 位
范围：0～4294967295

uint64：表示 64 位无符号整型
大小：64 位
范围：0～18446744073709551615

uint：根据不同的底层平台，表示 32 或 64 位无符号整型。
大小：在 32 位系统下是 32 位，而在 64 位系统下是 64 位。
范围：在 32 位系统下是 0～4294967295，而在 64 位系统是 0～18446744073709551615。

4、浮点型

float32：32 位浮点数
float64：64 位浮点数

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

在线运行程序

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

a 和 b 的类型根据赋值推断得出。在这里，a 和 b 的类型为 float64（float64 是浮点数的默认类型）。

我们把 a 和 b 的和赋值给变量 sum，把 b 和 a 的差赋值给 diff，接下来打印 sum 和 diff。no1 和 no2 也进行了相同的计算

 

5、复数
在计算机中，复数是由两个浮点数表示的，其中一个表示实部（real），一个表示虚部（imag）

complex64：实部和虚部都是 float32 类型的的复数。
complex128：实部和虚部都是 float64 类型的的复数。

内建函数 complex 用于创建一个包含实部和虚部的复数。complex 函数的定义如下：
func complex(r, i FloatType) ComplexType

该函数的参数分别是实部和虚部，并返回一个复数类型。实部和虚部应该是相同类型，也就是 float32 或 float64。
如果实部和虚部都是 float32 类型，则函数会返回一个 complex64 类型的复数。
如果实部和虚部都是 float64 类型，则函数会返回一个 complex128 类型的复数。

还可以使用简短语法来创建复数：
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)
}

在线运行程序

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

如果大家对复数的运算法则不是很了解，可以查阅《复数运算法则》，其中详细的讲解了复数的加减乘除操作 。

复数也可以用==和!=进行相等比较，只有两个复数的实部和虚部都相等的时候它们才是相等的。

Go语言内置的 math/cmplx 包中提供了很多操作复数的公共方法，实际操作中建议大家使用复数默认的 complex128 类型，因为这些内置的包中都使用 complex128 类型作为参数

6、其他数字类型

byte 是 uint8 的别名。
rune 是 int32 的别名。

7、string 类型
在golang中，字符串是字节的集合，其中每一个元素叫做字符。具体内容参看《go系统教程-字符串》

8、类型转换

Go 有着非常严格的强类型特征。Go 没有自动类型提升或类型转换

package main

import "fmt"

func main() {
    a := 1
    b := 5.5
    sum := a + b
    fmt.Println(sum)
}

在线运行程序

invalid operation: a + b (mismatched types int and float64)

上面的代码在 C 语言中是完全合法的，然而在 Go 中，却是行不通的。a的类型是 int ，而 b 的类型是 float64 ，

我们正试图把两个不同类型的数相加，Go 不允许这样的操作。

如果运行程序，你会得到: invalid operation: i + j (mismatched types int and float64)

 

要修复这个错误，i 和 j 应该是相同的类型。在这里，我们把 j 转换为 int 类型。把 v 转换为 T 类型的语法是 T(v)

package main

import "fmt"

func main() {
    a := 1
    b := 5.5
    sum := a + int(b)
    fmt.Println(sum)
}

在线运行程序

 6