一、Go基础

标识符：

	go语言中的标识符由字母数字和下划线（\_）组成，并且只能以字母和下划线（\_）开头

关键字:

	关键字是指编程语言中预先定义好的具有特殊含义的标识符。关键字和保留字都不建议用作变量名。

Go语言有25个关键字：

Go语言有37个保留字:

1、变量声明

1. 变量的来历

    程序运行过程中的数据都是保存在内存中的，我们想要在代码中操作某个数据时就要去内存上找到这个变量，但是如果我们直接在代码中通过内存地址去操作变量的话，代码的可读性会非常差而且还容易出错，所以我们就利用变量将这个数据的内存地址保存起来，以后直接通过这个变量就能在找到内存上对应的数据了。

2. 变量类型

    变量（Variable）的功能是存储数据。不同的变量保存数据类型可能会不一样。经过半个多世纪的发展，编程语言已经基本形成了一套固定的类型，常见的变量的数据类型有：整形、浮点型、布尔型等。
    
    					Go语言中的每一个变量都有自己的类型，并且变量必须经过声明才能开始使用。

3. 变量的声明

    Go语言中的变量需要声明后才能使用，同一作用域内不支持重复声明。并且Go语言的变量声明后必须使用。

   • 标准声明

     Go语言的变量声明格式为：

     var 变量名 变量类型

     变量声明以关键字var开头，变量类型放在变量的后面，行尾无需分号。

     var name string
     var age int
     var isOK bool

   • 批量声明

     每声明一个变量就需要写var关键字会比较繁琐，go语言中还支持批量变量的声明

     var(
     	a string
         b int
         c bool
         d float32
     )

   • 变量的初始化

       Go语言在声明变量的时候，会自动对变量对应的内存区域进行初始划操作。每个变量会被初始化成其类型的默认值，例如：整形和浮点类型变量的默认值为`0`。字符串变量的默认值为`空字符串`。布尔类型莫认为`false`。切片、函数、指针变量默认为`nil`。

     也可以在声明变量的时候为其指定初始值。变量初始化的标准格式如下：

     var 变量名 类型 = 表达式
     // 例
     var username string = "eric"
     var age int = 18

     也能一次初始化多个变量

     var name, age = "eric", 18

   • 类型推导

     有时候我们会将变量的类型省略，这个时候编译器会根据等号右边的值来推导变量的类型完成初始化。

     var name = "eric"
     var age = 18

   • 短变量声明

     在函数内部，可以使用跟简略的:=方式声明并初始化变量。

     package main
     import ("fmt")
     // 全局变量m
     var m = 100
     func main(){
         n := 10
         m := 200  //此处声明局部变量m
         fmt.PrintLn(m,n)
     }
     

   • 匿名变量

     在使用多重赋值的时候，如果想要忽略某个值，可以使用匿名变量（anonymous variable）。匿名变量用一个下划线_表示，例如：

     func foo() (int, string){
         return 18, "eric"
     }
     func main() {
         x,_ := foo()
         _,y := foo()
         fmt.Println("x=", x)
         fmt.Println("y=", y)
     }

     匿名变量不占命名空间，不会分配内存，所以匿名变量之间不存在重复声明。（在Lua等变编程语言里，匿名变量也被叫做哑圆变量。）

     注意事项：

     1. 函数外的每个语句都必须以关键字开始（var、const、func等）
     2. :=不能使用在函数外。
     3. _多用于占位，表示忽略值。
     4. go语言中变量声明必须使用，不适用就编译不过去
     5. 同一个作用域（{}）中不能重复声明同名的变量

2、常量

	相对于变量，常量是恒定不变的值，多用于定义程序运行期间不会改变的那些值。常量的声明和变量的声明非常类似，只是把`var`换成了`const`，常量在定义的时候必须赋值。

const pi = 3.14159275453
const e = 2.7182

	声明了`pi` `e` 这两个常量之后，在整个程序运行期间他们的值都不能再发生变化了。多个常量也可以一起声明：

const(
	pi = 3.14159275453
    e = 2.7182
)

const同时声明多个常量时，如果省略了值则表示和上面一行的值相同。例如：

const(
	n1 = 100
    n2
    n3
)
// n1,n2,n3的值都是100

3、iota

使用_跳过某些值

const(
	n1 = iote // 第一次默认为0
    n2        // 1
    _
    n4        //3
)

iota声明中间插队

const(
	n1 = iota // 0
    n2 = 100  // 100
    n3 = iota // 2
    n4        // 3
)
const n5 = iota // 0

	定义数量级（这里的`<<`表示左移操作，`1<<10`表示将1的二进制向左移10位，也就是由`1`变成了`10000000000`，也就是十进制的1024。同理`2<<2`表示将2的二进制向左移2位，也就是由`10`变成了`1000`，也就是十进制的8。）

