以下是 go 的基本类型

  • bool

  • Numeric Types

    • int8, int16, int32, int64, int

    • uint8, uint16, uint32, uint64, uint

    • float32, float64

    • complex64, complex128

    • byte

    • rune

  • string

bool

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

  1. package main
  3. import "fmt"
  5. func main() {  
  6.     a := true
  7.     b := false
  8.     fmt.Println("a:", a, "b:", b)
  9.     c := a && b
  10.     fmt.Println("c:", c)
  11.     d := a || b
  12.     fmt.Println("d:", d)
  13. }

Run in playground

在上面的程序中，a 赋值为 true, b 赋值为 false。

c 赋值为 a && b，只有当 a 和 b 都为 true 时，&& 操作符才返回 true。在这种情况下，c 是 false。

当 a 或 b 为真时，|| 操作符返回 true。在本例中，d 被赋值为 true，因为 a 为 true。我们将得到输出

  1. a: true b: false  
  2. c: false  
  3. 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 位整数，具体取决于底层平台。除非需要使用特定大小的整数，否则通常应该使用 int 来表示整数。

大小：32 位系统中为 32 位，64 位系统中为 64 位。

范围：32 位系统中为 -2147483648 到 2147483647，64位系统中为 -9223372036854775808 到 9223372036854775807

  1. package main
  3. import "fmt"
  5. func main() {  
  6.     var a int = 89
  7.     b := 95
  8.     fmt.Println("value of a is", a, "and b is", b)
  9. }

Run in playground

以上程序将输出 value of a is 89 and b is 95

在上面的程序中，a 是 int 类型，b 的类型是从分配给它的值推断出来的（95）。如上所述，int 的大小在 32 位系统中是 32 位，在 64 位系统中是 64 位。让我们继续并验证这一说法。

可以使用 Printf 方法中的 ％T 格式说明符输出变量的类型。 Go 有一个 unsafe 的包，它有一个 Sizeof 函数，它以字节为单位返回传递给它的变量的大小。应谨慎使用 unsafe 的软件包，因为使用它的代码可能存在可移植性问题，但在本教程中，我们可以使用它。

以下程序输出变量 a 和 b 的类型和大小。%T 是输出类型的格式说明符，%d 用于输出大小。

  1. package main
  3. import (  
  4.     "fmt"
  5.     "unsafe"
  6. )
  8. func main() {  
  9.     var a int = 89
  10.     b := 95
  11.     fmt.Println("value of a is", a, "and b is", b)
  12.     fmt.Printf("type of a is %T, size of a is %d", a, unsafe.Sizeof(a)) //type and size of a
  13.     fmt.Printf("\ntype of b is %T, size of b is %d", b, unsafe.Sizeof(b)) //type and size of b
  14. }

Run in playground

上面的程序将产生输出

  1. value of a is 89 and b is 95  
  2. type of a is int, size of a is 4  
  3. 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 位无符号整数

大小: 8 位

范围: 0 到 18446744073709551615

uint：表示 32 位或 64 位无符号整数，具体取决于底层平台。

大小：32 位系统中为 32 位，64 位系统中为 64 位。

范围：32 位系统中为 0 到 4294967295,64 位系统中为 0 到18446744073709551615。

浮点类型

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

下面是一个简单的程序来说明整数和浮点类型

  1. package main
  3. import (  
  4.     "fmt"
  5. )
  7. func main() {  
  8.     a, b := 5.67, 8.97
  9.     fmt.Printf("type of a %T b %T\n", a, b)
  10.     sum := a + b
  11.     diff := a - b
  12.     fmt.Println("sum", sum, "diff", diff)
  14.       no1, no2 := 56, 89
  15.     fmt.Println("sum", no1+no2, "diff", no1-no2)
  16. }

Run in playground

a 和 b 的类型是从分配给它们的值推断出来的。在这种情况下，a 和 b 的类型为float64。（float64 是浮点值的默认类型）。我们把 a 与 b 相加并将其分配给变量sum。我们把 a 与 b 相减并将其分配给 diff。然后输出 sum 和 diff。用 no1 和 no2 也做了类似的计算。上面的程序将输出

  1. type of a float64 b float64  
  2. sum 14.64 diff -3.3000000000000007  
  3. sum 145 diff -33

