梧席
类型
Q7nl1s admin
  2022-09-19 20:39:59 2022-09-19 20:39   2022-10-16 17:28:41      1.9k Words  

以下是 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
2
3
4
5
6
7
8
9
10
11
12
13
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 是false的。

当 a || b 为 true 时，运算符返回 true。在这种情况下，d 被赋值为true，因为 a 为true。我们将获得该程序的以下输出。

1
2
3
a: true b: false  
c: false  
d: true

Signed integers

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
2
3
4
5
6
7
8
9
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用于打印大小。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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
}

上面的程序将产生输出

1
2
3
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 字节）。

Unsigned integers

uint8：表示 8 位无符号整数
大小： 8 位
范围： 0 到 255

uint16：表示 16 位无符号整数
大小： 16 位
范围： 0 到 65535

uint32：表示 32 位无符号整数
大小： 32 位
范围： 0 到 4294967295

uint64：表示 64 位无符号整数
大小： 64 位
范围： 0 到 18446744073709551615

uint ：表示 32 位或 64 位无符号整数，具体取决于底层平台。
size : 32 位系统中的 32 位和 64 位系统中的 64 位。
范围：在 32 位系统中为 0 到 4294967295，在 64 位系统中为 0 到 18446744073709551615

Floating point types

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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 进行类似的计算。上面的程序将打印

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

Complex types

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

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

1
func complex(r, i FloatType) ComplexType

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

复数也可以使用速记语法创建

1
c := 6 + 7i

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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 的乘积。该程序将输出

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

Other numeric types

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

string type

字符串是 Go 中字节的集合。如果这个定义没有任何意义也没关系。现在，我们可以假设一个字符串是一个字符的集合。

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

1
2
3
4
5
6
7
8
9
10
11
12
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作为输出打印。

Type Conversion

Go 对显式类型非常严格。没有自动类型提升或转换。让我们通过一个例子来看看这意味着什么。

1
2
3
4
5
6
7
8
9
10
11
12
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 个不同类型的数字，这是不允许的。当你运行程序时，你会得到./prog.go:10:11: invalid operation: i + j (mismatched types int and float64)

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

1
2
3
4
5
6
7
8
9
10
11
12
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输出。

赋值也是如此。需要显式类型转换才能将一种类型的变量分配给另一种类型。这在以下程序中进行了解释。

1
2
3
4
5
6
7
8
9
10
11
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 而不进行任何类型转换时，编译器将抛出错误。

 Comments
Comment plugin failed to load
Loading comment plugin
  1. bool
  2. Signed integers
  3. Unsigned integers
  4. Floating point types
  5. Complex types
  6. Other numeric types
  7. string type
  8. Type Conversion
© 2020 - 2024    Q7nl1s
Powered by Hexo & Theme Keep
Unique Visitor Page View
  1. bool
  2. Signed integers
  3. Unsigned integers
  4. Floating point types
  5. Complex types
  6. Other numeric types
  7. string type
  8. Type Conversion