类型
欢迎来到Go系列教程的第四篇，本篇讲述的是Go的数据类型。
下面是Go存在的一些基础的类型。
- bool
- Number Types
- int8,int16,int32,int64,int
- uint8,uint16,uint32,uint64,uint
- float32,float64
- complex64,complex128
- byte
- rune
- string
布尔类型-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赋值为a && b的结果，这个&&运算符是只有当a和b都为ture的时候才会返回true。所以这个语句返回的是false。
而||运算符是只要a和b中有一个为true，那么它就会返回true。在上面事例中，因为a是true的，所以d就是true的。执行上面的程序，我们能得到下面的输出。
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: 表示32位或64位的整型数，到底是32位还是64位，主要还是看是在哪个平台上。一般情况下你都是用的int来表示整数，除非你有指定的整数大小需求。
大小: 在32位系统是32位，在64位系统则是64位
范围: 在32位系统是-2147483648 - 2147483647，在64位系统是-9223372036854775808 - 9223372036854775807
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）来推断它的类型。根据上面的规则，在32位系统中，int类型是32位的，在64位系统中则是64位的。下面我们就来验证下这个说法。
变量的类型可以在Printf函数中用%T格式说明符打印出来。Go有一个unsafe的包(package)里面有个函数Sizeof可以打印出参数所占字节的大小。但是在代码中使用unsale包还是要注意一点，就是它可能会有平台兼容性的问题，但是在我们这教程中使用当然是没问题的。
下面的程序输出了变量a和b的类型和大小。%T是用来打印类型的，%是用来打印大小的。
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\n", 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
type of a is int,size of a is 8
type of b is int,size of b is 8
我们可以根据上面的输出推断a和b都是int类型，它们都是64位bit(8byte)。但是如果上面的程序在32位系统上执行输出就会不一样，在32位系统，a和b占32位字节(4byte)。
无符号整数
unit8:表示8位无符号整数
大小:8位
范围：0 - 255
unit16:表示16位无符号整数
大小:16位
范围：0 - 65535
unit32:表示32位无符号整数
大小:32位
范围：0 - 4294967295
unit64:表示64位无符号整数
大小:64位
范围：0 - 18446744073709551615
unit:根据当前所在的平台系统而定的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
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，然后打印出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是用真实部分和虚拟部分去构造一个复数数字。complex函数有下面的定义。
func complex(r, i FloatType) ComplexType
它是用一个真实的和一个虚拟的部分作为参数，然后返回一个复数类型。真实和虚拟的部分都必须是相同的类型，float32或float64的。如果真实和虚拟部分都是float32类型的，那么这个函数将会返回一个complex64类型的复数数字。，如果真实和虚拟部分都是float64类型的，那么这个函数将会返回一个complex128类型的复数数字。
当然也可以用短语语法来生成一个复数数字。
c := 6 + 7i
让我们写一个简短的程序来更好地了解复数数字
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是虚拟部分。将c1和c2的和赋予变量cadd,c1和c2的乘积赋予cmul。下面是程序的输出.
sum: (13+34i)
product: (-149+191i)
其他的数字类型
byte 是unit8的别名
rune 是int32的别名
我们将会在学习string时，讨论更多bytes和runes的详细内容。
字符串类型
在Go中，字符串(strings)是字节(bytes)的集合。如果说你觉得这个定义没意义，没问题。现在我们假定字符串是字符(characters)的结合。我们将会学习string的更多内容在另外一篇教程。
我们用字符串写一个代码。
package main
import (
"fmt"
)
func main() {
first := "zhang"
last := "san"
name := first + " " + last
fmt.Println("My name is ", name)
}
在上面的程序中，变量first赋值字符串"zhang"，变量last赋值字符串"san".字符串可以用+操作符来连接。变量name的值就是通过连接变量first和变量last得来的。上面的程序就有输出My name is zhang san.
对于字符串我们还有很多不同的操作，我们将会在另外一个教程详细讨论。
类型转换
Go的显式类型是非常严格的，它的类型不会自动升级或转换。下面我们看看这个是什么意思。
package main
import (
"fmt"
)
func main() {
i := 55 // int
j := 67.8
sum := i + j // int + float64 not allowed
fmt.Println(sum)
}
上面的代码在C语言中是完全合法的。但是在Go中，这就不能行，i是int类型，j是float64类型。将两个不同类型的数字相加是不允许的。当你执行这个程序时，你将会得到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
sum := i + int(j) // 转换j为int类型
fmt.Println(sum)
}
现在你执行上面的程序，你就可以看到122的输出。
赋值时也是一样的，给一个变量赋值另外一种类型时也是需要显式类型转换的。可以看下面的代码解释。
package main
import (
"fmt"
)
func main() {
i := 10
var j float64 = float64(i) // 如果没有显示类型转换，这行代码就会报错
fmt.Println("j",j)
}
var j float64 = float64(i)在这个语句中，把i转换成了float64类型，然后赋值给j。但是当你要把i赋值给j却没有转换类型时，那么代码编译时就会报错。
以上就是本篇的全部，感谢阅读，这是我第一次翻译，难免会有翻译不当的地方，如果有什么反馈和评论，欢迎提出来！
浙公网安备 33010602011771号