Go基础——类型

Posted 2020-12-29 beiluowuzheng

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

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: false
d: true

　　

这个运行结果很好理解，如果两个变量都为true，做&&运算就都为true，如果其中一个是true另一个是false，做&&运算为false，而||运算只要有一个为true，则结果为true

有符号整型

int8：表示 8 位有符号整型
大小：8 位
范围：-128～127

int16：表示 16 位有符号整型
大小：16 位
范围：-32768～32767

int32：表示 32 位有符号整型
大小：32 位
范围：-2147483648～2147483647

int64：表示 64 位有符号整型
大小：64 位
范围：-9223372036854775808～9223372036854775807

Go语言中的unsafe包下有一个Sizeof方法，它接受一个变量，并返回变量所占用的字节数。使用unsafe包我们需要小心，因为它可能会带来可移植性问题，不过在教程里没有关系。在下面一个例子中，我们使用%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("type 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 8
type of b is int, size of b is 8

　　

如果打印结果，我们可以推断出上面的程序是运行在64位的系统上，因为如果是32位的系统，int会占4个字节，也就是32位，如果int占8个字节，则是在64位的系统上

无符号整型

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
	sum := a + b
	diff := a - b
	fmt.Println("sum:", sum, "diff:", diff)
	fmt.Printf("type of a %T b %T
", a, b)
	fmt.Printf("type of sum %T diff %T
", sum, diff)
}

　　

运行结果：

sum: 14.64 diff: -3.3000000000000007
type of a float64 b float64
type of sum float64 diff float64

　　 

我们再次通过%T打印a和b的类型，可以看到a和b的类型都是float64，float64是浮点数的默认类型，然后我们将a和b相加，赋值给sum，a和b相减，赋值给diff，而sum和diff的类型同样是float64

复数类型

complex64: 实部和虚部为float32位的复数 
complex128: 实部和虚部为float64位的复数

内建函数complex可以用来构造一个带有实部和虚部的复数，complex函数的定义如下：

func complex(r, i FloatType) ComplexType  

　　

这个函数接收一个实部和虚部的参数，并返回一个复数类型的值。实部和虚部必须是同一个类型。无论是float32还是float64。如果实部和虚部是float32，那么返回的值是complex64类型，如果实部和虚部都是floa64的类型，那么返回值的类型为complex128

package main

import "fmt"

func main() {
	r1, i1 := float32(5), float32(7)
	c1 := complex(r1, i1)
	fmt.Printf("type of c1 %T
", c1)
	//r2, i2 := 5, 7
	//c2 := complex(r2, i2)  如果将r2和i2传入，编译器会判断r2和i2为int类型，从而报出类型不匹配错误
	c2 := complex(5, 7) //编译器会将传入的5和7自动转换为float类型
	fmt.Printf("type of c2 %T
", c2)
	r3, i3 := float64(5), float64(7)
	c3 := complex(r3, i3)
	fmt.Printf("type of c3 %T
", c3)
}

　　

运行结果：

type of c1 complex64
type of c2 complex128
type of c3 complex128

　　

接下来，我们再看一下复数的相加和相乘。设c1=a+bi,c2=c+di是任意两个复数，则它们的和为(a+bi)+(c+di)=(a+c)+(b+d)i，它们的积为(a+bi)(c+di)=(ac-bd)+(bc+ad)i

package main

import "fmt"

func main() {
	c1 := complex(2, 3)
	c2 := 5 + 6i
	cadd := c1 + c2
	fmt.Println("cadd:", cadd)
	cmul := c1 * c2
	fmt.Println("cmul:", cmul)
}

　　

运行结果：

cadd: (7+9i)
cmul: (-8+27i)

　　

类型转换

Go对于类型的明确十分严格，这里没有类型自动转换

package main

import "fmt"

func main() {
	i := 55    //int
	j := 65.9  //float64
	k := i + j //int + float64 not allowed
	fmt.Println(k)
}

　　

上面这一段代码将一个整型和一个浮点数相加，在很多语言是允许这么操作的，但在Go中是编译不通过的，因为这里Go是不会帮我们自动将整型转换成浮点类型，必须程序员手动转换

package main

import "fmt"

func main() {
	i := 55             //int
	j := 65.9           //float64
	k := i + int(j)     //将float64转换为int
	z := float64(i) + j //将int转换为float64
	fmt.Println(k)
	fmt.Println(z)
}

　　

修改成这样，就能通过编译顺利运行了

string类型

在Go语言中，string是字节的集合，同Java和Python一样，Go语言也支持字符串的“+”操作

package main

import "fmt"

func main() {
	hello := "hello"
	world := "world"
	result := hello + " " + world
	fmt.Println(result)
}

　　

运行结果：

hello world

　　

其他数字类型

byte：uint8的别称
rune：int32的别称

在后面的章节还会再介绍字符串、byte和rune这几种类型