库查询 https://gowalker.org/

你应该$HOME/.profile文件增加下面设置。

1搭建go的环境
2step1：去golang的官网下载go的安装包
3windows：go1.9.2.....msi
4mac：go1.9.2......pkg
5	双击傻瓜式安装
6linux：go1.9.2.linux-amd64.tar.gz
7	默认到下载目录下：
8		需要将压缩包解压到指定的目录下：/usr/local
9	命令：cd 下载
10	命令：sudo tar -xzf go1.9.2.linux-amd64.tar.gz -C /usr/local
11
12	配置环境变量：
13		GOROOT：安装的目录
14			bin目录：go命令
15
16		** GOPATH：用户编写的go的源代码的位置 **
17			src：源代码
18			pkg：编译后的包的位置
19			bin：可执行文件
20
21		默认在home/ruby/go
22				       桌面，下载，文档。。。。。

==注意: GOPATH目录必须存在src、pkg、bin文件夹==

将goroot和gopath配置到ubuntu的配置文件中：$HOME/.profile

1cd进入$HOME，
2ls -a,查看文件，包含隐藏：.profile
3使用vim编辑.profile
4	a）vi .profile,打开该文件
5	b) 输入字母i，表示进入vim的编辑模式
6	c) 将goroot，gopath配置到文件中
7		export PATH=$PATH:/usr/local/go/bin
8		export GOPATH=$HOME/go
9	d) 保存文件并退出
10		点击esc，退出编辑模式
11		输入：wq,保存并 退出
12需要让配置好的.profile文件生效
13	a)进入到/usr/local目录
14	b)执行命令：source $HOME/.profile

访问go官网需要翻墙 https://golang.org/

Go语言最主要的特性：

• 自动垃圾回收
• 更丰富的内置类型
• 函数多返回值
• 错误处理
• 匿名函数和闭包
• 类型和接口
• 并发编程
• 反射
• 语言交互性

go的源码文件分三类 命令源码文件、库源码文件、测试源码文件 命令源码文件：

1声明自己属于main代码包、包含无参数声明和结果声明的main函数
2被安装后，相应的可执行文件会被存放到GOBIN指向的目录或<当前工作区目录>/bin下
3命令源码文件是Go程序的入口，但不建议把程序都写在一个文件中

注意：同一个代码包中强烈不建议直接包含多个命令源码文件

库源码文件：

1不具备命令源码文件的那两个特征的源码文件
2被安装后，相应的归档文件会被存放到<当前工作区目录>/pkg/<平台相关目录>下

测试源码文件：

1不具备命令源码文件的那两个特征的源码文件
2名称以_test.go为后缀
3其中至少有一个函数的名称以Test或Benchmark为前缀
4并且，该函数接收一个类型为*testing.T或*testing.B的参数
5func TestFind(t*testing.T){
6    // 省略若干条语句
7}
8
9第一行代码 package main 定义了包名。你必须在源文件中非注释的第一行指明这个文件属于哪个包，如：package main。package main表示一个可独立执行的程序，每个 Go 应用程序都包含一个名为 main 的包。
10
11下一行 import "fmt" 告诉 Go 编译器这个程序需要使用 fmt 包（的函数，或其他元素），fmt 包实现了格式化 IO（输入/输出）的函数。
12
13下一行 func main() 是程序开始执行的函数。main 函数是每一个可执行程序所必须包含的，一般来说都是在启动后第一个执行的函数（如果有 init() 函数则会先执行该函数）。
14
15下一行 /*...*/ 是注释，在程序执行时将被忽略。单行注释是最常见的注释形式，你可以在任何地方使用以 // 开头的单行注释。多行注释也叫块注释，均已以 /* 开头，并以 */ 结尾，且不可以嵌套使用，多行注释一般用于包的文档描述或注释成块的代码片段。
16
17下一行 fmt.Println(...) 可以将字符串输出到控制台，并在最后自动增加换行字符 \n。
18使用 fmt.Print("hello, world\n") 可以得到相同的结果。
19Print 和 Println 这两个函数也支持使用变量，如：fmt.Println(arr)。如果没有特别指定，它们会以默认的打印格式将变量 arr 输出到控制台。
20
21当标识符（包括常量、变量、类型、函数名、结构字段等等）以一个大写字母开头，如：Group1，那么使用这种形式的标识符的对象就可以被外部包的代码所使用（客户端程序需要先导入这个包），这被称为导出（像面向对象语言中的 public）；标识符如果以小写字母开头，则对包外是不可见的，但是他们在整个包的内部是可见并且可用的（像面向对象语言中的 protected ）。

导包方式import "包名"

import . "包名"不用给包名起别名,import 别名 "包名"

只做初始化源码文件使用import _ "包名"

也可以用路径指向包import "路径/包"可以是绝对路径或者相对路径

要导入多个包使用import ("包名1" "包名2")

go run 文件名，对go源码文件编译并执行

1-a:强制编译相关代码，不论他们的编译结果是否是最新的
2-n:打印编译过程中所需运行的命令，但不真正执行他们
3-p n:并行编译，其中n为并行的数量
4-v:列出被编译的代码包的名称。如果和-a连用会打印所有代码包1.3中的所有指包含Go语言自带的标准库的代码包，1.4中的所有不包含Go语言自带的标准包
5-work:显示编译时创建的临时工作目录的路径，并且不删除它
6-x:打印编译过程中所需运行的命令,并执行

go语言关键字| | | |
---|---|---|---|--- break | default | func | interface | select case | defer | go | map | struct chan | else | goto | package | switch const | fallthrough | if | range | type continue | for | import | return | var

标识符| | | | | | | | ---|---|---|---|---|---|---|---|--- append | bool | byte | cap | close | complex | complex64| complex128 | uint16 copy | false | float32 | float64 | imag | int | int8 | int16 | uint32 int32 | int64 | iota | len | make | new | nil | panic | uint64 print | println | real | recover | string | true | uint | uint8| uintptr

