以下是go中可用的基本类型:
-
bool
-
Numeric Types
-
int8, int16, int32, int64, int
-
uint8,uint16,uin32,uint64, uint
-
float32, float64
-
complex64, complex128
-
byte
-
rune
-
string
bool(布尔型)
一个布尔类型的值只有两种：true和false。if和for语句的条件部分都是布尔类型的值，并且==和<比较操作也会产生布尔型的值。一元操作符!对应逻辑非操作，因此!true的值为false。
布尔值可以和&&（AND）和||（OR）操作符结合，并且可能会有短路行为：如果运算符左边值已经可以确 定整个布尔表达式的值，那么运算符右边的值将不在被求值。
如下程序：
package main
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 b: false
c: false
d: true
注意：布尔值并不会隐式转换为数字值0或1，反之亦然。必须使用一个显式的if语句辅助转换。
有符号整型
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： 根据操作系统不同，表示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
在上面的程序中，a 的类型指定为 int，而 b 的类型从其初始值（95）推导。上面我们提到，int 的大小在32位系统下是32位，而在64位系统下是64位。下面让我们验证这个描述。
变量的类型可以在 Printf() 函数中通过 %T 格式化指示符（format specifier）来打印。Go的 unsafe 包中提供了一个名为 Sizeof 的方法，该方法接收一个变量并返回它的大小（byte数）。因为使用 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 bits （4bytes）。如果在64位系统上运行上面的程序那么输出会变得不同。在64位系统上，a 和 b 占 64 bits（8bytes）。
无符号整型
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时，编译器将报错。