转载请附上本文地址：
https://blog.csdn.net/u011957758/article/details/81073106

前言

学习任何东西都是从模仿开始的。
golang最精华的基础部分，在网上找了半天没发现合适的，还是自己总结一篇吧。
本文包括以下内容：

1.Golang的基础语法
2.Golang的基础命令

此文浏览即可无需记住，使用时当字典来查会有惊喜哦～

正文

Golang的基础语法

1.官方关键字与变量的类型

---

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

类型
int	int8	int16	int32(rune)	int64
uint	uint8(byte)	uint16	uint32	uint64
float32	float64
complex64	complex128
bool	string	error

1.变量的声明

---

var name type = expression

type与expiression可省略其一，但不可都省略

    // 注意不需要加封号
    var test string = "咖啡色的羊驼"  // 声明&赋值
    var test string                 // 声明 (省略表达式)
    var test = "咖啡色的羊驼"         // 声明&赋值 (省略类型，初始类型由初始值决定)

    var a,b,c int                   // 批量声明
    var a,b,c = 1,true,"咖啡色的羊驼" // 批量声明&赋值

    test := "咖啡色的羊驼"            // 短声明（去掉var变为:=，常用于局部变量的声明和初始化）
    a,b,c := 1,true,"咖啡色的羊驼"    // 批量短声明

    a := new(int)                   // *int类型(指针)的a，指向未命名的int变量

2.变量的赋值

---

    test = "咖啡色的羊驼"  // 赋值
    num++ / num--        // 声明前提下，进行数字的增减，注意：--v和++v是非法的
    a,b = 1,2            // 批量赋值
    _,ok = x.(T)         // 检查类型，但是丢弃字段。_的作用：丢弃

3.类型声明

---

type name underlying-type

类型的底层类型决定了它的结构和表达方式

    type mystring string  // 声明mystring的类型为string
    var name mystring     // 用mystring的类型来声明变量

4.包文件引入

---

    // 引入单个包
    import "fmt"

    // 批量引入 (换行分隔，不加逗号和封号)
    import (
        "fmt"
        "os"
        "math/rand"    // 调用的时候 rand.xxx即可
    )

    // 重命名导入，防止导入声明冲突
    import (
        crand "crypto/rand"
        mrand "math/rand"
    )

5.基本数据类型

---

整型

运算符	降序排列
算术运算符	*	/	%	<<	>>	&
逻辑运算符	+	-	|	^
比较运算符	==	!=	<	<=	>	>=
其他	&&	||

tip:
1.uintptr无符号整型，大小不明确，但足以存放指针
2.int虽然大小就是32位，但是和int32还是不同类型，需显示转换
3.rune=int32 和 byte=uint8

浮点型

1.只有float32 和 float64

复数

(没有复杂数学计算，平时反正我是还没用到)
1.只有complex64 和 complex128

bool

1. true or false

字符串类型

1.string
2.拼接字符串

    s := "关注"
    s += "咖啡色的羊驼"

3.计算长度

    s := "咖啡色的羊驼"
    l := len(s)

4.截取 （左开右闭原则）

    s := "咖啡色的羊驼"
    fmt.Println(s[0:1]) // 咖啡
    fmt.Println(s[:2])  // 咖啡色
    fmt.Println(s[4:])  // 羊驼
    fmt.Println(s[:])   // 咖啡色的羊驼

5.字符串是不可变的字节序列，so

    s := "咖啡色的羊驼"
    s[0] = "o"  // 编译错误，无法赋值

不可变的好处是：使得截取任何长度的字符串开销都很低，因为共用一段底层内存。

常量

1.

    const CBS = 83   // 声明

    const (
        CBS = 83
        PI  = 3.1415926
        AB              // 不赋值默认是继承上一项的值 3.1415926
    )

2.iota

    const (
        Sunday int = iota    // 0
        Monday               // 1
        Thusday              // 2
    )

6.复合数据类型

---

数组

1.

    var a [3]int                 // 声明 容量为3的数组
    var a [3]int = [3]int{1,2,3} // 声明&赋值
    fmt.Println(a[0])            // 调用

    a := [...]int{1,2,3}         // 省略号代表长度由初始数组元素个数决定

2.遍历数组，使用range，有点像js里头的each

    for index,value := range a {
        fmt.Printf("%d %d \n", index, value)
    }

3.数组长度是数组类型的一部分，[1]int不同于[2]int

slice

1.定义：拥有相同类型元素的可变长度序列。属性包括指针、长度、容量
长度指的是元素的个数，不能超过容量的值

2.

    var nums []string         // 声明
    nums := []string{1,2,3}   // 声明&赋值

    make([]T, len)            // 声明，长度=容量
    make([]T, len, cap)       // 声明
    make([]T, cap)[:len]      // 声明

3.

属性测量	对应函数
长度	len()
容量	cap()

4.遍历
同数组

map(散列表)