const(
	_ = iota
    KB = 1<<(10*iota)
    MB = 1<<(10*iota)
    GB = 1<<(10*iota)
    TB = 1<<(10*iota)
    PB = 1<<(10*iota)
)

多个iota定义在一行

const(
	a, b = iota + 1, iota + 2  // 1,2
    c, d                       // 2,3
    e, f                       // 3,4
)

4、fmt格式化

package main 
// fmt占位符
func main(){
    var n = 100
    // 查看类型
    fmt.Printf("%T\n", n)  // 查看数据类型
    fmt.Printf("%v\n", n)  // 查看变量值
    fmt.Printf("%b\n", n)  // 二进制
    fmt.Printf("%d\n", n)  // 十进制
    fmt.Printf("%o\n", n)  // 八进制
    fmt.Printf("%x\n", n)  // 十六进制
    var s = "word"
    fmt.Printf("%s\n", s)  // 字符串 word  不会体现类型
    fmt.Printf("%v\n", s)  // 字符串 word  不会体现类型
    fmt.Printf("%v#\n", s)  // 字符串 "word"  体现出了具类型
}

二、Go的基本数据类型

	Go语言中有丰富的数据类型，除了基本的整形、浮点型、布尔型、字符串外，还有数组、切片、结构体、函数、map、通道（channel）等。Go语言的基本数据类型和其它语言大同小异。

1、整形

基本整形

整形分为以下两个大类：

• 按长度分为：int8、int16、int32、int64
• 对应的无符号整形：uint8、uint16、uint32、uint64

其中，uint8是我们常用和熟知的byte型，int16对应C语言中的shot型（C：短整型），int64对应C语言中的long型（C：长整型）。

特殊整形

注意： 在使用int和 uint类型时，不能假定它是32位或64位的整型，而是考虑int和uint可能在不同平台上的差异。

注意事项：获取对象的长度的内建len()函数返回值的长度可以根据不同平台的字节长度进行变化。实际使用中，切片或map的元素数量等都可以用int来表示。在涉及到二进制传输、读写文件的结构描述时，为了保持文件的结构不会受到不同编译目标平台的字节长度影响，不要使用int和uint。

数字字面量语法（Number literals syntax）

Go1.13版本之后引入了数字字面量语法，这样便于开发者以二进制、八进制或十六进制浮点数的格式定义数字，例如：v:=0b001101101，代表二进制的101101，相当于十进制的45。v:=0o377，代表八进制的377，相当于十进制的255。v:=0x1p-2，代表十六进制的1除以2²，也就是0.25。

package main
 
import "fmt"
 
func main(){
	// 十进制
	var a int = 10
	fmt.Printf("%d \n", a)  // 10
	fmt.Printf("%b \n", a)  // 1010  占位符%b表示二进制
 
	// 八进制  以0开头
	var b int = 077
	fmt.Printf("%o \n", b)  // 77
 
	// 十六进制  以0x开头
	var c int = 0xff
	fmt.Printf("%x \n", c)  // ff
	fmt.Printf("%X \n", c)  // FF
}

2、浮点型

Go语言中有两种浮点型数：float32和float64。这两种浮点型数据格式遵循IEEE 754标准：flaot32的浮点最大范围约为1.8e308，可以使用一个常量定义：mathMaxFloat64。

打印浮点数时，可以使用fmt包配合动词%f，代码示例：

package main
import (
    "fmt"
    "math"
)
func main() {
    fmt.Printf("%f\n", math.Pi)
    fmt.Printf("%.2f\n", math.Pi)
    // 浮点数
	asd := 3.1415926
	fmt.Printf("%T\n", asd) // 默认Go语言中的小数都是float64类型
	asf := float32(3.14159)
	fmt.Printf("%T\n", asf) // 显示声明float32类型
	// asd = asf  // float32类型的值不能直接赋值给float64，反之也不行。
}

3、复数

两种数据类型complate64和complate128

package main
import (
    "fmt"
    "math"
)
func main() {
    var c1 complex64
    c1 = 1 + 2i
    var c2 complex128
    c2 = 2 + 3i
    fmt.Println(c1)
    fmt.Println(c2)
}

4、布尔值

Go语言中以bool类型进行声明布尔类型数据，布尔类型数据只有true(真)和falde(假)两个值。

注意：

1. 布尔类型变量的默认值为false。
2. Go语言中不允许将整形强制转换为布尔型。
3. 布尔型无法参予数值运算，也无法与其它类型进行转换。

5、字符串

注：字符串默认不可修改

