golang类型

分类: glolang 发布时间: 2018-10-01 15:32:11

以下是go中可用的基本类型

bool

Numeric Types

  • int8, int16, int32, int64, int

  • uint8, uint16, uint32, uint64, uint

  • float32, float64

  • complex64, complex128

  • byte

  • rune

string

布尔

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被赋值为&& b的值。仅当a和b都为true时,&&运算符才返回true。所以在这种情况下c是假的。

|| 当a或b为真时,operator返回true。在这种情况下,d被赋值为true,因为a为真。我们将为此程序获得以下输出。

a: true b: false  
c: false  
d: true
签名整数

int8:表示8位有符号整数

大小: 8位

范围: -128到12

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

在上述程序中一个是int类型和B的类型是从分配给它(95)的值推断。如上所述,int的大小在32位系统中是32位,在64位系统中是64位。让我们继续并验证这一说法。

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

以下程序输出变量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。然后打印sum和diff。使用no1和no2完成类似的计算。上面的程序将打印出来

type of a float64 b float64  
sum 14.64 diff -3.3000000000000007  
sum 145 diff -33
复杂的类型

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

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

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

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)
其他数字类型

byte是uint8 的别名

符文是int32的别名

字符串类型

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

package main

import (  
    "fmt"
)

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

在上面的程序中,首先分配字符串“Naveen”,最后分配字符串“Ramanathan”。可以使用+运算符连接字符串。name被赋予第一个连接到空格后跟最后一个的值。上述程序将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的情况下,这不会起作用。我是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)
}

排队号码 9,i转换为float64,然后分配给j。当您尝试将i分配给j而没有任何类型转换时,编译器将抛出错误。