>백엔드 개발 >Golang >[번역] 바둑언어 기본형

[번역] 바둑언어 기본형

Go语言进阶学习
Go语言进阶学习앞으로
2023-07-21 10:41:421277검색

Go 언어에서 사용할 수 있는 기본 유형은 다음과 같습니다.

1.bool(부울);

2 숫자 유형:

int8, int16, int32, int64, int

uint8 , uint16, uint32, uint64, uint

float32, float64

complex64, complex128

byte, rune

3, string(문자열)

bool

bool 유형은 부울을 나타냅니다. 값은 단 2개 값: 참 또는 거짓.

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)
}

Execute [1]

위 코드에서 a와 b에는 각각 true와 false가 할당되어 있습니다.

a && b의 결과는 c에 할당됩니다. && 연산자는 a와 b가 모두 true인 경우에만 true를 반환하므로 c의 값은 false입니다.

a 또는 b가 true이면 || 연산자는 true를 반환하므로 여기서 d 값은 true입니다.

위 코드 출력:

a: true b: false
c: false
d: true

부호 있는 정수

int8: 8비트 부호 있는 정수

크기: 8비트
범위: -128 ~ 127

int16: 16비트 부호 있는 정수 유형

크기: 16비트
범위: -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)
}

执行[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
}

执行[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)
}

执行[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

复数

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

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

func complex(r, i FloatType) ComplexType

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

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

c := 6 + 7i

我们一起来看个 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)
}

执行[5]

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

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

其他数值类型

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)
}

执行[6]

在上面的程序中,将字符串 "Naveen" 赋给了变量 first、"Ramanathan" 赋给了变量 last。字符串可以通过 + 操作符连接,将字符串变量 first、last 以空字符相连,结果赋给变量 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)
}

执行[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)
}

执行[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)
}

执行[9]

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

위 내용은 [번역] 바둑언어 기본형의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!

성명:
이 기사는 Go语言进阶学习에서 복제됩니다. 침해가 있는 경우 admin@php.cn으로 문의하시기 바랍니다. 삭제