占位符 https://studygolang.com/articles/2644

1println是标准输出
2printf是占位符替换输出 "%d",10

Go 语言中变量的声明必须使用空格隔开，如：

1var age int; // ;可以省略
2age := 1;

无空格：

fruit = apples + oranges; 

数据类型：

数字类型： 整型：

浮点型：

其他更多的数字类型：

1//类型相同多个变量, 非全局变量
2var vname1, vname2, vname3 type
3var vname1, vname2, vname3 = v1, v2, v3 //和python很像,不需要显示声明类型，自动推断
4
5vname1, vname2, vname3 := v1, v2, v3 //出现在:=左侧的变量不应该是已经被声明过的，否则会导致编译错误
6//这种不带声明格式的只能在函数体中出现
7
8// 这种因式分解关键字的写法一般用于声明全局变量
9var (
10    vname1 v_type1
11    vname2 v_type2
12)

==函数体内，如果有些变量不需要声明类型，单纯地赋值也是不够的，这个值必须被使用==

常量是一个简单值的标识符，在程序运行时，不会被修改的量。

常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型。

常量的定义格式：

const identifier [type] = value

常量还可以用作枚举：

1const (
2    Unknown = 0
3    Female = 1
4    Male = 2
5)

常量可以用len(), cap(),unsafe.Sizeof()函数计算表达式的值。常量表达式中，函数必须是内置函数，否则编译不过:

1package main
2
3import "unsafe"
4const (
5    a = "abc"
6    b = len(a)
7    c = unsafe.Sizeof(a)
8)
9
10func main(){
11    println(a, b, c)
12}

iota

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

在每一个const关键字出现时，被重置为0，然后再下一个const出现之前，每出现一次iota，其所代表的数字会自动增加1。

iota 可以被用作枚举值：

1const (
2    a = iota
3    b = iota
4    c = iota
5)

1package main
2
3import "fmt"
4
5const (
6	a = iota //0
7	b		 //1
8	c		 //2
9	d = "ha" //ha
10	e		 //ha
11	f = 100  //100
12	g		 //100
13	h = iota //7
14	i		 //8
15)
16
17func main()  {
18	fmt.Println(a,b,c,d,e,f,g,h,i)
19}

算术运算符

• | 相加 | A + B 输出结果 30

• | 相减 | A - B 输出结果 -10

• | 相乘 | A * B 输出结果 200 / | 相除 | B / A 输出结果 2 % | 求余 | B % A 输出结果 0 ++ | 自增 | A++ 输出结果 11 -- | 自减 | A-- 输出结果 9

关系运算符

| 检查左边值是否大于右边值，如果是返回 True 否则返回 False。 | (A > B) 为 False < | 检查左边值是否小于右边值，如果是返回 True 否则返回 False。 | (A < B) 为 True = | 检查左边值是否大于等于右边值，如果是返回 True 否则返回 False。 | (A >= B) 为 False <= | 检查左边值是否小于等于右边值，如果是返回 True 否则返回 False。 | (A <= B) 为 True

逻辑运算符 运算符 | 描述 | 实例 && | 逻辑 AND 运算符。如果两边的操作数都是 True，则条件 True，否则为 False。 | (A && B) 为 False || | 逻辑 OR 运算符。 如果两边的操作数有一个 True，则条件 True，否则为 False。 | (A || B) 为 True ! | 逻辑 NOT 运算符。 如果条件为 True，则逻辑 NOT 条件 False，否则为 True。 | !(A && B) 为 True

位运算

位运算符号

| 右移运算符">>"是双目运算符。右移n位就是除以2的n次方。 其功能是把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数。 | A >> 2 结果为 15 ，二进制为 0000 1111

赋值运算符

= | 右移后赋值 | C >>= 2 等于 C = C >> 2 &= | 按位与后赋值 | C &= 2 等于 C = C & 2 ^= | 按位异或后赋值 | C ^= 2 等于 C = C ^ 2 |= | 按位或后赋值 | C |= 2 等于 C = C | 2

其他运算符

• | 指针变量。 | *a; 是一个指针变量

运算符优先级

判断语句

以下描述了 select 语句的语法：

1每个case都必须是一个管道
2所有channel表达式都会被求值
3所有被发送的表达式都会被求值
4如果任意某个通信可以进行，它就执行；其他被忽略。
5如果有多个case都可以运行，Select会随机公平地选出一个执行。其他不会执行。 
6否则：
7    1.如果有default子句，则执行该语句。
8    2.如果没有default字句，select将阻塞，直到某个通信可以运行；Go不会重新对channel或值进行求值。
9    

语法

Go语言的For循环有3中形式，只有其中的一种使用分号。

和 C 语言的 for 一样：

for init; condition; post { }

和 C 的 while 一样：

for condition { }

和 C 的 for(;;) 一样：

for { }

循环语句嵌套

1for [condition |  ( init; condition; increment ) | Range]
2{
3    for [condition |  ( init; condition; increment ) | Range]
4    {
5        statement(s);
6    }
7    statement(s);
8}

• init： 一般为赋值表达式，给控制变量赋初值；
• condition： 关系表达式或逻辑表达式，循环控制条件；
• post： 一般为赋值表达式，给控制变量增量或减量。

for语句执行过程如下：

1①先对表达式1赋初值；
2②判别赋值表达式 init 是否满足给定条件，若其值为真，满足循环条件，则执行循环体内语句，然后执行 post，进入第二次循环，再判别 condition；否则判断 condition 的值为假，不满足条件，就终止for循环，执行循环体外语句。

for 循环的 range 格式可以对 slice、map、数组、字符串、chan等进行迭代循环。格式如下：

1for key, value := range oldMap {
2    newMap[key] = value
3}

函数

