1. bool (Boolean);
2. Numerische Typen:
int8, int32, int64, int
uint8, uint16, uint32, uint64, uint
float32, float64
complex64, complex128
byte, rune
3, string (string);
bool
bool-Typ steht für Boolean Wert, nur zwei Werte: wahr oder falsch.
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)
}Nach dem Login kopieren
Execute [1]
Im obigen Code werden a und b jeweils true und false zugewiesen. Das Ergebnis von
a && b wird c zugewiesen. Der &&-Operator gibt nur dann true zurück, wenn a und b beide true sind, sodass der Wert von c false ist.
Solange entweder a oder b wahr ist, gibt der ||-Operator wahr zurück, sodass der Wert von d hier wahr ist.
Die obige Codeausgabe:
a: true b: false
c: false
d: true
Nach dem Login kopieren
vorzeichenbehaftete Ganzzahl
int8: 8-Bit-Ganzzahl mit Vorzeichen
Größe: 8-Bit
Bereich: -128 ~ 127
int16: 16-Bit-Ganzzahl mit Vorzeichen Typ
Größe: 16 Bit
Bereich: -32768 ~ 32767
int32: 32 位有符号整型
size: 32 位
范围: -2147483648 ~ 2147483647
int64: 64 位有符号整型
size: 64 位
范围: -9223372036854775808 ~ 9223372036854775807
int: int 表示 32 或 64 位整型，具体位数取决于机器位数，除非需要使用特定大小的整数，否则通常使用 int 来表示整数
size: 32 位系统上为 32 位，64 位系统上为 64 位；
范围: 32 位系统 -2147483648 to 2147483647，64 位系统 -9223372036854775808 to 9223372036854775807
package main
import "fmt"
func main() {
var a int = 89
b := 95
fmt.Println("value of a is", a, "and b is", b)
}Nach dem Login kopieren
执行[2]
输出：value of a is 89 and b is 95.
上面的代码中，a 显式地声明为 int 类型，从赋给 b 的值来看，b 也是 int 类型。从上面我们知道，int 类型在 32 位系统上为 32 bit，在 64 位系统上是 64 bit。
我们一起来验证下。
变量的类型可以使用 Printf() 函数和 %T 格式化输出。Sizeof() 函数是 unsafe 包里的函数，它以字节为单位返回变量的大小。应该小心使用 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
}Nach dem Login kopieren
执行[3]
从上面的输出中，我们可以推断出 a 和 b 的类型是 int 并且都是 32 位大小（4 字节）。如果你是在 64 位系统上运行上述程序，输出会有所不同。在 64 位系统中，a 和 b 占用 64 位（8 字节）。
无符号整型
uint8: 8 位无符号整型
size: 8 位
范围: 0 ~ 255
uint16: 16 位无符号整型
size: 16 位
范围: 0 ~ 65535
uint32: 32 位无符号整型
size: 32 位
范围: 0 ~ 4294967295
uint64: 64 位无符号整型
size: 64 位
范围: 0 ~ 18446744073709551615
uint : 32 位或 64 位无符号整型，具体位数取决于系统位数
size : 32 位或 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)
}Nach dem Login kopieren
执行[4]
上面的代码，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
Nach dem Login kopieren
复数
complex64:由 float32 类型的实部和虚部组成的复数。complex128:由 float64 类型的实部和虚部组成的复数。
内置函数 complex() 根据给定的实数和虚数创建复数，该函数定义如下：
func complex(r, i FloatType) ComplexType
Nach dem Login kopieren
实部和虚部分别作为参数，返回一个复数。实部和虚部必须是同种类型，float32 或 float64。如果实部和虚部都是 float32，则返回类型为 complex64 的复数；如果实部和虚部都是 float64，则返回 complex128 类型的复数。
短变量声明也可以创建复数：
c := 6 + 7i
Nach dem Login kopieren
我们一起来看个 demo：
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)
}Nach dem Login kopieren
执行[5]
上面的代码中，c1 和 c2 是两个复数，c1 的实部是 5、虚部是 7。c2 的实部是 8、虚部是 27。c1 和 c2 相加之和赋给 cadd，乘积赋给 cmul，程序输出如下：
sum: (13+34i)
product: (-149+191i)
Nach dem Login kopieren
其他数值类型
byte 是 uint8 的别名，rune 是 int32 的别名。我们将在后面的章节展开讲解这两个概念。
字符串
Go 语言里面，字符串可以理解成是 byte（字节）的集合。
我们用 string 编写一个程序:
package main
import (
"fmt"
)
func main() {
first := "Naveen"
last := "Ramanathan"
name := first +" "+ last
fmt.Println("My name is",name)
}Nach dem Login kopieren
执行[6]
在上面的程序中，将字符串 "Naveen" 赋给了变量 first、"Ramanathan" 赋给了变量 last。字符串可以通过 + 操作符连接，将字符串变量 first、last 以空字符相连，结果赋给变量 name。
上面的代码输出：
My name is Naveen Ramanathan
Nach dem Login kopieren
还有一些关于字符串其他的操作方法，我们将在后面的章节单独讲解。
类型转换
Go 是强类型语言，没有类型的自动提升、转换。我们来看下什么意思：
package main
import (
"fmt"
)
func main() {
i := 55 //int
j := 67.8 //float64
sum := i + j //int + float64 not allowed
fmt.Println(sum)
}Nach dem Login kopieren
执行[7]
上面的代码，i 和 j 相加在 C 语言中是完全合法的，但在 Go 语言里却是行不通的。i 是 int 类型，j 是 float64 类型，将这两个不同类型的变量相加是不允许的。
执行上面的代码会报错：./prog.go:10:11: 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)
}Nach dem Login kopieren
执行[8]
现在执行上面的程序，将会输出 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)
}Nach dem Login kopieren
执行[9]
上面代码的第 9 行，将 i 转换成 float64 然后赋值给 j，如果不经过类型转换而直接赋值，编译器将会报错。
