标签：大小 其他 代码 运行 als 介绍 布尔值 相加 返回
Go基本类型
bool
Numeric Types：
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\n", 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\n", a, b)
fmt.Printf("type of sum %T diff %T\n", 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\n", 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\n", c2)
r3, i3 := float64(5), float64(7)
c3 := complex(r3, i3)
fmt.Printf("type of c3 %T\n", 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这几种类型
标签：大小 其他 代码 运行 als 介绍 布尔值 相加 返回
原文地址：https://www.cnblogs.com/beiluowuzheng/p/9450954.html