Go 语言最少有个 main() 函数。 GO 语言每个文件最多只有一个init()函数,该函数会被自动调用用于初始化操作

你可以通过函数来划分不同功能，逻辑上每个函数执行的是指定的任务。

函数声明告诉了编译器函数的名称，返回类型，和参数。

Go 语言标准库提供了多种可动用的内置的函数。例如，len() 函数可以接受不同类型参数并返回该类型的长度。如果我们传入的是字符串则返回字符串的长度，如果传入的是数组，则返回数组中包含的元素个数。

Go 语言函数定义格式如下：

1func function_name( [parameter list] ) [return_types] {
2函数体
3}

函数定义解析：

1func：函数由 func 开始声明
2function_name：函数名称，函数名和参数列表一起构成了函数签名。
3parameter list：参数列表，参数就像一个占位符，当函数被调用时，你可以将值传递给参数，这个值被称为实际参数。参数列表指定的是参数类型、顺序、及参数个数。参数是可选的，也就是说函数也可以不包含参数。
4return_types：返回类型，函数返回一列值。return_types 是该列值的数据类型。有些功能不需要返回值，这种情况下 return_types 不是必须的。
5函数体：函数定义的代码集合。
6

初始化局部和全局变量

声明数组

var variable_name [SIZE] variable_type

多维数组

var variable_name [SIZE1][SIZE2]...[SIZEN] variable_type

声明指针

var var_name *var-type

定义指针数组

var ptr [MAX]*int

指向指针的指针

var ptr **int

定义结构体

variable_name := structure_variable_type {value1, value2...valuen}

结构体指针

var struct_pointer *Books

定义切片

var identifier []type

切片不需要说明长度。

或使用make()函数来创建切片:

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

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

make([]T, length, capacity)

len() 方法获取长度

cap() 可以测量切片最长可以达到多少

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

Map(集合)

可以使用内建函数 make 也可以使用 map 关键字来定义 Map和chan:

1/* 声明变量，默认 map 是 nil */
2var map_variable map[key_data_type]value_data_type
3
4/* 使用 make 函数 */
5map_variable := make(map[key_data_type]value_data_type)
6
7/* 使用make 函数 */
8chan1 := make(chan type,(.capacity))

==如果不初始化 map，那么就会创建一个 nil map。nil map 不能用来存放键值对==

递归函数

1func recursion() {
2    recursion() /* 函数调用自身 */
3}
4
5func main() {
6    recursion()
7}
8

1斐波那契数列
2package main
3
4import "fmt"
5
6var n1=0
7var n2=0
8
9func fibonacci(n int) int {
10	n1++
11	if n < 2 {
12		return n
13	}
14	return fibonacci(n-2) + fibonacci(n-1)
15}
16
17func feibo(a,b,n int) int {
18    // 优化版，需要传起始参数，如果指定a,b大于0修改n>2
19	n2++
20	if (n > 0) {
21		return feibo(a+b, a, n-1)
22	}
23	return a
24}
25
26func main() {
27	var i int
28	var j int
29	for i = 0; i < 10; i++ {
30		fmt.Printf("%d\t", fibonacci(i))
31	}
32	fmt.Println(n1)
33	for j = 0; j < 10; j++ {
34		fmt.Printf("%d\t",feibo(0, 1, j))
35	}
36	fmt.Println(n2)
37}

类型转换

type_name(expression)

==type_name 为类型，expression 为表达式。==

接口

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

1/* 定义接口 */
2type interface_name interface {
3   method_name1 [return_type]
4   method_name2 [return_type]
5   method_name3 [return_type]
6   ...
7   method_namen [return_type]
8}
9
10/* 定义结构体 */
11type struct_name struct {
12   /* variables */
13}
14
15/* 实现接口方法 */
16func (struct_name_variable struct_name) method_name1() [return_type] {
17   /* 方法实现 */
18}
19...
20func (struct_name_variable struct_name) method_namen() [return_type] {
21   /* 方法实现*/
22}

错误处理

error类型是一个接口类型，这是它的定义：

1type error interface {
2    Error() string
3}

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

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

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

go语言深拷贝

1import (
2	"fmt"
3	"bytes"
4	"encoding/gob"
5)
6
7func main() {
8	a := make(map[int]int, 0)
9	b := map[int]int{1:1,2:2}
10	c := deepCopy(&a, &b)
11	fmt.Println(a,b,c)
12}
13
14func deepCopy(dst, src interface{}) error {
15	var buf bytes.Buffer
16	if err := gob.NewEncoder(&buf).Encode(src); err != nil {
17		return err
18	}
19	return gob.NewDecoder(bytes.NewBuffer(buf.Bytes())).Decode(dst)
20}
21

时间格式

1const (
2	ANSIC       = "Mon Jan _2 15:04:05 2006"
3	UnixDate    = "Mon Jan _2 15:04:05 MST 2006"
4	RubyDate    = "Mon Jan 02 15:04:05 -0700 2006"
5	RFC822      = "02 Jan 06 15:04 MST"
6	RFC822Z     = "02 Jan 06 15:04 -0700" // RFC822 with numeric zone
7	RFC850      = "Monday, 02-Jan-06 15:04:05 MST"
8	RFC1123     = "Mon, 02 Jan 2006 15:04:05 MST"
9	RFC1123Z    = "Mon, 02 Jan 2006 15:04:05 -0700" // RFC1123 with numeric zone
10	RFC3339     = "2006-01-02T15:04:05Z07:00"
11	RFC3339Nano = "2006-01-02T15:04:05.999999999Z07:00"
12	Kitchen     = "3:04PM"
13	// Handy time stamps.
14	Stamp      = "Jan _2 15:04:05"
15	StampMilli = "Jan _2 15:04:05.000"
16	StampMicro = "Jan _2 15:04:05.000000"
17	StampNano  = "Jan _2 15:04:05.000000000"
18)

其它标记

