基本类型

• 布尔型：bool

1. 长度：1字节
2. 取值范围：true,false
3. 注意：不可以用数字代表true或false

• 整型：int/uint

1. 根据运行平台可能为32或64位

• 8位整型：int8/uint8

1. 长度：1字节
2. 取值范围 -128~127/0-255
3. PS:int是有符号，uint是无符号

• 字节型：byte (uint8别名)

• 16位整型：int16/uint16

1. 长度：2字节
2. 取值范围：-32768~32768 / 0~65535

• 32位整型：int32(rune)/uint32

1. 长度：4字节
2. 取值范围：-2^32/2 ~ 2^32/2-1 / 0~2^32-1

• 64位整型：int64/uint64

1. 长度：8字节
2. 取值范围： -2^64/2 ~ 2^64/2-1 / 0~2^64-1

• 浮点型：float32/float64

1. 长度：4/8字节
2. 小数位：精确到7/15小数位

• 复数：complex64/complex128

1. 长度8/16字节

• 足够保存指针的32位或64位整数型：uintptr

• 其它值类型

1. array、struct、string

• 引用类型

1. slice、map、chan

-** 接口类型：interface**

• 函数类型：func

1. 在go语言中函数是可以赋值给变量的，所以函数也是一种类型

类型零值

• 零值不等于空值，而是当变量被声明为某种类型后的默认值，通常情况下值得类型的默认值为0，bool为false，string为空字符串。

package main

import (
	"fmt"
)

func main() {
	var a int
	fmt.Println(a)
}
//此时打印出来的a的值是0，如果a为string类型的话，打印出来的值是空字符串，如果a为bool型的话，打印出来的值是false

类型别名

package main

import (
	"fmt"
)

type (
	文本 string
)

func main() {
	var b 文本
	b = "你好"
	fmt.Println(b)
}
//此时也是可以进行打印的，但是不建议这样使用

单个变量的声明和赋值

• 变量的声明格式： var <变量名称> <变量类型>
• 变量的赋值格式： <变量名称> = <表达式>
• 声明的同时赋值：var <变量名称> <变量类型> = <表达式>

package main

import (
	"fmt"
)

func main() {
	var b int
	b = 1         //先声明后赋值,当这个变量还没有要用，当你在后面的分支结构中可能要用到它，这个时候不能在结构中声明，在结构退出之后，你可能还需要其他的运算。
	var c int = 1 //变量声明的同时赋值，一般用在全局变量中，全局变量不能使用:=，必须进行显式的说明
	var f = 2     //不写出变量类型的区别，有可能现在是int型，你在后面进行运算是float型，这个时候用系统推断就可以保持运算的类型一致。
	d := "go"     //最简写法
	e := false
	fmt.Println(b)
	fmt.Println(c)
	fmt.Println(d)
	fmt.Println(e)
	fmt.Println(f)
}

多个变量的声明与赋值

• 全局变量的声明可以使用var()的方式进行简写
• 全局变量的声明不可以省略var，但可以使用并行的方式
• 所有变量都可以使用类型推断
• 局部变量不可以使用var()的方式简写，只能使用并行方式

package main

import (
	"fmt"
)

func main() {
	//var a, b, c, d int = 1, 2, 3, 4
	//var a, b, c, d = 1, 2, 3, 4
	//a, b, c, d := 1, 2, 3, 4
	a, _, c, d := 1, 2, 3, 4 //忽略了,应用在函数的返回值当中
	fmt.Println(a, c, d)
}

变量的类型转换

• Go中不存在隐式转换，所有的类型转换必须显式声明
• 转换只能发生在两种相互兼容的类型之间
• 类型的转换格式为如下
• 从严格意义上讲type newint int,这里newint并不能说是int的别名，而只是底层数据结构相同，在这里称之为自定义类型，在进行类型转换时仍旧需要显示转换，但是byte和rune确确实实为uint8和int32的别名，可以相互进行转换。

<Value> [:]= <TypeOfValueA>(ValueB)

package main

import (
	"fmt"
)

func main() {
	//在相互兼容的两种类型之间进行转换
	var a float32 = 100.1
	fmt.Println(a)
	b := int(a)
	fmt.Println(b)
	//以下表达式无法通过编译，因为类型不兼容
	var c bool = true
	d := int(c)
}

• string()表示将数据转换成文本格式，因为计算机中存储的任何东西本质上都是数字，因此此函数自然地认为我们需要的是用数字65表示的文本A。

package main

import (
	"fmt"
	"strconv"
)

func main() {
	var a int = 65
	b := string(a)
	c := strconv.Itoa(a)
	d := strconv.Atoi(c)
	fmt.Println(b)
	fmt.Println(c)
	fmt.Println(d)
}
//此时我们需要引用strconv的Itoa的函数，将65转换成我们想要的字符串65，如果想要逆转的话需要用Atoi函数。