| go

go初探-类型

下面是 Go 支持的基本类型： 

1
2
3
4
5
6
7
8
9
bool
数字类型
		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
14
15
package main 
import(
	"fmt"
	"unsafe"
)

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。在这里，由于 a 为 true，因此 d 也为 true。我们将得到程序的输出如下。

运行结果

1
2
3
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：根据不同的底层平台（Underlying Platform），表示 32 或 64 位整型。除非对整型的大小有特定的需求，否则你通常应该使用 int 表示整型。
大小：在 32 位系统下是 32 位，而在 64 位系统下是 64 位。
范围：在 32 位系统下是 -2147483648～2147483647，而在 64 位系统是 -9223372036854775808～9223372036854775807。

1
2
3
4
5
6
7
 func sizeofval() {
	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))
	fmt.Printf("type of b is %T,size of b is %d",b ,unsafe.Sizeof(b))
}
value of a is 89 and b is 95。```
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

在上述程序中，a 是 int 类型，而 b 的类型通过赋值（95）推断得出。上面我们提到，int 类型的大小在 32 位系统下是 32 位，而在 64 位系统下是 64 位。接下来我们会证实这种说法。

在 Printf 方法中，使用 %T 格式说明符（Format Specifier），可以打印出变量的类型。Go 的 unsafe 包提供了一个 Sizeof 函数，该函数接收变量并返回它的字节大小。unsafe 包应该小心使用，因为使用 unsafe 包可能会带来可移植性问题。不过出于本教程的目的，我们是可以使用的。

下面程序会输出变量 a 和 b 的类型和大小。格式说明符 %T 用于打印类型，而 %d 用于打印字节大小。

# 无符号整型 
>
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 位浮点数

下面一个简单程序演示了整型和浮点型的运用。

func floatfunc(){
a,b := 5.67,8.79
fmt.Printf(“type of a %T b %T \n”,a,b)
sum := a+b
dif := a-b
fmt.Println(“sum”,sum,”dif”,dif)

no1,no2 := 56,89
fmt.Println("sum",no1+no2,"dif",no1-no2)

}

1
2
3
4
5
6
7
8
9
10
11
12
13
 a 和 b 的类型根据赋值推断得出。在这里，a 和 b 的类型为 float64（float64 是浮点数的默认类型）。我们把 a 和 b 的和赋值给变量 sum，把 b 和 a 的差赋值给 diff，接下来打印 sum 和 diff。no1 和 no2 也进行了相同的计算。上述程序将会输出：
 
# 复数类型
> 
complex64：实部和虚部都是 float32 类型的的复数。
complex128：实部和虚部都是 float64 类型的的复数。

内建函数 complex 用于创建一个包含实部和虚部的复数。complex 函数的定义如下：
`func complex(r,i,FloatType) ComplexType`

该函数的参数分别是实部和虚部，并返回一个复数类型。实部和虚部应该是相同类型，也就是 float32 或 float64。如果实部和虚部都是 float32 类型，则函数会返回一个 complex64 类型的复数。如果实部和虚部都是 float64 类型，则函数会返回一个 complex128 类型的复数。

还可以使用简短语法来创建复数：

func complexFunc() {
c1 := complex(5,7)
c2 := 8 + 27i
cadd := c1 + c2
fmt.Println(“c1”,c1)
fmt.Println(“sum”,cadd)
cmul := c1 *c2
fmt.Println(“product”,cmul)
}

1
2
3
4
5
6
7
8
9
 
 #其他数字类型
> byte 是 uint8 的别名。  
rune 是 int32 的别名。

在学习字符串的时候，我们会详细讨论 byte 和 rune。

# string 类型
在 Golang 中，字符串是字节的集合。如果你现在还不理解这个定义，也没有关系。我们可以暂且认为一个字符串就是由很多字符组成的。我们后面会在一个教程中深入学习字符串。 下面编写一个使用字符串的程序。

func strFunc() {
first := “Naveen”
last := “Ramanathan”
name := first +” “+ last
fmt.Println(“My name is”,name)
}

1
# 类型转换

func typeChangefunc() {
i := 55 //int
j := 67.8 //float64
// sum := i + j //不允许 int + float64
sum := i + int(j) //j is converted to int
fmt.Println(sum)
}
`
Go 有着非常严格的强类型特征。Go 没有自动类型提升或类型转换。我们通过一个例子说明这意味着什么
上面的代码在 C 语言中是完全合法的，然而在 Go 中，却是行不通的。i 的类型是 int ，而 j 的类型是 float64 ，我们正试图把两个不同类型的数相加，Go 不允许这样的操作。如果运行程序，你会得到 main.go:10: invalid operation: i + j (mismatched types int and float64)。

要修复这个错误，i 和 j 应该是相同的类型。在这里，我们把 j 转换为 int 类型。把 v 转换为 T 类型的语法是 T(v)。