• | 总打印数值的正负号；对于%q（%+q）保证只输出ASCII编码的字符。| Printf("%+q", "中文") | "\u4e2d\u6587"

• | 在右侧而非左侧填充空格（左对齐该区域）| |

| 备用格式：为八进制添加前导 0（%#o）| Printf("%#U", '中') | U+4E2D<br>为十六进制添加前导 0x（%#x）或 0X（%#X），为 %p（%#p）去掉前导 0x；<br>如果可能的话，%q（%#q）会打印原始 （即反引号围绕的）字符串；<br>如果是可打印字符，%U（%#U）会写出该字符的<br>Unicode 编码形式（如字符 x 会被打印成 U+0078 'x'）。

' ' | (空格)为数值中省略的正负号留出空白（% d）；<br>以十六进制（% x, %X）打印字符串或切片时，在字节之间用空格隔开 | 0 | 填充前导的0而非空格；对于数字，这会将填充移到正负号之后

同 for 一样， if 语句可以在条件表达式前执行一个简单的语句。 该语句声明的变量作用域仅在 if 之内。

1if v := math.Pow(x, n); v < lim {
2		return v
3	}

1// strings包
2// Author: Wjy
3import (
4	"strings"
5	"fmt"
6)
7
8func main() {
9	s1 := "hello world"
10	//判断字符是否在字符串中
11	fmt.Println(strings.Contains(s1, "l"))
12	//判断字符串中是否有字符在s1中
13	fmt.Println(strings.ContainsAny(s1, "wh"))
14	fmt.Println(strings.ContainsRune(s1, 'h'))
15	//判断字符的次数
16	fmt.Println(strings.Count(s1, "l"))
17
18	s2 := "2018课堂笔记.txt"
19	if strings.HasPrefix(s2, "2018"){
20		fmt.Println("前缀是2018")
21	}
22	if strings.HasSuffix(s2, "txt"){
23		fmt.Println("后缀是txt")
24	}
25	//查找第一次出现的索引位置，不存在返回-1
26	fmt.Println(strings.Index(s1, "l"))
27	fmt.Println(strings.IndexAny(s1, "ado"))
28	查找最后一次出现的位置
29	fmt.Println(strings.LastIndex(s1, "l"))
30
31	a := []string{"1","2","3","4"}
32	b := strings.Join(a, "")
33	fmt.Println(b)
34	//字符串分割
35	fmt.Println(strings.Split(b,""))
36	//字符串分割成几个,个数是-1==splite
37	fmt.Println(strings.SplitN(b, "", 3))
38	//自己拼接自己
39	fmt.Println(strings.Repeat("hello", 2))
40	//替换n为替换次数
41	fmt.Println(strings.Replace(b,"2","3",-1))
42	//大写
43	fmt.Println(strings.ToUpper(s1))
44
45	s6 := " **+hello+*world** "
46	//删除首尾字符
47	fmt.Println(strings.Trim(s6,"*+ "))
48	//删除左侧
49	fmt.Println(strings.TrimLeft(s6, ""))
50	//删除右侧
51	fmt.Println(strings.TrimRight(s6, ""))
52	//去首位空格
53	fmt.Println(strings.TrimSpace(s6))
54
55	s7:=s6[4:8]
56	fmt.Println(s7)
57	a:="我们去秋游"
58	fmt.Println(strings.Index(a, "去"))
59	fmt.Println(strings.Contains(a, "秋游"))
60}

1strconv转换
2func ParseBool(str string) (value bool, err error)
3//将字符串转换为布尔值
4strconv.ParseBool("1") // true
5
6func FormatBool(b bool) string
7//FormatBool 将布尔值转换为字符串 "true" 或 "false"
8strconv.FormatBool(0)
9
10func ParseFloat(s string, bitSize int) (f float64, err error)
11//将字符串转换为 float64 型,bitSize：指定浮点类型（32:float32、64:float64）
12
13func ParseInt(s string, base int, bitSize int) (i int64, err error)
14//将字符串转换为 int 类型,base：进位制（2 进制到 36 进制）,bitSize：指定整数类型（0:int、8:int8、16:int16、32:int32、64:int64）
15
16func Atoi(s string) (i int, err error)
17//将字符串转换为 int 类型
18
19func FormatInt(i int64, base int) string
20//FormatUint 将 int 型整数 i 转换为字符串形式
21
22func Itoa(i int) string
23//返回数字 i 所表示的字符串类型的十进制数
24
25浮点数到字符串
26strconv.FormatFloat(float64(input_num), 'f', 6, 64)
27
28整形到字符串
29s = strconv.Itoa(i) 或者 s = FormatInt(int64(i), 10)

1math模块部分函数
2https://godoc.org/math
3fmt.Println(math.Abs(float64(i))) //绝对值
4   fmt.Println(math.Ceil(5.0))       //向上取整
5   fmt.Println(math.Floor(5.8))      //向下取整
6   fmt.Println(math.Mod(11, 3))      //取余数，同11%3
7   fmt.Println(math.Modf(5.26))      //取整数，取小数
8   fmt.Println(math.Pow(3, 2))       //x的y次方
9   fmt.Println(math.Pow10(4))        // 10的n次方
10   fmt.Println(math.Sqrt(8))         //开平方
11   fmt.Println(math.Cbrt(8))         //开立方

list操作 https://godoc.org/container/list#New

