Golang中的变量类型

第4部分：类型

这是Golang教程系列中的第4个教程。
请阅读Golang教程第3部分：本系列的变量，以了解变量。
以下是可使用的基本类型

• 布尔
• 数值类型
• int8，int16，int32，int64，int
  uint8，uint16，uint32，uint64，uint
  float32，float64
  complex64，complex128
  字节
  rune
• 字符串

布尔

布尔类型表示布尔值，可以为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为假。

|| 当a或b为true时，运算符返回true。在这种情况下，由于a为真，因此d被分配为真。我们将为此程序获得以下输出。

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：表示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位。让我们继续进行验证。

可以使用函数中的％T格式说明符来打印变量的类型。Go有一个unsafe包，它具有Sizeof函数，该函数以字节为单位返回传递给它的变量的大小。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)) //type and size of a
    fmt.Printf("\ntype of b is %T, size of b is %d", b, unsafe.Sizeof(b)) //type and size of 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。我们从a中减去b并将其分配给diff。然后将求和和差异打印出来。使用no1和no2完成类似的计算。以上程序将打印

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

复数类型

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

内置函数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。cadd分配c1和c2之和，cmul并分配c1和c2的乘积。该程序将输出

sum: (13+34i)  
product: (-149+191i)  
其他数值类型
字节是uint8 的别名
符文是int32的别名

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

字符串类型

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

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

package main

import (  
    "fmt"
)

func main() {  
    first := "Naveen"
    last := "Ramanathan"
    name := first +" "+ last
    fmt.Println("My name is",name)
}

在上面的程序中，首先分配字符串“ Naveen”，最后分配字符串“ Ramanathan”。可以使用+运算符将字符串连接在一起。给name赋值为first的值连接到一个空格，然后为last。上面的程序将My name is Naveen Ramanathan作为输出打印。

还有一些可以对字符串执行的操作。我们将在单独的教程中介绍这些内容。

类型转换

Go对于显式键入非常严格。没有自动类型提升或转换。让我们看一个示例的含义。

package main

import (  
    "fmt"
)

func main() {  
    i := 55      //int
    j := 67.8    //float64
    sum := i + j //int + float64 not allowed
    fmt.Println(sum)
}

上面的代码在C语言中是完全合法的。但是在使用go的情况下，这将行不通。i是int类型，j是float64类型。我们正在尝试添加2个不同类型的数字，这是不允许的。当您运行程序时，您将获得main.go:10: invalid operation: i + j (mismatched types int and float64)

要解决该错误，i和j应该具有相同的类型。让我们将j转换为int。T(v)是将值v转换为类型T的语法

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) //this statement will not work without explicit conversion
    fmt.Println("j", j)
}

i转换为float64，然后分配给j。当您尝试将i分配给j而不进行任何类型转换时，编译器将引发错误。