[ Golang 入门教程 ] 第4节——数据类型
以下是go语言中可用的基本类型
- 布尔(bool)
- 数字类型
- 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被赋值为&& b的值。仅当a和b都为true时，&&运算符才返回true。所以在这种情况下c是假的。
|| 当a或b为真时，返回true。在这种情况下，d被赋值为true，因为a为真。程序输出：
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位整数，具体取决于底层平台。除非需要使用特定大小的整数，否则通常应该使用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）推断。如上所述，int 的大小在32位系统中是32位，在64位系统中是64位。让我们继续并验证这一说法。
可以使用Printf方法中的 ％T 格式说明符打印变量的类型。Go有一个包：unsafe，它有一个Sizeof函数，以字节为单位返回参数变量的大小。应谨慎使用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
}上面的程序将产生输出
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字节）。
无符号整数
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
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用于构造具有实部和虚部的复数。复杂函数具有以下定义
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。cadd被分配c1和c2的和，cmul并被赋予c1和c2的乘积。该程序将输出
sum: (13+34i)
product: (-149+191i) 其他数字类型
byte是uint8 的别名 rune是int32的别名
当我们了解字符串时，我们将更详细地讨论。
字符串类型
字符串是golang中的字节集合。现在我们可以假设一个字符串是一个字符集合。我们将在单独的教程中详细了解字符串。
让我们用字符串写一个程序。
package main
import (
"fmt"
)
func main() {
first := "Naveen"
last := "Ramanathan"
name := first +" "+ last
fmt.Println("My name is",name)
}在上面的程序中，首先分配字符串“Naveen”，最后分配字符串“Ramanathan”。可以使用+运算符连接字符串。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)
}上面的代码在C语言中是完全合法的。但是在go下，这不会起作用。i是int类型，j是float64类型。我们正在尝试添加2个不允许的不同类型的数字。当你运行程序时，你会得到main.go:10: 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)
}现在，当您运行上述程序时，您可以看到输出 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行，i转换为float64，然后分配给j。当您尝试将i分配给j而没有任何类型转换时，编译器将抛出错误。
