Go 语言（Golang）基础学习笔记(一)

教程推荐:

1.Go 语言教程
2.Go语言圣经（中文版）
3.Go语言高级编程
4.Go语言中文网
5.8小时转职Golang工程师(如果你想低成本学习Go语言)

1、Hello World

package main //包声明

import "fmt" //引入包

func main() { //函数
	fmt.Println("Hello, World!") //语句 & 表达式
}

2、基础语法

<1> 字符串连接

Go 语言的字符串可以通过+ 实现：

package main //包声明

import "fmt" //引入包

func main() {
	fmt.Println("Hello, " + "World")
}

<2> 格式化字符串

package main

import (
	"fmt"
)

func main() {
	var stockCode = 123
	var endDate = "2020-12-31"
	// %d 表示整型数字，%s 表示字符串
	var url = "Code=%d&endDate=%s"
	var targetUrl = fmt.Sprintf(url, stockCode, endDate)
	fmt.Println(targetUrl)
}

3、数据类型

类型	描述	例子
布尔型	true 或者 false	var b bool = true
数字类型	整型 和浮点型	var stockCode int
字符串类型	字符序列	var endDate string

派生类型:

(a) 指针类型（Pointer）
(b) 数组类型
(c) 结构化类型(struct)
(d) Channel 类型
(e) 函数类型
(f) 切片类型
(g) 接口类型（interface）
(h) Map 类型

fmt格式占位符

fmt格式占位符

普通占位符
占位符     说明                           举例                   输出
%v      相应值的默认格式。            Printf("%v", people)   {zhangsan}，
%+v     打印结构体时，会添加字段名     Printf("%+v", people)  {Name:zhangsan}
%#v     相应值的Go语法表示            Printf("#v", people)   main.Human{Name:"zhangsan"}
%T      相应值的类型的Go语法表示       Printf("%T", people)   main.Human
%%      字面上的百分号，并非值的占位符  Printf("%%")            %

布尔占位符
占位符       说明                举例                     输出
%t          true 或 false。     Printf("%t", true)       true

整数占位符
占位符     说明                                  举例                       输出
%b      二进制表示                             Printf("%b", 5)             101
%c      相应Unicode码点所表示的字符              Printf("%c", 0x4E2D)        中
%d      十进制表示                             Printf("%d", 0x12)          18
%o      八进制表示                             Printf("%d", 10)            12
%q      单引号围绕的字符字面值，由Go语法安全地转义 Printf("%q", 0x4E2D)        '中'
%x      十六进制表示，字母形式为小写 a-f         Printf("%x", 13)             d
%X      十六进制表示，字母形式为大写 A-F         Printf("%x", 13)             D
%U      Unicode格式：U+1234，等同于 "U+%04X"   Printf("%U", 0x4E2D)         U+4E2D

4、变量

Go 语言变量名由字母、数字、下划线组成，其中首个字符不能为数字。
声明变量的一般形式是使用 var 关键字：

<1> 变量声明var

仅指定变量类型，没有初始化，则变量默认为零值。

package main
import "fmt"
func main() {
	// 声明一个变量并初始化
	var a = "go"
	fmt.Println(a)

	// 没有初始化就为零值
	var b int
	fmt.Println(b)

	// bool 零值为 false
	var c bool
	fmt.Println(c)
}

根据值自行判定变量类型:

var d = true
fmt.Println(d)

<2> 变量声明:=

package main
import "fmt"
func main() {
	str := "go"
	fmt.Println(str)
}

如果变量已经使用 var 声明过了，再使用 := 声明变量，就产生编译错误，格式：

str := "go" 相等于：var str = "go"

<3> 多变量声明

package main

import "fmt"

var x, y int
var (  // 这种因式分解关键字的写法一般用于声明全局变量
	a int
	b bool
)

var c, d int = 1, 2
var e, f = 123, "hello"

func main(){
	//这种不带声明格式的只能在函数体中出现
	g, h := 123, "hello"
	fmt.Println(x, y, a, b, c, d, e, f, g, h)
}

<4> 值类型和引用类型

所有像 int、float、bool 和 string 这些基本类型都属于值类型，使用这些类型的变量直接指向存在内存中的值：

