go系列教程-类型

Posted 2021-03-01 e10470252222

下面是 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
", b)
    // a 的类型和大小
    fmt.Printf("type of a is %T, size of a is %d
", a, unsafe.Sizeof(a))
    // b 的类型和大小
    fmt.Printf("type of b is %T, size of b is %d
", 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
", 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