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

標籤：Go

上一篇：Go開發筆記系列：1 - Go 開發環境搭建和代碼除錯

下一篇：go系列教程-字串