当使用等号 = 将一个变量的值赋值给另一个变量时，如：j = i，实际上是在内存中将 i 的值进行了拷贝：

你可以通过&i 来获取变量 i 的内存地址，例如：0xf840000040（每次的地址都可能不一样）。值类型的变量的值存储在栈中。

package main

import "fmt"

func main(){
	str := "go"
	fmt.Println(str)
	fmt.Println(&str)
}

<5> 常量

【1】const

用const声明常量

const WIDTH int = 5  

【2】iota

iota是一个特殊常量，可以认为是一个可以被编译器修改的常量。

（1）默认使用

package main

import "fmt"

const (
	// 可以在const() 添加一个关键字 iota， 每行的iota都会累加1, 第一行的iota的默认值是0
	ID1  = iota  //iota = 0
	ID2   //iota = 1
	ID3  //iota = 2
)

func main() {
	fmt.Printf("ID1:%d\n", ID1)
	fmt.Printf("ID2:%d\n", ID2)
	fmt.Printf("ID3:%d\n", ID3)
}

（2）构造表达式：

package main

import "fmt"

const (
	// 可以在const() 添加一个关键字 iota， 每行的iota都会累加1, 第一行的iota的默认值是0
	ID1  = 10*iota
	ID2
	ID3
)

func main() {
	fmt.Printf("ID1:%d\n", ID1)
	fmt.Printf("ID2:%d\n", ID2)
	fmt.Printf("ID3:%d\n", ID3)
}

（3）每行累加1的特性

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

	g, h = iota * 2, iota *3  // iota = 3, g = iota * 2, h = iota * 3, g = 6, h = 9
	i, k                       // iota = 4, i = iota * 2, k = iota * 3 , i = 8, k = 12
)

iota 只能够配合const() 一起使用， iota只有在const进行累加效果。

5 、运算符

Go 语言运算符

6、条件语句

<1> if else

package main

import "fmt"

func main() {
	a := 2
	if a == 0{

	}else if a == 1{

	}else{
		fmt.Println(a)
	}
}

<2> switch

方式一:switch {}

package main

import "fmt"

func main() {
	var grade string = "B"

	switch {
	case grade == "A":
		fmt.Printf("优秀!\n")
	case grade == "B", grade == "C":
		fmt.Printf("良好\n")
	case grade == "D":
		fmt.Printf("及格\n")
	case grade == "F":
		fmt.Printf("不及格\n")
	default:
		fmt.Printf("差\n")
	}
}

方式二:switch v_name{}

package main

import "fmt"

func main() {
	var grade string = "B"

	switch grade {
	case "A":
		fmt.Printf("优秀!\n")
	case "B", "C":
		fmt.Printf("良好\n")
	case "D":
		fmt.Printf("及格\n")
	case "F":
		fmt.Printf("不及格\n")
	default:
		fmt.Printf("差\n")
	}
}

<3>select 语句

select 是 Go 中的一个控制结构，类似于用于通信的 switch 语句。每个 case 必须是一个通信操作，要么是发送要么是接收。

select 随机执行一个可运行的 case。如果没有 case 可运行，它将阻塞，直到有 case 可运行。一个默认的子句应该总是可运行的。

7、循环语句

package main

import (
	"fmt"
	"strconv"
)

func main() {
	for i :=0;i<10;i++  {
		fmt.Printf(strconv.Itoa(i))
	}
}

8、函数

<1> 函数定义

package main

import "fmt"

func main() {
	/* 定义局部变量 */
	var a int = 100
	var b int = 200
	var ret int

	/* 调用函数并返回最大值 */
	ret = max(a, b)

	fmt.Printf( "最大值是 : %d\n", ret )
}

/* 函数返回两个数的最大值 */
func max(num1, num2 int) int {
	/* 定义局部变量 */
	var result int

	if num1 > num2 {
		result = num1
	} else {
		result = num2
	}
	return result
}

<2> 函数返回多个值:

package main

import "fmt"
// (x, y string) : 要传入的参数及类型
// (string, string) : 要返回的类型
func swap(x, y string) (string, string) {
	return y, x
}

func main() {
	a, b := swap("Google", "Runoob")
	fmt.Println(a, b)
}

<3> 函数的多返回值三种写法

【1】匿名的返回值