1func (e *Element) Next() *Element  //返回该元素的下一个元素，如果没有下一个元素则返回nil
2func (e *Element) Prev() *Element//返回该元素的前一个元素，如果没有前一个元素则返回nil。
3type List
4func New() *List //返回一个初始化的list
5func (l *List) Back() *Element //获取list l的最后一个元素
6func (l *List) Front() *Element //获取list l的第一个元素
7func (l *List) Init() *List  //list l初始化或者清除list l
8func (l *List) InsertAfter(v interface{}, mark *Element) *Element  //在list l中元素mark之后插入一个值为v的元素，并返回该元素，如果mark不是list中元素，则list不改变。
9func (l *List) InsertBefore(v interface{}, mark *Element) *Element//在list l中元素mark之前插入一个值为v的元素，并返回该元素，如果mark不是list中元素，则list不改变。
10func (l *List) Len() int //获取list l的长度
11func (l *List) MoveAfter(e, mark *Element)  //将元素e移动到元素mark之后，如果元素e或者mark不属于list l，或者e==mark，则list l不改变。
12func (l *List) MoveBefore(e, mark *Element)//将元素e移动到元素mark之前，如果元素e或者mark不属于list l，或者e==mark，则list l不改变。
13func (l *List) MoveToBack(e *Element)//将元素e移动到list l的末尾，如果e不属于list l，则list不改变。
14func (l *List) MoveToFront(e *Element)//将元素e移动到list l的首部，如果e不属于list l，则list不改变。
15func (l *List) PushBack(v interface{}) *Element//在list l的末尾插入值为v的元素，并返回该元素。
16func (l *List) PushBackList(other *List)//在list l的尾部插入另外一个list，其中l和other可以相等。
17func (l *List) PushFront(v interface{}) *Element//在list l的首部插入值为v的元素，并返回该元素。
18func (l *List) PushFrontList(other *List)//在list l的首部插入另外一个list，其中l和other可以相等。
19func (l *List) Remove(e *Element) interface{}//如果元素e属于list l，将其从list中删除，并返回元素e的值。

关于map嵌套赋值

1type t_classmates map[string]int
2 domitory := make(map[string]t_classmates)
3domitory["309"] = t_classmates{"wangwu": 25, "zhaoliu": 26,}
4或者
5a := make(map[string]map[string]int)
6c := make(map[string]int)
7a["key"]=c

底层一些的地方，bufio.Scanner，ioutil.ReadFile和ioutil.WriteFile使用的都是*os.File的 Read和Write方法

1switch语句写条件表达式case只能使用某个值或者变量，不能添加判断语句。
2switch省略条件表达式，可当 if...else if...else 使⽤
3case关键字后加fallthrough关键字紧跟该条件的条件语句会顺序执行。

1#string到int  
2int,err:=strconv.Atoi(string)  
3#string到int64  
4int64, err := strconv.ParseInt(string, 10, 64)  
5#int到string  
6string:=strconv.Itoa(int)  
7#int64到string  
8string:=strconv.FormatInt(int64,10) 
9
10时间格式化yyyy-MM-dd hh:mm:ss
11var _startDate int64 = time.Now().Unix()
12var startDate string = time.Unix(_startDate, 0).Format("2006-01-02 15:04:05")
13
14int64转10位的时间
15t := time.Now().Unix()
16str := strconv.FormatInt(t, 10)
17
18数组赋值 var nums [...]int{2:1,3:2} 指定位置参数或者取下标赋值
19
20break 可⽤用于 for、switch、select，⽽而 continue 仅能⽤用于 for 循环。
21
22
23使⽤用 slice 对象做变参时，必须展开。
24func main() {
25    s := []int{1, 2, 3}
26    println(test("sum: %d", s...))
27}
28func test2(s string,n ...int) string {
29   var x int
30   for _, i := range n{
31      x += i
32   }
33   return fmt.Sprintf(s, x)
34}

1类
2package main
3
4import "fmt"
5
6// Author: Wjy
7type Worker struct {
8	name string
9	age int
10	sex string
11}
12
13type Cat struct {
14	color string
15	age int
16}
17
18func (w Worker) work()  {
19	fmt.Println(w)
20}
21
22func (w Worker) eat() {
23	fmt.Println("工人吃")
24}
25
26func (c Cat) eat()  {
27	fmt.Println(c)
28}
29
30func (c *Cat) sleep() {
31	fmt.Println(c.color,(*c).age)
32	//c.color = "黑"
33}
34
35func main() {
36	//w := Worker{"啊",30,"男"}
37	//w.work()
38	//w.eat()
39	//
40	//c := Cat{"红",1}
41	//c.eat()
42	//c.sleep()
43	//c1 := &c
44	//(*c1).eat()
45
46	f := 父类{"a",12}
47	f.eat()
48	z := 子类{父类{"b",3},"adsa"}
49	z.eat()
50}
51
52type 父类 struct {
53	name string
54	age int
55}
56
57type 子类 struct {
58	父类
59	school string
60}
61
62func (f 父类) eat()  {
63	fmt.Println(f)
64}
65
66func (z 子类) eat()  {
67	fmt.Println(z)
68}

1// 排序
2package main
3
4import (
5	"sort"
6	"fmt"
7)
8
9// Author: Wjy
10type Person struct {
11	name string
12	age int
13}
14
15func (p *Person) String()string {
16	return fmt.Sprint(*p)
17}
18
19func main() {
20	p1:=Person{"aaa",30}
21	p2:=Person{"bbb",29}
22	p3:=Person{"ccc",31}
23	p4:=Person{"ddd",29}
24	p5:=Person{"eee",35}
25
26	s1:=make([]*Person,0)
27	s1 = append(s1,&p1,&p2,&p3,&p4,&p5)
28
29	s2 := PersionSlice(s1)
30	sort.Sort(s2)
31	fmt.Println(s2)
32}
33
34type PersionSlice []*Person
35
36func (slice PersionSlice) Less(i,j int) bool {
37	if slice[i].age < slice[j].age{
38		return true
39	}else if slice[i].age > slice[j].age{
40		return false
41	}else {
42		return slice[i].name<slice[j].name
43	}
44}
45
46func (slice PersionSlice) Swap(i,j int) {
47	slice[i],slice[j]=slice[j],slice[i]
48}
49
50func (slice PersionSlice) Len() int {
51	return len(slice)
52}

