golangbot
golangbot
发布于 6个月前

[ Golang 入门教程 ] 第4节——数据类型

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

  • 布尔(bool)
  • 数字类型
    • int8,int16,int32,int64,int
    • uint8,uint16,uint32,uint64,uint
    • float32,float64
    • complex64,complex128
    • byte
    • rune
  • 字符串(string)

布尔类型(bool)

布尔类型表示布尔值,值为truefalse

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为真时,返回true。在这种情况下,d被赋值为true,因为a为真。程序输出:

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

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

可以使用Printf方法中的 %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。然后打印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用于构造具有实部和虚部的复数。复杂函数具有以下定义

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 的别名 rune是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下,这不会起作用。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)
}

运行代码

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