1.定义：拥有键值对元素的无需集合
2.

    cbs := make(map[string][int]) // 声明 创建一个key为string类型，value为int类型的散列表
    cbs["ok"] = 1                 // 赋值

    cbs := map[string][int]{      // 声明 & 赋值
        "咖啡色" : 1,              // 注意，这儿有逗号
        "的羊驼" : 2, 
        "ok"    : 3,
    }

    delete(cbs, "ok")             // 删除元素

3.遍历
同数组

结构体

1.定义：将0个或多个任意类型的变量组合到一起的聚合数据类型，每个变量都叫结构体的成员。

2.

    type PHPer struct {
        ID      int        // 首字母大写，说明是public属性
        Name    string
        DoB     time.Time  // 也可以是自定义的类型
        cbs     string     // 首字母小写说明是private属性
    }

    var cbs PHPer          // 定义cbs是一个 PHPer 类型的结构体
    cbs.ID = 1             // 赋值

    Type Point struct { X,Y int}
    p := Point{1,2}        // 初始化值<-不推荐，成员多的话不好记顺序
    p := Point{X:1,Y:2}

7.函数

---

内置的函数总览

函数	说明
make	创建slice和map，返回的是引用
len	测量长度
cap	测量容量
new	给一个类型分配内存，并返回指向这个类型的指针
append	往array,slice等追加元素(类似js中的appendTo)，返回修改后的slice
copy	内容拷贝，主要是切片的拷贝
close	关闭channel
delete	删除散列表map的元素
real	返回complex的虚部
imag	返回complex的实部
panic	停止常规的goroutine
recover	允许程序定义goroutine的panic动作

函数的声明

    func name(paramerter-list) (result-list) {
        // 开始你的表演
    }

    func cbs(x int, y int) int { // 类型跟在参数后面，函数括号后需指定返回的类型
        return x + y
    }

多返回值

    func findLinks(url string) (link string, err error) {
        // ...各种激情过后
        return link, nil
    }

    func findLinks(url string) (string, error) { // 这么定义也行
        // ...各种激情过后
        return link, nil
    }

    link, err := findLinks(url)  // 接收多返回值

函数变量

1.

    func square(n int) int {
        return n * n
    }

    f := square     // 函数变量赋值
    fmt.Pringln(f(1))

2.函数类型的零值是nil
3.函数变量再次复制的时候，新的函数的参数和返回值类型与个数必须与初次定义的函数一致，否则会报错。

匿名函数

匿名函数只能在包级别的作用域进行声明。

    // 1.
    strings.Map(
        func(r rune) rune {
            return r+1
        },
        "cbs"
    )

    // 2.函数类型返回(闭包)
    func squares() func() int {
        var x int
        return func() int {
            x++
            return x*x
        }
    }

变长函数

定义：可以有可变的参数个数。

    // 定义
    func sum(vals ...int) int { // ...后面跟类型，代表这种类型的参数可以有多个
        total := 0
        for _,val := range vals {
            total += val
        }
        return total
    }

    // 调用
    fmt.Println(sum(1,2))
    fmt.Println(sum(1,2,3,4)) // 注意这个例子

    // 声明一个slice传递给变长函数，在变量后加...可以达到和上头一样的效果
    vals := []int{1,2,3,4}
    fmt.Println(sum(vals...)) 

延迟调用函数

    func test() int {
        defer func() {fmt.Println("213")} () // 延迟函数,由defer 定义，注意尾巴有一个括号。在函数return之后调用
        return 1
    }

宕机与恢复

宕机发生，程序执行终止。在发生宕机之时，defer定义的函数会继续执行，如果内置recover()，则recover会终止当前的宕机状态并且返回宕机的值，函数不会从之前宕机的地方继续执行而是正常返回。

    func cbs () (ok int, err error) {
        defer func() {
            if p:=recover(); p!=nil {
                err = fmt.Errorf("error: %v", p)
            }
        }()
    }

Golang的基础命令

命令	说明	例子
go build	测试编译包，检查是否存在编译错误，如果被编译的是main包，会生成可执行文件	go build cbs.go (可直接./cbs执行)
go run	编译并直接运行程序，会生成一个临时文件(不是标准的可执行文件)，直接在命令行打印输出程序执行结果	go run cbs.go
go test	测试源码目录下*_test.go的文件，生成测试时候的可执行文件，成功会显示”pass”,”ok”等信息	go test cbs.go
go fmt	格式化go文件,一般ide的保持会默认执行这个	go fmt cbs.go
go install	首先编译导入的包文件，所有导入的包文件编译完才会编译主程序；再将编译后生成的可执行文件放到bin目录下($GOPATH/bin)，编译后的包文件放到pkg目录下($GOPATH/pkg)	go install
go get	主要用于动态获取远程代码包，比如gitlab包 (如果是git获取需要提前安装git)	go get -u github.com/xxx/xxx
godoc -http=:8080	执行后在localhost:8080可查看本地文档	godoc -http=:8080
go clean	移除当前源码包里面编译生成的文件	go clean
go env	当前go环境变量	go env
go fix	修复以前老版本的代码到新版本	go fix
go list	列出当前全部安装的packge	go list
go version	当前go版本	go version