Heim > Backend-Entwicklung > Golang > [Übersetzung] Go-Sprachgrundlagen-Typen

[Übersetzung] Go-Sprachgrundlagen-Typen

Freigeben: 2023-07-21 10:41:42
nach vorne
1278 Leute haben es durchsucht

Die folgenden Grundtypen sind in der Go-Sprache verfügbar:

1. bool (Boolean);

2. Numerische Typen:

int8, int32, int64, int

uint8, uint16, uint32, uint64, uint

float32, float64

complex64, complex128

byte, rune

3, string (string);

bool

bool-Typ steht für Boolean Wert, nur zwei Werte: wahr oder falsch.

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)
}
Nach dem Login kopieren

Execute [1]

Im obigen Code werden a und b jeweils true und false zugewiesen. Das Ergebnis von

a && b wird c zugewiesen. Der &&-Operator gibt nur dann true zurück, wenn a und b beide true sind, sodass der Wert von c false ist.

Solange entweder a oder b wahr ist, gibt der ||-Operator wahr zurück, sodass der Wert von d hier wahr ist.

Die obige Codeausgabe:

a: true b: false
c: false
d: true
Nach dem Login kopieren

vorzeichenbehaftete Ganzzahl

int8: 8-Bit-Ganzzahl mit Vorzeichen
Größe: 8-Bit
Bereich: -128 ~ 127

int16: 16-Bit-Ganzzahl mit Vorzeichen Typ
Größe: 16 Bit
Bereich: -32768 ~ 32767

int32: 32 位有符号整型
size: 32 位
范围: -2147483648 ~ 2147483647

int64: 64 位有符号整型
size: 64 位
范围: -9223372036854775808 ~ 9223372036854775807

int: int 表示 32 或 64 位整型,具体位数取决于机器位数,除非需要使用特定大小的整数,否则通常使用 int 来表示整数
size: 32 位系统上为 32 位,64 位系统上为 64 位;
范围: 32 位系统 -2147483648 to 2147483647,64 位系统 -9223372036854775808 to 9223372036854775807

package main

import "fmt"

func main() {
    var a int = 89
    b := 95
    fmt.Println("value of a is", a, "and b is", b)
}
Nach dem Login kopieren

执行[2]

输出:value of a is 89 and b is 95.

上面的代码中,a 显式地声明为 int 类型,从赋给 b 的值来看,b 也是 int 类型。从上面我们知道,int 类型在 32 位系统上为 32 bit,在 64 位系统上是 64 bit。

我们一起来验证下。

变量的类型可以使用 Printf() 函数和 %T 格式化输出。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)) //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
}
Nach dem Login kopieren

执行[3]

从上面的输出中,我们可以推断出 a 和 b 的类型是 int 并且都是 32 位大小(4 字节)。如果你是在 64 位系统上运行上述程序,输出会有所不同。在 64 位系统中,a 和 b 占用 64 位(8 字节)。

无符号整型

uint8: 8 位无符号整型
size: 8 位
范围: 0 ~ 255

uint16: 16 位无符号整型
size: 16 位
范围: 0 ~ 65535

uint32: 32 位无符号整型
size: 32 位
范围: 0 ~ 4294967295

uint64: 64 位无符号整型
size: 64 位
范围: 0 ~ 18446744073709551615

uint : 32 位或 64 位无符号整型,具体位数取决于系统位数
size : 32 位或 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)
}
Nach dem Login kopieren

执行[4]

上面的代码,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
Nach dem Login kopieren

复数

complex64:由 float32 类型的实部和虚部组成的复数。complex128:由 float64 类型的实部和虚部组成的复数。

内置函数 complex() 根据给定的实数和虚数创建复数,该函数定义如下:

func complex(r, i FloatType) ComplexType
Nach dem Login kopieren

实部和虚部分别作为参数,返回一个复数。实部和虚部必须是同种类型,float32 或 float64。如果实部和虚部都是 float32,则返回类型为 complex64 的复数;如果实部和虚部都是 float64,则返回 complex128 类型的复数。

短变量声明也可以创建复数:

c := 6 + 7i
Nach dem Login kopieren

我们一起来看个 demo:

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)
}
Nach dem Login kopieren

执行[5]

上面的代码中,c1 和 c2 是两个复数,c1 的实部是 5、虚部是 7。c2 的实部是 8、虚部是 27。c1 和 c2 相加之和赋给 cadd,乘积赋给 cmul,程序输出如下:

sum: (13+34i)
product: (-149+191i)
Nach dem Login kopieren

其他数值类型

byte 是 uint8 的别名,rune 是 int32 的别名。我们将在后面的章节展开讲解这两个概念。

字符串

Go 语言里面,字符串可以理解成是 byte(字节)的集合。

我们用 string 编写一个程序:

package main

import (
    "fmt"
)

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

执行[6]

在上面的程序中,将字符串 "Naveen" 赋给了变量 first、"Ramanathan" 赋给了变量 last。字符串可以通过 + 操作符连接,将字符串变量 first、last 以空字符相连,结果赋给变量 name。

上面的代码输出:

My name is Naveen Ramanathan
Nach dem Login kopieren

还有一些关于字符串其他的操作方法,我们将在后面的章节单独讲解。

类型转换

Go 是强类型语言,没有类型的自动提升、转换。我们来看下什么意思:

package main

import (
    "fmt"
)

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

执行[7]

上面的代码,i 和 j 相加在 C 语言中是完全合法的,但在 Go 语言里却是行不通的。i 是 int 类型,j 是 float64 类型,将这两个不同类型的变量相加是不允许的。

执行上面的代码会报错:./prog.go:10:11: 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)
}
Nach dem Login kopieren

执行[8]

现在执行上面的程序,将会输出 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)
}
Nach dem Login kopieren

执行[9]

上面代码的第 9 行,将 i 转换成 float64 然后赋值给 j,如果不经过类型转换而直接赋值,编译器将会报错。

Das obige ist der detaillierte Inhalt von[Übersetzung] Go-Sprachgrundlagen-Typen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!

Verwandte Etiketten:
Quelle:Go语言进阶学习
Erklärung dieser Website
Der Inhalt dieses Artikels wird freiwillig von Internetnutzern beigesteuert und das Urheberrecht liegt beim ursprünglichen Autor. Diese Website übernimmt keine entsprechende rechtliche Verantwortung. Wenn Sie Inhalte finden, bei denen der Verdacht eines Plagiats oder einer Rechtsverletzung besteht, wenden Sie sich bitte an admin@php.cn
Beliebte Tutorials
Mehr>
Neueste Downloads
Mehr>
Web-Effekte
Quellcode der Website
Website-Materialien
Frontend-Vorlage