Go语言中的字符串以原生数据类型出现，使用字符串就像使用其他原生数据类型（int、bool、float32、float64等）一样。Go语言里的字符串的内部实现使用UTF-8编码。字符串的值为双引号(")中的内容，可以在Go语言的源码中直接添加非ASCII码字符，例如：

s1 := "hello"
s2 := "你好"

字符串转义符

Go语言的字符串常见转义符包含回车、换行、单双引号、制表符等，如下表格所示。

举个例子，我们要打印一个Windows平台下的一个文件路径：

package main
import (
    "fmt"
)
func main() {
    str := "\"c:\\User\\AppDate\\.go\""
    fmt.Println(str)  // 双引号需要转换
    fmt.Println(`c:\User\AppDate\.go\`)  // 反引号原样输出
}

多行字符串

Go语言中要定义一个多行字符串时，就必须使用反引号字符：

package main
import (
    "fmt"
)
func main() {
	asd := `第一行
第二行
第三行`
	fmt.Println(asd)
}

反引号间换行将被作为字符串中的换行，但是所有的转义字符均无效，文本将会原样输出。

字符串的常用操作

具体示例：

byte和rune类型

组成每个字符串的元素叫做“字符“，可以通过遍历或者单个获取字符串元素获得字符。字符用单引号（''）包裹起来，像：

var a = '汉'
var b = 'x'

Go语言的字符有以下两种：

1. unit8类型，或者叫byte型，代表了ASCII码的一个字符。
2. rune类型，代表一个utf-8字符。

当需要处理中文、日文或者其它符合字符时，需要用到rune类型。rune类型实际是一个int32。

Go使用了特殊的runne类型来处理Unicode，让基于Unicode的文本处理更为方便，也可以使用byte类型进行默认字符处理，性能和扩展性都有照顾。

示例：

// 遍历字符串
func traversalString() {
	s := "hello沙河"
	for i := 0; i < len(s); i++ { //byte
		fmt.Printf("%v(%c) ", s[i], s[i])
	}
	fmt.Println()
	for _, r := range s { //rune
		fmt.Printf("%v(%c) ", r, r)
	}
	fmt.Println()
}

输出：

104(h) 101(e) 108(l) 108(l) 111(o) 230(?) 178(2) 153() 230(?) 178(2) 179(3) 
104(h) 101(e) 108(l) 108(l) 111(o) 27801(沙) 27827(河) 

因为UTF8编码下一个中文汉字由3~4个字节组成，所以我们不能简单的按照字节去遍历一个包含中文的字符串，否则就会出现上面输出的结果。

字符串底层是一个byte数组，所以可以和[]byte类型相互转换，字符串是不能修改的，字符串是由byte字节组成，所以字符串长度是byte字节的长度。rune类型用来表示utf8字符，一个rune字符由哟个或多个byte组成。

修改字符串

要修改字符串，需要先将其转换成[]runne或[]byte，完成后再转换为string。无论哪种转换，都会重新分配内存，并复制字节数组。

package main
import (
	"fmt"
)
// 浮点数
func main() {
	asd := "Hello world"
	dsa := "欸瑞克"
	fmt.Printf("asd: %T dsa:%T\n", asd, dsa)
	asd1 := []rune(asd) // 把字符串强制转换成一个rune切片
	fmt.Printf("asd1: %T dsa:%d\n", asd1, asd1)
	fmt.Printf("asd1: %T dsa:%s\n", asd1, string(asd1)) // 把runne切片强制转换成字符串
	asd1[0] = 'h'
	fmt.Printf("asd1: %T dsa:%d\n", asd1, asd1)
	fmt.Printf("asd1: %T dsa:%s\n", asd1, string(asd1))
	asd1[0] = 'h'
	fmt.Printf("asd1: %d\n", asd1[0])
	asd2 := "H"       // string类型
	asd3 := byte('H') // byte（uint8）类型
	asd4 := "是"       // string类型
	asd5 := '是'       // rune(int32)类型
	fmt.Printf("%T %T %T %T\n", asd2, asd3, asd4, asd5)
}

6、类型转换

Go语言中只有强制类型转换，没有隐式类型转换。该语法只能在两个类型之间支持相互转换的时候使用。

强制类型转换的基本语法如下：

T(表达式)

其中，T表示要转换的类型。表达式包括变量、复杂算子和函数返回值等。

比如计算直角三角形的斜边长时使用math包的Sqrt()函数，该函数接收的是float64类型的参数，而变量a和b都是int类型的，这个时候就需要将a和b强制转换为float64类型。

func sqrtDemo() {
	var a, b = 3, 4
	var c int
	// math.Sqrt()接收的参数是float64类型，需要强制转换
	c = int(math.Sqrt(float64(a*a + b*b)))
	fmt.Println(c)
}

三、流程控制