标签：explicit import float 空格 字符串类型 work 类型转换 细节 介绍
下面是 Go 支持的基本类型：
bool 类型表示真假值，只能为 true 或 false。
import "fmt" func main() { var a bool = 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（译者注：a 为 true，因此 a || b 的结果为true，因此 d 为 true）。我们将会得到如下输出：
a: true b: false c: false d: true
int8：表示8位有符号整数
size：8 bits
range：-128 ~ 127
int16：表示16位有符号整数
size：16 bits
range：-32768 ~ 32767
int32： 表示32位有符号整数
size： 32 bits
range： -2147483648 ~ 2147483647
int64： 表示64位有符号整数
size： 64 bits
range： -9223372036854775808 ~ 9223372036854775807
int： 根据底层平台（underlying platform）不同，表示32或64位整数。在实际编程中，除非对大小有明确的要求，否则一般应该使用 int 表示整数。
size： 在32位系统下 32 bits，在64位系统下 64 bits
range： 在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
uint8： 表示8位无符号整型
size： 8 bits
range： 0 ~ 255
uint16： 表示16位无符号整型
size： 16 bits
range： 0 ~ 65535
uint32： 表示32位无符号整型
size： 32 bits
range： 0 ~ 4294967295
uint64： 表示64位无符号整型
size： 64 bits
range： 0 ~ 18446744073709551615
uint ： 根据底层平台不同表示32或64位无符号整型
size ： 32位系统下是32 bits，64位系统下64 bits
range ：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。c1 与 c2 的和赋值给 cadd。c1 与 c2 的积赋值给 cmul。运行这个程序得到如下输出：
sum: (13+34i) product: (-149+191i)
byte 是 uint8 的别称 rune 是 int32 的别称
我们将在学习 string 类型时详细讨论 byte 和 rune。
在Go中字符串（String）是 byte 的集合。如果你觉得这个定义没有任何意义也没关系。我们可以暂且假定一个字符串就是一串字符的集合。在后面的教程中我们将通过一整篇的篇幅来介绍字符串的细节。
让我们写一个程序来了解字符串：
package main import ( "fmt" ) func main() { first := "Naveen" last := "Ramanathan" name := first +" "+ last fmt.Println("My name is",name) }
在上面的程序中，first 被赋值为 "Naveen"，last 被赋值为 "Ramanathan"。字符串可以通过 + 操作符连接在一起。name 被赋值为 first 、空格与 last 三者连接后的结果。上面的程序将得到如下输出：
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，将这两个类型不同的数字相加是非法的。运行这个程序将会报错：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) }
在 var j float64 = float64(i) 这一行，i 被转换为 float64，然后赋值给 j。当你尝试将 i 不进行转换直接赋值给 j时，编译器将报错。
标签：explicit import float 空格 字符串类型 work 类型转换 细节 介绍
原文地址：https://www.cnblogs.com/liuzhongchao/p/9158652.html
