go 的基本數據類型
下面是 Go 支持的基本類型:
- bool
- 數字類型
- int8, int16, int32, int64, int
- uint8, uint16, uint32, uint64, uint
- float32, float64
- complex64, complex128
- byte
- rune
- string
bool
bool 類型表示一個布爾值,值為 true 或者 false。
package main import "fmt" func main() { a := true b := false fmt.Println("a:", a, "b:", b) c := a && b fmt.Println("c:", c) d := a || b fmt.Println("d:", d) }
在上面的程序中,a 賦值為 true,b 賦值為 false。
c 賦值為 a && b。僅當 a 和 b 都為 true 時,操作符 && 才返回 true。因此,在這裏 c 為 false。
當 a 或者 b 為 true 時,操作符 || 返回 true。在這裏,由於 a 為 true,因此 d 也為 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:根據不同的底層平臺(Underlying Platform),表示 32 或 64 位整型。除非對整型的大小有特定的需求,否則你通常應該使用 int 表示整型。
大小:在 32 位系統下是 32 位,而在 64 位系統下是 64 位。
範圍:在 32 位系統下是 -2147483648~2147483647,而在 64 位系統是 -9223372036854775808~9223372036854775807。
package main
import "fmt"
func main() {
var a int = 89
b := 95
fmt.Println("value of a is", a, "and b is", b)
}
在線運行程序
上面程序會輸出 value of a is 89 and b is 95
。
在上述程序中,a 是 int 類型,而 b 的類型通過賦值(95)推斷得出。上面我們提到,int 類型的大小在 32 位系統下是 32 位,而在 64 位系統下是 64 位。接下來我們會證實這種說法。
在 Printf 方法中,使用 %T 格式說明符(Format Specifier),可以打印出變量的類型。Go 的 unsafe 包提供了一個 Sizeof 函數,該函數接收變量並返回它的字節大小。unsafe 包應該小心使用,因為使用 unsafe 包可能會帶來可移植性問題。不過出於本教程的目的,我們是可以使用的。
下面程序會輸出變量 a 和 b 的類型和大小。格式說明符 %T
用於打印類型,而 %d
用於打印字節大小。
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)) // a 的類型和大小
fmt.Printf("\ntype of b is %T, size of b is %d", b, unsafe.Sizeof(b)) // 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 為 int 類型,且大小都是 32 位(4 字節)。如果你在 64 位系統上運行上面的代碼,會有不同的輸出。在 64 位系統下,a 和 b 會占用 64 位(8 字節)的大小。
無符號整型
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。
浮點型
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)
}
a 和 b 的類型根據賦值推斷得出。在這裏,a 和 b 的類型為 float64(float64 是浮點數的默認類型)。我們把 a 和 b 的和賦值給變量 sum,把 b 和 a 的差賦值給 diff,接下來打印 sum 和 diff。no1 和 no2 也進行了相同的計算。上述程序將會輸出:
type of a float64 b float64
sum 14.64 diff -3.3000000000000007
sum 145 diff -33
復數類型
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)
}
在上面的程序裏,c1 和 c2 是兩個復數。c1的實部為 5,虛部為 7。c2 的實部為8,虛部為 27。c1 和 c2 的和賦值給 cadd
,而 c1 和 c2 的乘積賦值給 cmul
。該程序將輸出:
sum: (13+34i)
product: (-149+191i)
其他數字類型
byte 是 uint8 的別名。
rune 是 int32 的別名。
在學習字符串的時候,我們會詳細討論 byte 和 rune。
string 類型
在 Golang 中,字符串是字節的集合。如果你現在還不理解這個定義,也沒有關系。我們可以暫且認為一個字符串就是由很多字符組成的。我們後面會在一個教程中深入學習字符串。 下面編寫一個使用字符串的程序。
package main
import (
"fmt"
)
func main() {
first := "Naveen"
last := "Ramanathan"
name := first +" "+ last
fmt.Println("My name is",name)
}
上面程序中,first 賦值為字符串 "Naveen",last 賦值為字符串 "Ramanathan"。+ 操作符可以用於拼接字符串。我們拼接了 first、空格和 last,並將其賦值給 name。上述程序將打印輸出 My name is Naveen Ramanathan
。
還有許多應用於字符串上面的操作,我們將會在一個單獨的教程裏看見它們。
類型轉換
Go 有著非常嚴格的強類型特征。Go 沒有自動類型提升或類型轉換。我們通過一個例子說明這意味著什麽。
package main
import (
"fmt"
)
func main() {
i := 55 //int
j := 67.8 //float64
sum := i + j //不允許 int + float64
fmt.Println(sum)
}
上面的代碼在 C 語言中是完全合法的,然而在 Go 中,卻是行不通的。i 的類型是 int ,而 j 的類型是 float64 ,我們正試圖把兩個不同類型的數相加,Go 不允許這樣的操作。如果運行程序,你會得到 main.go:10: invalid operation: i + j (mismatched types int and float64)
。
要修復這個錯誤,i 和 j 應該是相同的類型。在這裏,我們把 j 轉換為 int 類型。把 v 轉換為 T 類型的語法是 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)
}
現在,當你運行上面的程序時,會看見輸出 122
。
賦值的情況也是如此。把一個變量賦值給另一個不同類型的變量,需要顯式的類型轉換。下面程序說明了這一點。
package main
import (
"fmt"
)
func main() {
i := 10
var j float64 = float64(i) // 若沒有顯式轉換,該語句會報錯
fmt.Println("j", j)
}
在第 9 行,i 轉換為 float64 類型,接下來賦值給 j。如果不進行類型轉換,當你試圖把 i 賦值給 j 時,編譯器會拋出錯誤。
go 的基本數據類型