//返回多个返回值，匿名的
func foo2(a string, b int) (int, int) {
    //...
    return 666, 777
}

【2】有形参名称的返回值

• 返回 (r1 int, r2 int) ,此return后就不用再写了

//返回多个返回值， 有形参名称的
func foo3(a string, b int) (r1 int, r2 int) {
    //...

    //给有名称的返回值变量赋值
    r1 = 1000
    r2 = 2000
 
    return
}

返回值的类型相返回值还可以这样写

//返回多个返回值， 有形参名称的
func foo3(a string, b int) (r1 , r2  int) {
    //...

    //给有名称的返回值变量赋值
    r1 = 1000
    r2 = 2000
 
    return
}

当然 传入参数值的类型相返回值也可以这样写

//返回多个返回值， 有形参名称的
func foo3(a , b int) (r1 , r2  int) {
    //...

    //给有名称的返回值变量赋值
    r1 = 1000
    r2 = 2000
 
    return
}

<3>函数参数

函数如果使用参数，该变量可称为函数的形参。形参就像定义在函数体内的局部变量。调用函数，可以通过两种方式来传递参数：

传递类型	描述
值传递	值传递是指在调用函数时将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数。
引用传递(传地址)	引用传递是指在调用函数时将实际参数的地址传递到函数中，那么在函数中对参数所进行的修改，将影响到实际参数。

引用传递:

package main

import "fmt"

func main() {
	/* 定义局部变量 */
	var a int = 100
	var b int= 200

	fmt.Printf("交换前，a 的值 : %d\n", a )
	fmt.Printf("交换前，b 的值 : %d\n", b )

	/* 调用 swap() 函数 交换地址
	 * &a 指向 a 指针，a 变量的地址
	 * &b 指向 b 指针，b 变量的地址
	 */
	swap(&a, &b)

	fmt.Printf("交换后，a 的值 : %d\n", a )
	fmt.Printf("交换后，b 的值 : %d\n", b )
}

func swap(x *int, y *int) {
	var temp int
	temp = *x    /* 保存 x 地址上的值 */
	*x = *y      /* 将 y 值赋给 x */
	*y = temp    /* 将 temp 值赋给 y */
}

<4> 函数用法

函数用法	描述
函数作为另外一个函数的实参	函数定义后可作为另外一个函数的实参数传入
闭包	闭包是匿名函数，可在动态编程中使用
方法	方法就是一个包含了接受者的函数

[1] 函数作为另外一个函数的实参

package main

import (
	"fmt"
	"math"
)

func main(){
	/* 声明函数变量 */
	getSquareRoot := func(x float64) float64 {
		return math.Sqrt(x)
	}

	/* 使用函数 */
	fmt.Println(getSquareRoot(9))

}

[2] 闭包

Go 语言支持匿名函数，可作为闭包。匿名函数是一个"内联"语句或表达式。匿名函数的优越性在于可以直接使用函数内的变量，不必申明。

package main

import "fmt"

func getSequence() func() int {
	i:=0
	return func() int {
		i+=1
		return i
	}
}

func main(){
	/* nextNumber 为一个函数，函数 i 为 0 */
	nextNumber1 := getSequence()

	/* 调用 nextNumber 函数，i 变量自增 1 并返回 */
	fmt.Println(nextNumber1()) // 输出 1
	fmt.Println(nextNumber1()) // 输出 2
	fmt.Println(nextNumber1()) // 输出 3

	/* 创建新的函数 nextNumber1，并查看结果 */
	nextNumber2 := getSequence()
	fmt.Println(nextNumber2()) // 输出 1
	fmt.Println(nextNumber2()) // 输出 2
}

[3] 方法

Go 语言中同时有函数和方法。一个方法就是一个包含了接受者的函数，接受者可以是命名类型或者结构体类型的一个值或者是一个指针。

package main

import (
	"fmt"
)

// Circle  定义结构体 
type Circle struct {
	radius float64
}

func main() {
	var c1 Circle
	c1.radius = 10.00
	fmt.Println("圆的面积 = ", c1.getArea())
}

//该 method 属于 Circle 类型对象中的方法
func (c Circle) getArea() float64 {
	//c.radius 即为 Circle 类型对象中的属性
	return 3.14 * c.radius * c.radius
}