1// 接口
2package main
3
4import "fmt"
5
6// Author: Wjy
7type USB interface {
8	start()
9	end()
10}
11
12// 实现类
13type Mouse struct {
14	name string
15}
16
17func (m Mouse)start(){
18	fmt.Println(m,"点点")
19}
20
21func (m Mouse)end(){
22	fmt.Println(m,"ddd")
23}
24
25type Flash struct {
26	name string
27}
28
29func (f Flash)start(){fmt.Println("u",f)}
30func (f Flash)end(){fmt.Println(f)}
31
32func main()  {
33	m := Mouse{"罗技"}
34	f := Flash{"闪迪"}
35	var usb USB // 定义接口类型的变量
36	// 接口对象不能访问实现类的属性
37	//usb = m
38	usb = f
39	usb.start()
40
41	testInterface(m)
42
43}
44
45func testInterface(usb USB){
46	usb.start()
47}

1//断言
2package main
3
4import (
5	"math"
6	"fmt"
7)
8// Author: Wjy
9type Shape interface {
10	peri() float64
11	area() float64
12}
13type Triangle struct {
14	a,b,c float64
15}
16func (t Triangle)peri()float64  {
17	return t.a+t.b+t.c
18}
19func (t Triangle)area()float64  {
20	p :=t.peri() / 2
21	s := math.Sqrt(p*(p-t.a)*(p-t.b)*(p-t.c))
22	return s
23}
24func main() {
25	/*
26	多态
27	 */
28	 t1 := Triangle{3,4,5}
29	 fmt.Println(t1.peri())
30	 fmt.Println(t1.area())
31
32	 var s1 Shape
33	 s1 = t1
34	 fmt.Println(s1.peri())
35	 fmt.Println(s1.area())
36
37	 var c1 Circle
38	 c1 = Circle{4}
39	 fmt.Println(c1.peri())
40	 fmt.Println(c1.area())
41	 fmt.Println(c1.radius)
42
43	 var s2 Shape = Circle{5}
44	 fmt.Println(s2.area())
45	 fmt.Println(s2.peri())
46
47	 testShap(t1)
48	 // 如果定义了一个接口类型数组可以传任意实现类对象
49	 arr := [4]Shape{t1,s1,c1,s2}
50	 fmt.Println(arr)
51
52	 getType(s1)
53	 getType(s2)
54	 getType(c1)
55
56	 getTpye2(s1)
57	 getTpye2(t1)
58}
59
60type Circle struct {
61	radius float64
62}
63func (c Circle)peri()float64  {
64	return c.radius*2*math.Pi
65}
66func (c Circle)area()float64  {
67	return math.Pow(c.radius, 2)*math.Pi
68}
69//func (c Circle)new()  {
70//	fmt.Println(c,"new")
71//}
72func testShap(s Shape){
73	fmt.Println(s.peri(),s.area())
74}
75// 接口转实现类,方法1
76func getType(s Shape){
77	//instance, ok := s.(Circle) // 判断实现类
78	//fmt.Println(instance.radius, ok)
79
80	if ins,ok:=s.(Triangle);ok{
81		fmt.Println("三角形",ins.a,ins.b,ins.c)
82	}else if ins,ok:=s.(Circle);ok{
83		fmt.Println("圆",ins.radius)
84	}else {
85		fmt.Println("不是圆和三角")
86	}
87}
88// 接口转实现类,方法2
89func getTpye2(s Shape){
90	switch ins:=s.(type) {
91	case Triangle: fmt.Println("三角形",ins)
92	case Circle: fmt.Println("圆", ins.radius)
93	//case int: fmt.Println("整数")
94	}
95}

1// 自定义error error是内置类型跟nil类似
2package main
3
4import "fmt"
5
6// Author: Wjy
7
8func main() {
9 	res1, ok := getArea(-4,6)
10 	if ok != nil{
11 		fmt.Println(ok.Error())
12	}else {
13		fmt.Println("面积是",res1)
14	}
15}
16
17type errorRect struct {
18	msg string
19	wid float64
20	len float64
21}
22
23func (e *errorRect) Error()string{
24	return fmt.Sprintf("宽度是 %.2f,长度 %.2f, 错误信息 %s",e.wid,e.len,e.msg)
25}
26
27func getArea(wid, len float64)(float64,error){
28	errorMsg := ""
29	if wid < 0{
30		errorMsg = "宽度为复数"
31	}
32	if len < 0{
33		if errorMsg == ""{
34			errorMsg = "长度为复数"
35		}else {
36			errorMsg += ",长度为复数"
37		}
38	}
39	if errorMsg!=""{
40		return 0,&errorRect{errorMsg,wid,len}
41	}
42	area := wid * len
43	return area,nil
44}
45

1//异常处理
2package main
3
4import "fmt"
5
6// Author: Wjy
7
8func main() {
9	//read:= bufio.NewReader(os.Stdin)
10	//data,_,_:=read.ReadLine()
11	//fmt.Println(string(data))
12
13	funA()
14	funB()
15	fmt.Println("over")
16
17	funC()
18}
19
20func funA()  {
21	fmt.Println("funcA()...")
22}
23func funB()  {
24	defer func(){
25		if msg:=recover();msg!=nil{
26			fmt.Println(msg,"已恢复")
27		}
28	}()
29	fmt.Println("我是函数funB()...")
30	for i:=1;i<=10;i++{
31		fmt.Println("i:",i)
32		if i == 5{
33			// 让程序终端
34			panic("funB,恐慌")// 打断程序的执行
35		}
36	}
37}
38
39func funC()  {
40	defer func() {fmt.Println("funC",recover())}()
41	fmt.Println("func")
42}