复数型

complex64: 具有 float32 实部和虚部的复数
complex128: 具有 float64 实部和虚部的复数

内置函数 complex 用于构造具有实部和虚部的复数。complex 函数具有以下定义

  1. func complex(r, i FloatType) ComplexType

它将实部和虚部作为参数并返回 complex 类型。实部和虚部都应该是相同的类型。即float32 或 float64。如果实部和虚部都是 float32，则此函数返回 complex64 类型的复数值。如果实部和虚部都是 float64 类型，则此函数返回 complex128 类型的复数值

复数也可以使用简写语法创建


  1. c := 6 + 7i

让我们写一个小程序来理解复数。

  1. package main
  3. import (  
  4.     "fmt"
  5. )
  7. func main() {  
  8.     c1 := complex(5, 7)
  9.     c2 := 8 + 27i
  10.     cadd := c1 + c2
  11.     fmt.Println("sum:", cadd)
  12.     cmul := c1 * c2
  13.     fmt.Println("product:", cmul)
  14. }

Run in playground

在上面的程序中，c1 和 c2 是两个复数。c1 的实部为 5 虚部为 7。c2 实部为 8 和虚部为 27。cadd 被赋值为 c1 和 c2 的和，cmul 被赋值为 c1 和 c2 的乘积。这个程序将输出

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

其他数值类型

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

当我们了解字符串时，我们将更详细地讨论 byte 和 rune。

字符串类型

字符串是 golang 中字节的集合。如果这个定义没有任何意义的话，那也没关系。现在，我们可以假设字符串是一个字符集合。我们将在单独的教程中详细了解字符串。

让我们使用字符串写一个程序。

  1. package main
  3. import (  
  4.     "fmt"
  5. )
  7. func main() {  
  8.     first := "Naveen"
  9.     last := "Ramanathan"
  10.     name := first +" "+ last
  11.     fmt.Println("My name is",name)
  12. }

Run in playground

在上面的程序中，first 分配字符串 “Naveen”， last 分配字符串 “Ramanathan”。字符串可以使用 + 运算符连接。name 被赋值为 first 变量加一个空格值再加一个 last 变量。上面的程序将输出 My name is Naveen Ramanathan

还可以对字符串执行更多的操作。我们将在单独的教程中讨论这些。

类型转换

Go对显式输入非常严格。没有自动类型提升或转换。让我们用一个例子来看看这是什么意思。

  1. package main
  3. import (  
  4.     "fmt"
  5. )
  7. func main() {  
  8.     i := 55      //int
  9.     j := 67.8    //float64
  10.     sum := i + j //int + float64 not allowed
  11.     fmt.Println(sum)
  12. }

Run in playground

上面的代码在 C 语言中是完全合法的。但是在 go 语言里，这不会起作用。i 是 int 类型，j 是 float64 类型。我们试图相加两个不同类型的数字，这是不允许的。你会得到main.go:10: invalid operation: i + j (mismatched types int and float64)

为了修正这个错误，i 和 j 应该是同一类型的。让我们把 j 转换成 int。T(v) 是把值 v 转换成类型 T 的语法

  1. package main
  3. import (  
  4.     "fmt"
  5. )
  7. func main() {  
  8.     i := 55      //int
  9.     j := 67.8    //float64
  10.     sum := i + int(j) //j is converted to int
  11.     fmt.Println(sum)
  12. }

Run in playground

现在，当你运行上面的程序时，你可以看到 122 作为输出。

赋值也是如此。需要显式类型转换才能将一种类型的变量分配给另一种类型的变量。如下

  1. package main
  3. import (  
  4.     "fmt"
  5. )
  7. func main() {  
  8.     i := 10
  9.     var j float64 = float64(i) //this statement will not work without explicit conversion
  10.     fmt.Println("j", j)
  11. }

Run in playground

在第 9 行，i 转换为 float64 类型，然后分配给 j 。当你尝试将 i 分配给 j 而没有任何类型转换时，编译器将抛出错误。

原文链接

https://golangbot.com/types/