9、数组

<1> 初始化固定长度数组

var n [10]int /* n 是一个长度为 10 的数组 */

var balance = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
var balance = [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

//  将索引为 1 和 3 的元素初始化
balance := [5]float32{1:2.0,3:7.0}

package main

import "fmt"

func main() {
	var n [10]int /* n 是一个长度为 10 的数组 */
	var i,j int

	/* 为数组 n 初始化元素 */
	for i = 0; i < 10; i++ {
		n[i] = i + 100 /* 设置元素为 i + 100 */
	}

	/* 输出每个数组元素的值 */
	for j = 0; j < 10; j++ {
		fmt.Printf("Element[%d] = %d\n", j, n[j] )
	}
}

<2> 编历方式

for i = 0; i < 10; i++ {
	fmt.Println("index = ", i, ", value = ", myArray[i])
}

for index, value := range myArray {
	fmt.Println("index = ", index, ", value = ", value)
}

_ 表示匿名变量

for _, value := range myArray {
	fmt.Println("index = ", index, ", value = ", value)
}

<3> 固定长度数组传参

package main

import "fmt"

func printData(arr [12]int){
	fmt.Println(arr)
}

func main() {
	myArray := [12]int{1,2,4,5}
	printData(myArray)
}

若长度不匹配则报错

所以此时最用动态数组。

<4> 动态数组

动态数组其实就是切片,请看12、Go 语言切片(Slice)

package main

import "fmt"

func printData(arr []int){
	fmt.Println(arr)
}

func main() {
	myArray := []int{1,2,4,5}
	printData(myArray)
}

10、 指针

<1> 指针定义

一个指针变量指向了一个值的内存地址。

package main

import "fmt"

func main() {
	var a int= 20   /* 声明实际变量 */
	var ip *int        /* 声明指针变量 */

	ip = &a  /* ip的值赋为a的存储地址 */

	fmt.Printf("a 变量的值: %d\n", a)

	fmt.Printf("a 变量的地址是: %x\n", &a  )

	/* 指针变量的存储地址 */
	fmt.Printf("ip 变量的值: %x\n", ip )

	/* 使用指针访问值 */
	fmt.Printf("*ip 变量的值: %d\n", *ip )
}

空指针:当一个指针被定义后没有分配到任何变量时，它的值为 nil。
nil 指针也称为空指针。
nil在概念上和其它语言的null、None、nil、NULL一样，都指代零值或空值。
一个指针变量通常缩写为 ptr。
空指针判断：

if(ptr != nil)     /* ptr 不是空指针 */
if(ptr == nil)    /* ptr 是空指针 */

<2> 指向指针的指针

如果一个指针变量存放的又是另一个指针变量的地址，则称这个指针变量为指向指针的指针变量。

当定义一个指向指针的指针变量时，第一个指针存放第二个指针的地址，第二个指针存放变量的地址：

指向指针的指针变量声明格式如下：

var ptr **int;

package main

import "fmt"

func main() {
	var a int
	var ptr *int
	var pptr **int

	a = 3000
	ptr = &a
	pptr = &ptr

	fmt.Printf("a = %d\n", a)
	fmt.Printf("ptr = %d\n", ptr)
	fmt.Printf("*ptr = %d\n", *ptr)
	fmt.Printf("pptr = %d\n", pptr)
	fmt.Printf("*pptr = %d\n", *pptr)
	fmt.Printf("**pptr = %d\n", **pptr)
}

<3> 指针作为函数参数

package main

import "fmt"

func main() {
	/* 定义局部变量 */
	var a int = 100
	var b int= 200

	fmt.Printf("交换前 a 的值 : %d\n", a )
	fmt.Printf("交换前 b 的值 : %d\n", b )

	/* 调用函数用于交换值
	 * &a 指向 a 变量的地址
	 * &b 指向 b 变量的地址
	 */
	swap(&a, &b);

	fmt.Printf("交换后 a 的值 : %d\n", a )
	fmt.Printf("交换后 b 的值 : %d\n", b )
}

func swap(x *int, y *int) {
	var temp int
	temp = *x    /* 保存 x 地址的值 */
	*x = *y      /* 将 y 赋值给 x */
	*y = temp    /* 将 temp 赋值给 y */
}

11、 结构体(struct)

声明一种行的数据类型 myint， 是int的一个别名

type myint int

<1> 定义一个结构体

package main

import "fmt"

// Books 定义一个结构体
type Books struct {
	title   string
	author  string
	subject string
	bookId int
}

func main() {

	// 创建一个新的结构体
	book1 := Books{"Go 语言", "www.runoob.com", "Go 语言教程", 6495407}
	fmt.Println(book1)

	// 也可以使用 key => value 格式
	book2 := Books{title: "Go 语言", author: "www.runoob.com", subject: "Go 语言教程", bookId: 6495407}
	fmt.Println(book2)

	// 忽略的字段为 0 或 空
	book3 := Books{title: "Go 语言", author: "www.runoob.com"}
	fmt.Println(book3)
}

<2> 访问结构体成员

package main

import "fmt"

type Books struct {
	title string
	author string
	subject string
	bookId int
}

func main() {
	var Book1 Books        /* 声明 Book1 为 Books 类型 */
	var Book2 Books        /* 声明 Book2 为 Books 类型 */

	/* book1.描述 */
	Book1.title = "Go 语言"
	Book1.author = "www.runoob.com"
	Book1.subject = "Go 语言教程"
	Book1.bookId = 6495407

	/* book2.描述 */
	Book2.title = "Python 教程"
	Book2.author = "www.runoob.com"
	Book2.subject = "Python 语言教程"
	Book2.bookId = 6495700

	/* 打印 Book1 信息 */
	fmt.Printf( "Book1.title : %s\n", Book1.title)
	fmt.Printf( "Book1.author : %s\n", Book1.author)
	fmt.Printf( "Book1.subject : %s\n", Book1.subject)
	fmt.Printf( "Book1.bookId : %d\n", Book1.bookId)

	/* 打印 Book2 信息 */
	fmt.Printf( "Book2.title : %s\n", Book2.title)
	fmt.Printf( "Book2.author : %s\n", Book2.author)
	fmt.Printf( "Book2.subject : %s\n", Book2.subject)
	fmt.Printf( "Book2.bookId : %d\n", Book2.bookId)
}

<3> 结构体作为函数参数

package main

import "fmt"

type Books struct {
	title string
	author string
	subject string
	book_id int
}

func main() {
	var Book1 Books        /* 声明 Book1 为 Books 类型 */

	/* book 1 描述 */
	Book1.title = "Go 语言"
	Book1.author = "www.runoob.com"
	Book1.subject = "Go 语言教程"
	Book1.book_id = 6495407

	/* 打印 Book1 信息 */
	printBook(Book1)
}

func printBook( book Books ) {
	fmt.Printf( "Book title : %s\n", book.title)
	fmt.Printf( "Book author : %s\n", book.author)
	fmt.Printf( "Book subject : %s\n", book.subject)
	fmt.Printf( "Book book_id : %d\n", book.book_id)
}

<3> 结构体指针

package main

import "fmt"

type Books struct {
	title string
	author string
	subject string
	book_id int
}

func main() {
	var Book1 Books        /* 声明 Book1 为 Books 类型 */

	/* book 1 描述 */
	Book1.title = "Go 语言"
	Book1.author = "www.runoob.com"
	Book1.subject = "Go 语言教程"
	Book1.book_id = 6495407

	/* 打印 Book1 信息 */
	printBook(&Book1)
}
func printBook( book *Books ) {
	fmt.Printf( "Book title : %s\n", book.title)
	fmt.Printf( "Book author : %s\n", book.author)
	fmt.Printf( "Book subject : %s\n", book.subject)
	fmt.Printf( "Book book_id : %d\n", book.book_id)
}

12、Go 语言切片(Slice)

Go 语言切片是对数组的抽象。

Go 数组的长度不可改变，在特定场景中这样的集合就不太适用，Go 中提供了一种灵活，功能强悍的内置类型切片(“动态数组”)，与数组相比切片的长度是不固定的，可以追加元素，在追加时可能使切片的容量增大。

<1> 切片初始化

声明一个未指定大小的数组来定义切片：

数组初始化:

array := [3]int {1,2,3 }

切片初始化:

slice := []int {1,2,3 } 

直接初始化切片，[] 表示是切片类型，{1,2,3} 初始化值依次是 1,2,3，其 cap=len=3。

【1】slice切片的4种声明定义方式

slice := []int {1,2,3 } 

2&3.切片不需要说明长度。或使用make() 函数(开辟空间)来创建切片:

var slice1 []type = make([]type, len)
也可以简写为
slice1 := make([]type, len)

3.也可以指定容量，其中 capacity 为可选参数。

make([]T, length, capacity)

<2>切片：把数组切成片

slice:= array[startIndex:endIndex] 

package main

import "fmt"

func main() {
	array := [5]int {1,2,3,4,5}

	slice := array[1:4]
	fmt.Println(slice)
}

<3> len() 和 cap() 函数

• 切片是可索引的，并且可以由 len()方法获取长度。

• 切片提供了计算容量的方法cap() 可以测量切片最长可以达到多少。

package main

import "fmt"

func main() {
	arrayInt := []int{1,2,3,4}
	fmt.Printf("len=%d cap=%d slice=%v\n",len(arrayInt),cap(arrayInt),arrayInt)
}

<4> 空(nil)切片

package main

import "fmt"

func main() {
	var numbers []int

	if numbers == nil {
		fmt.Printf("切片是空的")
	}
}

<5> 切片截取

package main

import "fmt"

func main() {
	arrayInt := [] int {0,1,2,3,4,5,6}

	fmt.Println(arrayInt[1:4])
	//[:4] => [0:4]
	fmt.Println(arrayInt[:4])
	// [1:] => [1:len(arrayInt)]
	fmt.Println(arrayInt[1:])
}

<6> append() 和 copy() 函数

package main

import "fmt"

func main() {
	var numbers []int
	printSlice(numbers)

	/* 允许追加空切片 */
	numbers = append(numbers, 0)
	printSlice(numbers)

	/* 向切片添加一个元素 */
	numbers = append(numbers, 1)
	printSlice(numbers)

	/* 同时添加多个元素 */
	numbers = append(numbers, 2,3,4)
	printSlice(numbers)

	/* 创建切片 numbers1 是之前切片的两倍容量*/
	numbers1 := make([]int, len(numbers), (cap(numbers))*2)

	/* 拷贝 numbers 的内容到 numbers1 */
	copy(numbers1,numbers)
	printSlice(numbers1)
}

func printSlice(x []int){
	fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

13、范围(Range)

Go 语言中 range 关键字用于 for 循环中迭代数组(array)、切片(slice)、通道(channel)或集合(map)的元素。在数组和切片中它返回元素的索引和索引对应的值，在集合中返回 key-value 对。

package main
import "fmt"
func main() {
	//这是我们使用range去求一个slice的和。使用数组跟这个很类似
	nums := []int{2, 3, 4}
	sum := 0
	//我们不需要使用该元素的序号，所以我们使用空白符"_"省略了
	for _, num := range nums {
		sum += num
	}
	fmt.Println("sum:", sum)
	//在数组上使用range将传入index和值两个变量。
	for i, num := range nums {
		if num == 3 {
			fmt.Println("index:", i)
		}
	}
	//range也可以用在map的键值对上。
	kvs := map[string]string{"a": "apple", "b": "banana"}
	for k, v := range kvs {
		fmt.Printf("%s -> %s\n", k, v)
	}
	//range也可以用来枚举Unicode字符串。第一个参数是字符的索引，第二个是字符（Unicode的值）本身。
	for i, c := range "go" {
		fmt.Println(i, c)
	}
}

13、Map(键值对集合)

Map 是一种无序的键值对的集合。Map 最重要的一点是通过 key 来快速检索数据，key 类似于索引，指向数据的值。

Map 是一种集合，所以我们可以像迭代数组和切片那样迭代它。不过，Map 是无序的，我们无法决定它的返回顺序，这是因为 Map 是使用 hash 表来实现的。

<1> 定义 Map

可以使用内建函数 make 也可以使用 map 关键字来定义 Map:
一般都要初始化值或用make开辟空间,开辟空间少了空间也会自动增

【1】仅声明map：

如果不初始化 map，那么就会创建一个 nil map。nil map 不能用来存放键值对,一般都要初始化值或用make开辟空间

// 声明变量，默认 map 是 nil 
var myMapName map[键的数据类型]值的数据类型
var myMap map[string]string

【2】声明并初始化map：

 myMap3 := map[string]string{
	"one":   "php",
	"two":   "c++",
	"three": "python",
}

【3】用make开辟空间：

// 使用 make 函数,
myMapName := make(map[键的数据类型]值的数据类型)
myMap := make(map[string]string)

myMap := make(map[string]string,len)
myMap := make(map[string]string,10)

<2> 通历Map

package main

import "fmt"

func main() {
	capitalMap := make(map[string]string)

	/* map插入key - value对,各个国家对应的首都 */
	capitalMap [ "France" ] = "巴黎"
	capitalMap [ "Italy" ] = "罗马"
	capitalMap [ "Japan" ] = "东京"
	capitalMap [ "India " ] = "新德里"

	/*使用键输出地图值 */
	for key,value := range capitalMap {
		fmt.Println(key, "首都是", value)
	}
}

<3> 增删改查 和 delete() 函数

//增
capitalMap[ "France" ] = "巴黎"

//删
delete(countryCapitalMap, "France")

//改
capitalMap[ "France" ] = "巴黎2"

//查
fmt.Println(capitalMap[ "France" ])

delete() 函数：

package main

import "fmt"

func main() {
	/* 创建map */
	countryCapitalMap := map[string]string{"France": "Paris", "Italy": "Rome", "Japan": "Tokyo", "India": "New delhi"}

	fmt.Println("原始地图")

	/* 打印地图 */
	for country := range countryCapitalMap {
		fmt.Println(country, "首都是", countryCapitalMap [ country ])
	}

	/*删除元素*/ 
	delete(countryCapitalMap, "France")
	fmt.Println("法国条目被删除")

	fmt.Println("删除元素后地图")

	/*打印地图*/
	for country := range countryCapitalMap {
		fmt.Println(country, "首都是", countryCapitalMap [ country ])
	}
}

<4> 引用传递

package main

import "fmt"

func ChangeValue(cityMap map[string]string) {
	cityMap["France"] = "巴黎2"
}

func main() {
	capitalMap := make(map[string]string)
	/* map插入key - value对,各个国家对应的首都 */
	capitalMap [ "France" ] = "巴黎"
	capitalMap [ "Italy" ] = "罗马"
	capitalMap [ "Japan" ] = "东京"
	capitalMap [ "India " ] = "新德里"

	ChangeValue(capitalMap)

	fmt.Println(capitalMap)
}

14、 递归函数

递归，就是在运行的过程中调用自己。

<1> 阶乘

package main

import "fmt"

func Factorial(n uint64)(result uint64) {
	if n > 0 {
		result = n * Factorial(n-1)
		return result
	}
	return 1
}

func main() {
	var i int = 3
	fmt.Printf("%d 的阶乘是 %d\n", i, Factorial(uint64(i)))
}

<2> 斐波那契数列

package main

import "fmt"

func fibonacci(n int) int {
	if n < 2 {
		return n
	}
	return fibonacci(n-2) + fibonacci(n-1)
}

func main() {
	var i int
	for i = 0; i < 10; i++ {
		fmt.Printf("%d\t", fibonacci(i))
	}
}

15 类型转换

类型转换用于将一种数据类型的变量转换为另外一种类型的变量。
go 不支持隐式转换类型

package main

import "fmt"

func main() {
	var sum int = 17
	var count int = 5
	var mean float32

	mean = float32(sum)/float32(count)
	fmt.Printf("mean 的值为: %f\n",mean)
}

16、接口

Go 语言提供了另外一种数据类型即接口，它把所有的具有共性的方法定义在一起，任何其他类型只要实现了这些方法就是实现了这个接口。

定义接口

package main

import (
	"fmt"
)
// NokiaPhone 定义一个结构体
type NokiaPhone struct {
}
// IPhone 定义一个结构体
type IPhone struct {
}

// Phone 定义了一个接口Phone
type Phone interface {
	call()
}

func (nokiaPhone NokiaPhone) call() {
	fmt.Println("This is NokiaPhone!")
}

func (iPhone IPhone) call() {
	fmt.Println("This is IPhone!")
}

func main() {
	var phone Phone

	//根据传入参数的类型调用不同的方法
	phone = new(NokiaPhone)
	phone.call()

	phone = new(IPhone)
	phone.call()

}

17、错误处理

Go 语言通过内置的错误接口提供了非常简单的错误处理机制。
error类型是一个接口类型，这是它的定义：

type error interface {
    Error() string
}

我们可以在编码中通过实现 error 接口类型来生成错误信息。

函数通常在最后的返回值中返回错误信息。使用errors.New 可返回一个错误信息：

func Sqrt(f float64) (float64, error) {
    if f < 0 {
        return 0, errors.New("math: square root of negative number")
    }
    // 实现
}

实例:

package main

import (
	"fmt"
)

// DivideError 定义一个 DivideError 结构
type DivideError struct {
	dividee int
	divider int
}

// 实现 `error` 接口
func (de *DivideError) Error() string {
	strFormat := `
    Cannot proceed, the divider is zero.
    dividee: %d
    divider: 0
`
	return fmt.Sprintf(strFormat, de.dividee)
}

// Divide 定义 `int` 类型除法运算的函数
func Divide(varDividee int, varDivider int) (result int, errorMsg string) {
	if varDivider == 0 {
		dData := DivideError{
			dividee: varDividee,
			divider: varDivider,
		}
		errorMsg = dData.Error()
		return
	} else {
		return varDividee / varDivider, ""
	}

}

func main() {

	// 正常情况
	if result, errorMsg := Divide(100, 10); errorMsg == "" {
		fmt.Println("100/10 = ", result)
	}
	// 当除数为零的时候会返回错误信息
	if _, errorMsg := Divide(100, 0); errorMsg != "" {
		fmt.Println("errorMsg is: ", errorMsg)
	}

}

18 、并发

<1> go 函数并发

并发:并行出发、并行执行
Go 语言支持并发，我们只需要通过 go 关键字来开启 goroutine 即可。
goroutine 是轻量级线程，goroutine 的调度是由 Golang 运行时进行管理的。
goroutine 语法格式：

go 函数名( 参数列表 )

Go 允许使用 go 语句开启一个新的运行期线程， 即 goroutine，以一个不同的、新创建的 goroutine 来执行一个函数。 同一个程序中的所有 goroutine 共享同一个地址空间。

package main

import (
        "fmt"
        "time"
)

func say(s string) {
        for i := 0; i < 5; i++ {
                time.Sleep(100 * time.Millisecond)
                fmt.Println(s)
        }
}

func main() {
        go say("world")
        say("hello")
}

执行以上代码，你会看到输出的 hello 和 world 是没有固定先后顺序。因为它们是两个 goroutine 在执行：

package main

import (
	"fmt"
	"time"
)

func say(s string) {
	for i := 0; i < 5; i++ {
		time.Sleep(100 * time.Millisecond)
		fmt.Println(s)
	}
}

func main() {
	//并发
	go say("new 1")
	say("new 2")
}

<2> 通道（channel）

通道（channel）是用来传递数据的一个数据结构。
通道可用于两个 goroutine(线程) 之间通过传递一个指定类型的值来同步运行和通讯。操作符 <- 用于指定通道的方向，发送或接收。如果未指定方向，则为双向通道。

ch <- v    // 把 v 发送到通道 ch
v := <-ch  // 从 ch 接收数据,并把值赋给 v

【1】定义通道

定义一个通道很简单，我们使用chan关键字即可，通道在使用前必须先创建：

ch := make(chan int)

注意：默认情况下，通道是不带缓冲区的。发送端发送数据，同时必须有接收端相应的接收数据。

以下实例通过两个 goroutine(线程) 来计算数字之和，在 goroutine(线程) 完成计算后，它会计算两个结果的和：

package main

import "fmt"

func sum(s []int, c chan int) {
        sum := 0
        for _, v := range s {
                sum += v
        }
        c <- sum // 把 sum 发送到通道 c
}

func main() {
        s := []int{7, 2, 8, -9, 4, 0}

        c := make(chan int)
        go sum(s[:len(s)/2], c)
        go sum(s[len(s)/2:], c)
        x, y := <-c, <-c // 从通道 c 中接收

        fmt.Println(x, y, x+y)
}