1// time包
2package main
3
4import (
5	"time"
6	"fmt"
7	"math/rand"
8)
9
10// Author: Wjy
11func main() {
12	t1:=time.Now() // 获取当前时间
13	fmt.Printf("%T\n",t1)
14	fmt.Println(t1)
15	// 指定日期时间
16	t2 := time.Date(2018,10,22,16,30,28,0,time.Local)
17	fmt.Println(t2)
18	// 时间对象转字符串
19	fmt.Println(t1.String())
20	// 格式化输出日期
21	fmt.Println(t1.Format("Mon Jan 2 15:04:05 -0700 MST 2006"))
22	// 6-1-2-3-4-5
23	fmt.Println(t1.Format("2006年01月02日 15:04:05"))
24	// 字符串转时间对象
25	s3 := "1999年10月10日"
26	ss3,ok:=time.Parse("2006年01月02日",s3)
27	fmt.Println(ss3,ok)
28
29	t4 := time.Date(1970,1,1,1,0,0,0,time.UTC)
30	fmt.Println(t4.Unix()) // 获取秒数
31	fmt.Println(t1.Unix()-t4.Unix()) // 格林威治时间到现在的秒数
32
33	fmt.Println(t1.UnixNano()-t4.UnixNano()) // 格林威治时间到现在的微秒
34
35	y,m,d := t1.Date() // 获取当前时间对象的年，月，日
36	fmt.Println(y,m,d)
37	h,min,s := t1.Clock() // 获取当前时间对象的时，分，秒
38	fmt.Println(h,min,s)
39
40	year2 := t1.Year()
41	fmt.Println(year2)
42	fmt.Println(t1.YearDay())
43	month2 := t1.Month()
44	fmt.Println(month2)
45	fmt.Println(t1.Day())
46	fmt.Println(t1.Hour())
47	fmt.Println(t1.Minute())
48	fmt.Println(t1.Second())
49	fmt.Println(t1.Weekday())
50	fmt.Println(t1.ISOWeek()) // 年，周
51
52	t5 := t1.Add(time.Minute)
53	fmt.Println(t1,t5)
54	fmt.Println(t1.Add(24*time.Hour))
55
56	fmt.Println(t5.Sub(t1)) // 求两时间差
57	//time.Sleep(time.Second*10)
58
59	rand.Seed(time.Now().UnixNano())
60	randNum := rand.Intn(10)+1
61	time.Sleep(time.Duration(randNum)*time.Second)
62	fmt.Println(time.Duration(randNum)*time.Second)
63}

1//文件操作
2package main
3
4import (
5	"os"
6	"fmt"
7	"path"
8	"path/filepath"
9)
10
11// Author: Wjy
12func main() {
13	file,ok := os.Stat("./src")
14	if ok != nil{
15		fmt.Println(ok)
16		return
17	}
18	//os.Open("")
19	fmt.Printf("%T\n",file)
20	fmt.Println(file.Name())
21	fmt.Println(file.IsDir())
22	fmt.Println(file.Mode())
23	fmt.Println(file.ModTime())
24	fmt.Println(file.Size())
25
26	filename := "E:/goland/bin"
27	filename1 := "/home/path"
28	fmt.Println(path.IsAbs(filename1))
29	fmt.Println(filepath.IsAbs(filename))
30
31	fmt.Println(filepath.Abs(filename))
32
33	fmt.Println(path.Join(filename,".."))
34	// 创建文件夹
35	//errs:=os.MkdirAll("./newpath/w/d/s",777)
36	//if errs !=nil{
37	//	fmt.Println(errs)
38	//}else {
39	//	fmt.Println("ok")
40	//}
41	// 如果文件存在create会覆盖创建
42	//tfile,err := os.Create("测试用的文件.txt")
43	//fmt.Println(err)
44	//tfile.WriteString("lakakkakakasduhiuh我i我i我i我i")
45	//tfile.Close()
46
47	//fil,err :=os.Open("测试用的文件.txt")
48	//fmt.Println(err)
49	//fmt.Println(fil)
50	//fil.Close()
51
52	fil1,err1:=os.OpenFile("测试用的文件.txt",os.O_RDWR|os.O_CREATE,777)
53	fmt.Println(fil1,err1)
54	fil1.Close()
55
56	// 可以删除文件和空目录
57	//err :=os.Remove("./测试用的文件.txt")
58	//fmt.Println(err)
59	//err := os.RemoveAll("目录")//删除整个目录
60}

1// 文件读写
2package main
3
4import (
5	"os"
6	"fmt"
7	"io"
8)
9
10// Author: Wjy
11func main() {
12	/*
13	打开文件
14	读取文件
15		file.Read([]byte)-->n,err
16		n: 读取的数据个数
17		err: 错误信息
18	关闭文件
19	 */
20	filename := "./测试用的文件.txt"
21	file,err:=os.Open(filename)
22	if err!=nil{
23		fmt.Println(err)
24		return
25	}
26	bs := make([]byte,5,5)
27	for {
28		n,err :=file.Read(bs)
29		if n == 0 || err == io.EOF{
30			fmt.Println("结束了")
31			break
32		}
33		fmt.Println(n)
34		fmt.Println(bs[:n])
35		fmt.Println(string(bs[:n]))
36	}
37	//n,err=file.Read(bs)
38	//fmt.Println(n)
39	//fmt.Println(bs)
40	//fmt.Println(string(bs))
41	//fmt.Println(err)
42	//
43	//n,err=file.Read(bs)
44	//if n < 5{
45	//	fmt.Println(n)
46	//	fmt.Println(bs)
47	//	fmt.Println(string(bs[:n]))
48	//	fmt.Println(err)
49	//	return
50	//}
51
52	file.Close()
53
54}

1// ioutil包读写文件
2package main
3
4import (
5		"os"
6	"bufio"
7		"strings"
8)
9
10// Author: Wjy
11func main() {
12	//filename1 := "./ddd.txt"
13	//data, err:= ioutil.ReadFile(filename1)
14	//fmt.Println(string(data),err)
15	//
16	//filename2 := "./ddd.py"
17	//s1 := "print 'hello world'"
18	//err =ioutil.WriteFile(filename2,[]byte(s1),os.ModePerm)
19	//fmt.Println(err)
20
21	// 读取字符串
22	//a := "zxcuoioiasn2l3j"
23	//r := strings.NewReader(a)
24	//data,err :=ioutil.ReadAll(r) // 返回byte切片
25	//fmt.Println(data,err)
26
27	// 读取目录
28	//l, _:=ioutil.ReadDir("./src/")
29	//for _,v := range l{
30	//	fmt.Println(v.Name())
31	//	if v.IsDir() == true{
32	//		l1,_ := ioutil.ReadDir("./src/"+v.Name())
33	//		for _, j:=range l1{
34	//			fmt.Println(j.Name(), j.IsDir())
35	//		}
36	//	}
37	//}
38
39	// 缓存读写bufio
40	//filename := "ddd.txt"
41	//file,_:=os.Open(filename)
42	//r1 := bufio.NewReader(file)
43	//data,_,_:=r1.ReadLine()
44	//fmt.Println(string(data))
45	//data,_,_=r1.ReadLine()
46	//fmt.Println(string(data))
47	//data,_,_=r1.ReadLine()
48	//fmt.Println(string(data))
49
50	//for {
51	//	s1, err := r1.ReadString(10)
52	//	if err == io.EOF{
53	//		break
54	//	}
55	//	fmt.Print(s1)
56	//}
57	//file.Close()
58
59	//for {
60	//data,err:=r1.ReadBytes('\n')
61	//if err == io.EOF{break}
62	//fmt.Print(string(data))
63	//}
64	//file.Close()
65
66	//r2:=bufio.NewReader(os.Stdin)
67	//s2,_:=r2.ReadString('\n')
68	//fmt.Println(s2)
69
70	// 计算两日期差
71	//t1 :=time.Date(2018,2,10,13,59,0,0,time.Local)
72	//t2 :=time.Now()
73	//subM:=t2.Sub(t1)
74	//time_hour :=int(subM.Hours())
75	//fmt.Println(time_hour/24)
76	//
77	//fmt.Println(t2.Format("2006 15:04:05"))
78	//fmt.Println(int(t2.Unix()))
79
80	//file4,_ := os.OpenFile("标准输出.txt",os.O_RDWR|os.O_CREATE,os.ModePerm)
81	//r3:=bufio.NewReader(os.Stdin)
82	//s3,_:=r3.ReadString('\n')
83	//r4 := bufio.NewWriter(file4)
84	//s4,err := r4.WriteString(s3)
85	//r4.Flush()
86	//file4.Close()
87	//fmt.Println(s4,err)
88
89	file5,_:=os.OpenFile("标准输出1.txt",os.O_RDWR|os.O_CREATE,os.ModePerm)
90	defer file5.Close()
91	r3 := bufio.NewReader(strings.NewReader("hello world"))
92	//s3,_:=r3.ReadString('\n')
93	r4 := bufio.NewWriter(file5)
94	r4.ReadFrom(r3)
95	r4.Flush()
96}

1// math包
2var num int
3	fmt.Scanln(&num)
4	fmt.Printf("%T %v",num, error)
5	num := 2.1
6	fmt.Println(num/int(math.Pow10(3)), num%int(math.Pow10(3))/int(math.Pow10(2)))
7	fmt.Println(math.Floor(num+0.5)) // 向下取整
8	fmt.Println(math.Ceil(num)) // 向上取整
9	fmt.Println(math.Max(1,2)) //最大值
10	fmt.Println(math.Min(1,2)) // 最小值
11	fmt.Println(math.Pow(2,3)) //幂数
12	fmt.Println(math.Mod(11,3)) // 求余数
13	fmt.Println(math.Modf(3.18)) // 整数和精度
14	fmt.Println(math.Sqrt(9)) // 开平方

1// defer坑
2// Author: Wjy
3
4package main
5
6import "fmt"
7
8// defer是栈的数据结构
9
10func main() {
11	//a:=1
12	//fmt.Println(f())
13	//fmt.Println(f1())
14	//fmt.Println(f2())
15
16	//fmt.Println(f3())
17	//fmt.Println(f4())
18	//fmt.Println(f5())
19	//var pil *int
20	//a := 10
21	//pil = &a
22	//fmt.Println(&a,&pil)
23	//f6(pil)
24
25	//var pill **int
26	//pill = &pil
27	//fmt.Println(**pill)
28
29	//map1:=make(map[int]int)
30	//fmt.Printf("%p\n",map1)
31	//fmt.Println(&map1)
32
33	//arr := [2]int{1,2}
34	//arr1 := &arr
35	//arr1[0] = 100
36	//fmt.Println(arr1)
37
38	a:=[...]int{1,2,3}
39	f7(&a)
40
41	b := 1
42	c := 2
43	d := [2]*int{&b,&c}
44	f8(d)
45	fmt.Println(b,c)
46}
47
48func f()(result int){
49	defer func() {result++}()
50	return 0
51}
52
53func f1()(r int){
54	t := 5
55	defer func() {t = t+5}()
56	return t
57}
58
59func f2()(r int){
60	defer func(r int) {r=r+5}(r)
61	return 1
62}
63
64func f3() (result int) {
65	result = 0
66	func() {result++}()
67	return
68}
69
70func f4() (r int) {
71	t:=5
72	r=t
73	func() {t=t+5}()
74	return
75}
76
77func f5() (r int) {
78	r = 1
79	func(r int){
80		r = r +5
81	}(r)
82	return
83}
84
85func f6(a *int)  {
86	fmt.Println(*a)
87}
88
89func f7(a *[3]int)  {
90	fmt.Println(*a)
91}
92
93func f8(a [2]*int)  {
94	fmt.Println(a)
95	*a[0] = 111
96	fmt.Println(a)
97}