行业资讯

Go编程基础-学习1

发布时间：2020-06-27 11:30:17 作者：1350368559
来源：网络 阅读：1184

Go编程基础-学习

本内容为自己学习go知识记录的笔记，方便复习查看
笔记内容参考无闻老师的github：https://github.com/Unknwon/go-fundamental-programming
课程视频内容：百度网盘（提取码：mgom）
笔记内容参考：Go编程基础-课堂讲义

1. 什么是Go？

Go是一门 并发支持 、垃圾回收 的 编译型 系统编程语言，旨在创造一门具有在静态编译语言的 高性能 和动态语言的 高效开发 之间拥有良好平衡点的一门编程语言。

2. Go的主要特点有哪些？

类型安全 和 内存安全
以非常直观和极低代价的方案实现 高并发
高效的垃圾回收机制
快速编译（同时解决C语言中头文件太多的问题）
为多核计算机×××能提升的方案
UTF-8编码支持

3.Go存在的价值是什么？

Go在谷歌：以软件工程为目的的语言设计

4.Go是记事本编程吗？

包括VIM，IDEA，Sublime Text，Eclipse等众多知名IDE均已支持

5.Go目前有多少实际应用和资源？

全球最大视频网站 Youtube（谷歌）
七牛云存储以及旗下网盘服务（Q盘）
爱好者开发的Go论坛及博客
已用Go开发服务端的著名企业：谷歌、盛大、七牛、360
其它海量开源项目：go-wiki、Go Walker、Go Language Resources

6.Go发展成熟了吗？

作为一门2009年才正式发布的编程语言，Go是非常年轻的，因此不能称为一门成熟的编程语言，但开发社区每天都在不断更新其核心代码，给我们这些爱好者给予了很大的学习和开发动力。

7.Go的爱好者多吗？

以Google Group为主的邮件列表每天都会更新10至20帖，国内的Go爱好者QQ群和论坛每天也在进行大量的讨论，因此可以说目前Go爱好者群体是足够壮大。

8.安装Go语言

Go源码安装：参考链接
Go标准包安装：下载地址
第三方工具安装

9.Go环境变量与工作目录

根据约定，GOPATH下需要建立3个目录：
bin（存放编译后生成的可执行文件）
pkg（存放编译后生成的包文件）
src（存放项目源码）

Go编程基础-学习1

10.Go命令

在命令行或终端输入go即可查看所有支持的命令

11.Go常用命令简介
go get：获取远程包（需 提前安装 git或hg）
go run：直接运行程序
go build：测试编译，检查是否有编译错误
go fmt：格式化源码（部分IDE在保存时自动调用）
go install：编译包文件并编译整个程序
go test：运行测试文件
go doc：查看文档（CHM手册）
12.程序的整体结构

Go编程基础-学习1

13.Go开发工具安装及配置

本套教程主要使用 Sublime Text
其它IDE安装方案：参考链接
Sublime Text
下载Sublime Text：官方网站
安装gosublime（破解版可能无法安装）：安装指令
Sublime Text 2 入门及技巧

14.Go语言版”Hello world!”

Go编程基础-学习1
输出：hello.go
Go编程基础-学习1

15.Go内置关键字（25个均为小写）
- 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
16.Go注释方法
//   单行注释
/* */  多行注释
17.Go程序的一般结构：basic_structure.go

Go程序是通过 package 来组织的（与python类似）
只有 package 名称为 main 的包可以包含 main 函数
一个可执行程序 有且仅有 一个 main 包
通过 import 关键字来导入其它非 main 包
通过 const 关键字来进行常量的定义
通过在函数体外部使用 var 关键字来进行全局变量的声明与赋值
通过 type 关键字来进行结构(struct)或接口(interface)的声明
通过 func 关键字来进行函数的声明

18.Go导入 package 的格式

Go编程基础-学习1 Go编程基础-学习1Go编程基础-学习1

package main
import (
    "fmt"
)
func main() {
    //fmt.Println("hello world")
    var a int = 65
    fmt.Println(a)
    b := string(a)
    fmt.Println(b)
}    
daixuandeMacBook-Pro:学习go daixuan$ go run hello.go
65
A
如果我就是想输出字符串65，怎么办？
package main
import (
    "fmt"
    "strconv"
)
func main() {
    var a int = 65
    b := strconv.Itoa(a)
    fmt.Println(b)
}
$ go run basic_struct.go
65

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

28.常量的定义

常量的值在编译时就已经确定
常量的定义格式与变量基本相同
等号右侧必须是常量或者常量表达式
常量表达式中的函数必须是内置函数
Go编程基础-学习1

29.常量的初始化规则

在定义常量组时，如果不提供初始值，则表示将使用上行的表达式
使用相同的表达式不代表具有相同的值
Go编程基础-学习1
Go编程基础-学习1

package main
import (
    "fmt"
)
const (
    a, b = 1, "2" 
    c, d //这里两个变量c,d使用初始化规则，值等于上一行表达式，注意每一行的常量个数相同
)
func main() {
    fmt.Println(a)
    fmt.Println(b)
    fmt.Println(c)
    fmt.Println(d)
}
$ go run basic_struct.go
1
2
1
2
30.枚举

iota是常量的计数器，从0开始，组中每定义1个常量自动递增1
通过初始化规则与iota可以达到枚举的效果
每遇到一个const关键字，iota就会重置为0

package main
import (
    "fmt"
)
const (
    a = "A"
    b           //b初始化规则b=a="A"
    c = iota    //已经有2个常量a，b，所以c=2
    d           //注意：这里d套用了c的常量表达式d=iota，已经有3个常量a，b，c，所以d=3
)
const (  
    e = iota  //每遇到一个const关键字，iota就会重置为0，所以e=iota=0
    f     //f套用了e的常量表达式f=iota，e=0，f=e+1=1
)
func main() {
    fmt.Println(a)
    fmt.Println(b)
    fmt.Println(c)
    fmt.Println(d)
    fmt.Println(e)
    fmt.Println(f)
}
go run basic_struct.go
A
A
2
3
0
1
31.运算符

Go中的运算符均是从左至右结合
优先级（从高到低）
^ ! （一元运算符）

func main() {
LABEL1:
    for i := 0; i < 10; i++ {
        for {
            fmt.Println(i)
            continue LABEL1
        }
    }
    fmt.Println("ok")
}
$ go run basic_struct.go
0
1
2
3
4
5
6
7
8
9
ok
func main() {
LABEL1:
    for i := 0; i < 10; i++ {
        for {
            fmt.Println(i)
            goto LABEL1
        }
    }
    fmt.Println("ok")
}
$ go run basic_struct.go
0
0
0
......
因为一执行循环，输出0后，goto到label1，用重新开始循环，重新输出0之后，又调到label1，又进入循环，无线下去输出0，死循环
38.数组Array

定义数组的格式：var <varName> [n]<type>，n>=0
数组长度也是类型的一部分，因此具有不同长度的数组为不同类型

func main() {
    var a [2]int  //初始化int类型数组a，定义为2个元素，默认值为0
    var b [2]int
    b = a
    fmt.Println(b)
}
$ go run basic_struct.go
[0 0]
func main() {
    a := [2]int{1, 1} //初始化int类型数组a，定义为2个元素，初始值为1
    var b [2]int
    b = a
    fmt.Println(b)
}
$ go run basic_struct.go
[1 1]
func main() {
    a := [2]int{1} //初始化int类型数组a，定义为2个元素，初始值1、0
    var b [2]int
    b = a
    fmt.Println(b)
}
$ go run basic_struct.go
[1 0]
func main() {
    a := [20]int{18: 2, 19: 1} //定义数组第19个元素值为2，第20个元素为1
    fmt.Println(a)
}
$ go run basic_struct.go
[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 2 1]
func main() {
    a := [...]int{3, 2, 1, 19: 1} //使用...定义数组，第20个元素是1，则数组长度为20
    fmt.Println(a)
}
$ go run basic_struct.go
[3 2 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1]

注意区分：
指向数组的指针[100]int -->&[0 0 0 0 0 0 0 0 0 1]
指针数组[100]int -->[0xc420016088 0xc420016090] 

func main() {
    a := [...]int{9: 1}
    var p *[10]int = &a //p是指向数组的指针
    fmt.Println(p)
}
$ go run basic_struct.go
&[0 0 0 0 0 0 0 0 0 1] //数组前面有一个&，p是指向数组的指针
func main() {
    a := [...]int{9: 1}
    var p = &a   //这样更简单，p是指向数组的指针
    fmt.Println(p)
}
$ go run basic_struct.go
&[0 0 0 0 0 0 0 0 0 1]
func main() {
    x, y := 1, 2
    a := [...]*int{&x, &y} //定义a是指针类型的数组，保存的数组元素是指向int型的指针：变量x和y的地址 
    fmt.Println(a)
}
$ go run basic_struct.go
[0xc420016088 0xc420016090]

数组在Go中为值类型，传递数组是整个拷贝的，其他语言为了节省内存，数组是引用类型。
数组之间可以使用==或!=进行比较，但不可以使用<或>

func main() {
    a := [2]int{1, 2}
    b := [2]int{1, 2}
    fmt.Println(a == b)
}
$ go run basic_struct.go
true
func main() {
    a := [2]int{1, 2}
    b := [2]int{1, 200}
    fmt.Println(a == b)
}
$ go run basic_struct.go
false
//注意：数组长度不同，无法直接比较，否则报错
func main() {
    a := [2]int{1, 2}
    b := [1]int{10}
    fmt.Println(a == b)
}
$ go run basic_struct.go
# command-line-arguments
./basic_struct.go:17:16: invalid operation: a == b (mismatched types [2]int and [1]int)

可以使用new来创建数组，此方法返回一个指向数组的指针

func main() {
    p := new([10]int)
    fmt.Println(p)
}
$ go run basic_struct.go
&[0 0 0 0 0 0 0 0 0 0]
//可以使用索引直接对数组元素操作
func main() {
    a := [10]int{}
    a[1] = 2      //使用索引直接对数组元素赋值
    fmt.Println(a)
    p := new([10]int)
    p[1] = 2   //使用索引直接对数组元素赋值
    fmt.Println(p)
    fmt.Println(*p)
}
$ go run basic_struct.go
[0 2 0 0 0 0 0 0 0 0]
&[0 2 0 0 0 0 0 0 0 0]
[0 2 0 0 0 0 0 0 0 0]

Go支持多维数组

func main() {
    a := [2][3]int{
        {1, 1, 1},
        {2, 2, 2}}
    fmt.Println(a)
}
$ go run basic_struct.go
[[1 1 1] [2 2 2]]
func main() {
    a := [2][3]int{
        {1: 1},   //给数组元素赋值
        {2: 2}}    //给数组元素赋值
    fmt.Println(a)
}
$ go run basic_struct.go
[[0 1 0] [0 0 2]]

Go语言版冒泡排序

func main() {
    a := []int{5, 2, 6, 3, 9}
    fmt.Println(a)
    num := len(a)
    for i := 0; i < num; i++ {
        for j := i + 1; j < num; j++ {
            if a[i] < a[j] {
                temp := a[i]
                a[i] = a[j]
                a[j] = temp
            }
        }
    }
    fmt.Println(a)
}
$ go run basic_struct.go
[5 2 6 3 9]
[9 6 5 3 2]
39.切片Slice

其本身并不是数组，它指向底层的数组
作为变长数组的替代方案，可以关联底层数组的局部或全部
为引用类型
可以直接创建或从底层数组获取生成
使用len()获取元素个数，cap()获取容量
一般使用make()创建
如果多个slice指向相同底层数组，其中一个的值改变会影响全部

func main() {
    a := [10]int{1,2,3,4,5,6,7,8,9,0}
    fmt.Println(a)
    s1:=a[5:10]//a[5:10]指的是：a[5,6,7,8,9]，不包括a[10]
    fmt.Println(s1)
}
$ go run basic_struct.go
[1 2 3 4 5 6 7 8 9 0]
[6 7 8 9 0]

func main() {
    a := [10]int{1,2,3,4,5,6,7,8,9,0}
    fmt.Println(a)
    s1:=a[5:len(a)]//a[5,6,7,8,9]
    fmt.Println(s1)
}
$ go run basic_struct.go
[1 2 3 4 5 6 7 8 9 0]
[6 7 8 9 0]

func main() {
    a := [10]int{1,2,3,4,5,6,7,8,9,0}
    fmt.Println(a)
    s1:=a[5:]//a[5,6,7,8,9]
    fmt.Println(s1)
}
$ go run basic_struct.go
[1 2 3 4 5 6 7 8 9 0]
[6 7 8 9 0]

func main() {
    a := [10]int{1,2,3,4,5,6,7,8,9,0}
    fmt.Println(a)
    s1:=a[:5]//a[5,6,7,8,9]
    fmt.Println(s1)
}
$ go run basic_struct.go
[1 2 3 4 5 6 7 8 9 0]
[1 2 3 4 5]

make([]T, len, cap)
其中cap可以省略，则和len的值相同
len表示存数的元素个数，cap表示容量

func main() {
    s1:=make([]int,3,10)
    fmt.Println(s1)
}
$ go run basic_struct.go
[0 0 0]
func main() {
    s1:=make([]int,3,10)
    fmt.Println(s1)
    fmt.Println(len(s1),cap(s1))//打印元素个数3和容量10
}
$ go run basic_struct.go
[0 0 0]
3 10
40.Slice与底层数组的对应关系
func main() {
    a:=[]byte{'a','b','c','d','e','f','g','h','i','j','k'}
    sa := a[2:5]
    fmt.Println(string(sa))
}
$ go run basic_struct.go
cde
func main() {
    a:=[]byte{'a','b','c','d','e','f','g','h','i','j','k'}
    sb := a[3:5]
    fmt.Println(string(sb))
}
$ go run basic_struct.go
de

Go编程基础-学习1

41.Reslice 从slice中获取新的slice

Reslice时索引以被slice的切片为准
索引不可以超过被slice的切片的容量cap()值
索引越界不会导致底层数组的重新分配而是引发错误

func main() {
    a:=[]byte{'a','b','c','d','e','f','g','h','i','j','k'}
    sa := a[2:5]
    fmt.Println(len(sa),cap(sa))//sa元素3，容量是9
    sb := a[3:5]
    fmt.Println(len(sb),cap(sb))//sb元素2，容量是8，比sa少1
    fmt.Println(string(sa))
    fmt.Println(string(sb))
}
$ go run basic_struct.go
3 9
2 8 
cde
de
func main() {
    a:=[]byte{'a','b','c','d','e','f','g','h','i','j','k'}
    sa := a[2:5]
    fmt.Println(len(sa),cap(sa))//sa元素3，容量是9（cdefghijk）
    sb := sa[2:5]
    fmt.Println(len(sb),cap(sb))//sb元素3，容量是7（efghijk）
    fmt.Println(string(sa))
    fmt.Println(string(sb))
}
$ go run basic_struct.go
3 9
3 7
cde
efg
42.Append（重要）

可以在slice尾部追加元素
可以将一个slice追加在另一个slice尾部
如果最终长度未超过追加到slice的容量则返回原始slice
如果超过追加到的slice的容量则将重新分配数组并拷贝原始数据（容量翻倍）

func main() {
    s1 := make([]int,3,6)
    fmt.Printf("%p\n",s1)
    s1 = append(s1,1,2,3)
    fmt.Printf("%v,%p\n",s1,s1)
}
$ go run basic_struct.go
0xc4200180c0              //容量没有变化，内存地址没有变化
[0 0 0 1 2 3] 0xc4200180c0
func main() {
    s1 := make([]int,3,6)
    fmt.Printf("%p\n",s1)
    s1 = append(s1,1,2,3)
    fmt.Printf("%v,%p\n",s1,s1)
    s1 = append(s1,1,2,3) //这里容量不够，重新分配容量（翻倍），拷贝原来元素再追加
    fmt.Printf("%v,%p\n",s1,s1)
}
$ go run basic_struct.go
0xc420092000
[0 0 0 1 2 3],0xc420092000
[0 0 0 1 2 3 1 2 3],0xc420072060
func main() {
    a := []int{1,2,3,4,5}
    s1 := a[2:5]
    s2 := a[1:3]
    fmt.Println(s1,s2)
    s1[0] = 9    //slice指向底层数组，多个slice指向同一个数组时候，其中一个改变，会影响数组，同时影响其他slice值
    fmt.Println(a)
    fmt.Println(s1,s2)
}
$ go run basic_struct.go
[3 4 5] [2 3]
[1 2 9 4 5]
[9 4 5] [2 9]
func main() {
    a := []int{1,2,3,4,5}
    s1 := a[2:5]
    s2 := a[1:3]
    fmt.Println(s1,s2)
    s2=append(s2,1,2,1,1,1,1,1,1,1)//apend元素个数超过slice容量，会指向新的内存地址的底层数组（从a拷贝过来的），此时改变a，不会影响s2的值
    s1[0] = 9
    fmt.Println(a)
    fmt.Println(s1)
    fmt.Println(s2)
}
$ go run basic_struct.go
[3 4 5] [2 3]
[1 2 9 4 5]
[9 4 5]
[2 3 1 2 1 1 1 1 1 1 1]

slice拷贝，以个数少的为准

//把s2拷贝到s1
func main() {
    s1:=[]int{1,2,3,4,5,6}
    s2:=[]int{7,8,9}
    copy(s1,s2) //s2的元素7，8，9会覆盖s1的前三个元素1，2，3
    fmt.Println(s1)
}
$ go run basic_struct.go
[7 8 9 4 5 6]
//把s1拷贝到s2
func main() {
    s1:=[]int{1,2,3,4,5,6}
    s2:=[]int{7,8,9}
    copy(s2,s1)//把s1的前三个元素1，2，3拷贝覆盖s2
    fmt.Println(s2,s1)
}
$ go run basic_struct.go
[1 2 3] [1 2 3 4 5 6]
func main() {
    s1:=[]int{1,2,3,4,5,6}
    s2:=[]int{7,8,9}
    copy(s2,s1[3:6]) //把s1的后三个元素拷贝到s2，覆盖s2元素
    fmt.Println(s2,s1)
}
$ go run basic_struct.go
[4 5 6] [1 2 3 4 5 6]
func main() {
    s1:=[]int{1,2,3,4,5,6}
    s2:=[]int{7,8,9}
    copy(s2[1:3],s1[4:6]) //把s1的后2个元素拷贝到s2的后两位，覆盖s2后2个元素，保留第一个元素7
    fmt.Println(s2,s1)
}
$ go run basic_struct.go
[7 5 6] [1 2 3 4 5 6]
43.map

类似其它语言中的哈希表或者字典，以key-value形式存储数据
Key必须是支持==或!=比较运算的类型，不可以是函数、map或slice
Map查找比线性搜索快很多，但比使用索引访问数据的类型慢100倍
Map使用make()创建，支持 := 这种简写方式

func main() {
    var m map[int]string //定义map，int是key类型，string是value类型
    m=map[int]string{}
    fmt.Println(m)
}
$ go run basic_struct.go
map[]

make([keyType]valueType, cap)，cap表示容量，可省略
超出容量时会自动扩容，但尽量提供一个合理的初始值
使用len()获取元素个数

func main() {
    var m map[int]string=make(map[int]string)
    fmt.Println(m)
}
$ go run basic_struct.go
map[]

func main() {
    var m =make(map[int]string)
    fmt.Println(m)
}
$ go run basic_struct.go
map[]
func main() {
    m :=make(map[int]string)
    fmt.Println(m)
}
$ go run basic_struct.go
map[]
func main() {
    m :=make(map[int]string)
    m[1] = "ok"
    fmt.Println(m)
}
$ go run basic_struct.go
map[1:ok]
func main() {
    m :=make(map[int]string)
    m[1] = "ok"
    a:=m[1]
    fmt.Println(a)
}
ok
func main() {
    m :=make(map[int]string)
    //m[1] = "ok"
    a:=m[1]
    fmt.Println(a)
}
输出为空

键值对不存在时自动添加，使用delete()删除某键值对
使用 for range 对map和slice进行迭代操作

func main() {
    m :=make(map[int]string)
    m[1] = "ok"
    delete(m,1)
    a:=m[1]
    fmt.Println(a)
}
输出为空
func main() {
    m := make(map[int]map[int]string) //使用make创建初始化m，定义m的value是另一个map[int]string
    m[1]=make(map[int]string)//这里是用make初始化另一个map，作为value赋值给m[1] 
    m[1][1]= "ok"
    a:=m[1][1]
    fmt.Println(a)
}
ok
func main() {
    m := make(map[int]map[int]string)
    m[1]=make(map[int]string) //这里只对m[1]初始化了，没有对m[2]初始化，所以把ok赋值给nil报错
    m[2][1]= "ok"
    b:=m[2][1]
    fmt.Println(b)
}
panic: assignment to entry in nil map

goroutine 1 [running]:
main.main()
    /Users/daixuan/go/hello.go:8 +0x168

map嵌套map需注意，每一级的map都得初始化，怎么知道map是否被初始化呢？
采用多返回值的方式，当有一个返回值的时候，返回value，当有多个返回值的时候，第二个返回bool类型的值，true或者false

package main
import "fmt"
func main() {
    m := make(map[int]map[int]string)
    m[1]=make(map[int]string)
    m[1][1]= "123"
    a, ok  :=m[1][1] //m[1]被初始化，a=123，不为空，所以ok=true
    b, nok :=m[2][1] //m[2]未被初始化，b=nil，为空，所以nok=false
    fmt.Println(a,ok)
    fmt.Println(b,nok)
}
123 true   
 false
 package main
import "fmt"
func main() {
    m := make(map[int]map[int]string)
    a, ok  :=m[2][1]
    fmt.Println(a,ok) //第一次没有初始化map，所以ok=false
    if !ok { //这里判断是否ok==false,那么去初始化map[2](第二级的map)
        m[2]=make(map[int]string)//初始化第二级别map
    }
    m[2][1]="good"//赋值给第二级map的key=1的value是'good'
    a, ok  =m[2][1]
    fmt.Println(a,ok) //a=good，所以ok=true
}
 false
good true

迭代操作（slice和map都可以迭代操作）：

package main
import (
    "fmt"
)
func main()  {
    slice := []int{10,20,30,40}
    for index,value :=range slice { //i是slice的索引，相当于计数器，int型，0，1，2，3，4....，v是slice存储的值取出赋值给v，修改v的值不会影响slice本身
        if slice[index]==30{
            slice[index]=300 //使用slice[index]=300 可以直接修改slice原始的值为300
            value=400
            fmt.Println(index,value)
            fmt.Println(slice[index]) //使用slice[index]=300 可以直接修改slice原始的值为300
        }
    }
}
2 400
300
package main
import (
    "fmt"
)
func main()  {
    slice := []int{10,20,30,40}
    for _,value :=range slice { //用空白标识符下划线 _ 来忽略索引值
            fmt.Println(value)
        }
    }
10
20
30
40
package main
import (
    "fmt"
)
func main() {
    m := make(map[int]string)
    m[1]="ok"
    for key, value := range m {
        fmt.Println(key, value)
    }

    info := map[string]string{
        "name": "david",
        "address": "shanghai",
    }
    for k,v := range info{
        fmt.Printf("Key:%s,Value:%s\n",k,v)
    }
}
1 ok
Key:name,Value:david
Key:address,Value:shanghai
package main
import (
    "fmt"
)
func main() {
    sm := make([]map[int]string,5)//定义一个以map为原数类型的slice，定义map方法：m :=map[int]string，定义slice方法：slice := make([]string，5)
    for _, v := range sm { //对slice：sm进程迭代操作
        v = make(map[int]string) //对slice中的map初始化
        v[1] ="OK" //这里对v是个拷贝赋值，不会影响slice本身的值，所以v=map[1:OK]，而sm是：[map[] map[] map[] map[] map[]]
        fmt.Println(v)
    }
    fmt.Println(sm)
}
map[1:OK]
map[1:OK]
map[1:OK]
map[1:OK]
map[1:OK]
[map[] map[] map[] map[] map[]]

如果想把slice的值修改掉，怎么办呢？

package main
import (
    "fmt"
)
func main() {
    sm := make([]map[int]string,5)//定义一个以map为原数类型的slice，定义map方法：m :=map[int]string，定义slice方法：slice := make([]string，5)
    for i := range sm { //对slice：sm进程迭代操作,i=0,1,2,3,4
        sm[i] = make(map[int]string) //对slice中的map初始化
        sm[i][1] ="OK" //这里对第i个切片sm[i]赋值key=1,value="OK"，会影响slice本身的值，所以v=map[1:OK]，而sm是：[map[1:OK] map[1:OK] map[1:OK] map[1:OK] map[1:OK]]
        fmt.Println(sm[i])
    }
    fmt.Println(sm)
}
map[1:OK]
map[1:OK]
map[1:OK]
map[1:OK]
map[1:OK]
[map[1:OK] map[1:OK] map[1:OK] map[1:OK] map[1:OK]]

map是无序的，不能直接排序，但是我们可以对其key进程间接排序，需要借助slice，实现根据key有序的取出map中的值，实现map的简介排序

package main
import (
    "fmt"
)
func main() {
    m := map[int]string{1:"a",2:"b",3:"c",4:"d",5:"e"} //定义map，map没有索引
    s := make([]int,len(m))//定义slice,slice以索引为固定的key
    i :=0
    for k,_ := range m{
        s[i] = k //把map中所有的key存在slice中,但是无序的
        i++
    }
    fmt.Println(s)
}
[5 1 2 3 4]

package main
import (
    "fmt"
    "sort"
)
func main() {
    m := map[int]string{1:"a",2:"b",3:"c",4:"d",5:"e"} //定义map，map没有索引
    s := make([]int,len(m))//定义slice,slice以索引为固定的key
    i :=0
    for k,_ := range m{
        s[i] = k //把map中所有的key存在slice中
        i++
    }
    sort.Ints(s)//使用sort进程排序，把map中的key排序
    fmt.Println(s)
}
[1 2 3 4 5]
package main
import (
    "fmt"
    "sort"
)
func main() {
    m := map[int]string{1:"a",2:"b",3:"c",4:"d",5:"e"} //定义map，map没有索引
    fmt.Println(len(m))
    s := make([]int,len(m))//定义slice,slice以索引为固定的key
    i :=0
    for k,_ := range m{
        s[i] = k //把map中所有的key存在slice中
        i++
    }
    sort.Ints(s)
    fmt.Println(s)
    for j := range s{
        fmt.Println(m[j+1])
    }
}
5
[1 2 3 4 5]
a
b
c
d
e
根据在 for range 部分讲解的知识，尝试将类型为map[int]string的键和值进行交换，变成类型map[string]int
package main
import (
    "fmt"
)
func main() {
    m1 := map[int]string{1:"a",2:"b",3:"c",4:"d",5:"e"}
    fmt.Println(m1)
    m2 := make(map[string]int)
    for k,v := range m1{
        m2[v] =k
    }
    fmt.Println(m2)
}
map[3:c 4:d 5:e 1:a 2:b]
map[e:5 a:1 b:2 c:3 d:4]

程序正确运行后应输出如下结果：
Go编程基础-学习1

44.函数function

Go 函数 不支持 嵌套、重载和默认参数
但支持以下特性：
无需声明原型、不定长度变参、多返回值、命名返回值参数
匿名函数、闭包
定义函数使用关键字 func，且左大括号不能另起一行
函数也可以作为一种类型使用
Go 语言函数定义格式如下：

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

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

定义参数列表是一个int输入，另一个string输入，无返回值
fun A(a int,b string){  
}
定义参数列表是一个int输入，另一个string输入，只有一个int类型返回值
fun A(a int,b string)int{   
}
定义参数列表是一个int输入，另一个string输入，返回类型是一个int+一个string+一个int
fun A(a int,b string)(int,string,int){  
}
定义参数列表是3个int输入,3个int型输出
fun A(a int,b int, c int)(a int,b int,c int){   
}
可以简写为：
fun A(a,b, c int)(a,b,c int){   
}

命令返回值参数和不命名返回值参数有什么区别呢？
如果你要返回多个返回值的话，而且使用(a,b,c int)简写形式的话，你就必须命名返回值，不然它就不知道了

func A() (a,b,c int){
    a,b,c = 1,2,3 //这里不是:=，因为已经在内存中给a,b,c分配过内存地址了
    return a,b,c  //这里也可以直接写return，因为已经定义了返回值变量和类型(a,b,c int),代码可读性要求返回值return后加上变量a,b,c
}

如果这样定义返回值的话 (int,int,int)，就可以不用命名返回值(不定义返回值是a,b,c)

func A() (int,int,int){
    a,b,c := 1,2,3 //这里必须是:=，因为是首次初始化变量
    return a,b,c  //这里不可以只写return
}

如果A是一串int型的数字，n个，我要计算A长得最大值，怎么写呢？
使用go中的不定长变参

package main
import "fmt"
func main() {
    A(1,2,3,4,5,6,7)
}
func A(a ...int){  //...就是不定长变参，A就是一个slice，可以打印出来
    fmt.Println(a)
}
输出：[1 2 3 4 5 6 7]

package main
import "fmt"
func main() {
    A("a",1,2,3,4,5,6,7)
}
func A(b string,a ...int){  //如果A使用了不定长变参"..."，不可以在...后边定义变量b，可以在a之前定义变量b
    fmt.Println(b,a)
}
输出：a [1 2 3 4 5 6 7]

slice的值拷贝和直接slice地址拷贝有什么区别呢？

package main
import "fmt"
func main() {
    a :=1
    A(a)
    fmt.Println(a)
}
func A(a int){  //如果A使用了不定长变参"..."定义slice A
    a=2  //值拷贝不会修改面main函数中a的值,可以理解为：局部变量修改不会影响全局变量的值
    fmt.Println(a)
}
2
1
package main
import "fmt"
func main() {
    a,b :=1,2
    A(a,b)
    fmt.Println(a,b)
}
func A(s ...int){  //如果A使用了不定长变参"..."定义slice s
    s[0]=3//a=3，值拷贝不会影响main函数的内部a的值
    s[1]=4//b=4，值拷贝不会影响main函数的内部b的值
    fmt.Println(s)
}
[3 4]
1 2
package main
import "fmt"
func main() {
    s1 := []int{1,2,3,4}
    A(s1)
    fmt.Println(s1)
}
func A(s []int){  //如果A使用了不定长变参"..."定义slice A
    s[0]=5//在A()函数的内部修改影响到了main函数中的s1的值，这里拿到了slice的地址，拷贝修改了slice内存地址中的值，实际上就是对slice本身进行操作
    s[1]=6
    s[2]=7
    s[3]=8
    fmt.Println(s)
}
[5 6 7 8]
[5 6 7 8]

如果我想对这种int，string，也进行内存地址值得拷贝覆盖操作，怎么做？
采用指针地址值传递，先取出地址，再赋值

package main
import "fmt"
func main() {
    a :=1
    A(&a)//调用A()函数，由于A()要求输出是指针类型（一个地址值0xxxx），所有输入&a符合输入要求&a=0xxxx
    fmt.Println(a)//这里也打印2，说明内存中的*a的值已经被修改
}
func A(a *int){ //定义了指针类型的a,a可能的值是a=0xxxxx
    *a=2 //把内存地址为0xxxx的变量*a重新赋值为2
    fmt.Println(*a)//打印*a的变量值，
}
2
2

函数也是一种数据类型，给个例子

package main
import "fmt"
func main() {
    a :=A //这里a就是A的复制品
    a()
}
func A(){
    fmt.Println("Func A")
}
Func A

什么是匿名函数呢？

package main
import "fmt"
func main() {
    a := func() { //定义a是匿名函数，可以调用并且打印Func A
        fmt.Println("Func A")
    }
    a()
}
Func A

那么什么是闭包？

package main
import "fmt"
func main() {
    f := closure(10) //调用闭包函数closure()，返回一个匿名函数给f，赋值x=10
    /*
    此时f就是匿名函数：
    func(y int)int {
        fmt.Printf("%p\n",&x)  
        return x + y
    }
    */
    fmt.Println(f(1)) //第一次调用func(),x=10,y=1，return 11
    fmt.Println(f(2)) //第二次调用func(),x=10,y=2，return 12
}
func closure(x int) func(int) int { //闭包函数的作用是返回一个匿名函数
    fmt.Printf("%p\n",&x) //第一次调用闭包函数打印x变量地址0xc420012070
    return func(y int)int {
        fmt.Printf("%p\n",&x)  //第二、三次调用闭包函数打印x变量地址0xc420012070，三次相同,
        return x + y
    }
}
0xc420012070
0xc420012070
11
0xc420012070
12

实例
以下实例为 max() 函数的代码，该函数传入两个整型参数 num1 和 num2，并返回这两个参数的最大值：

//函数返回两个数的最大值
func max(num1, num2 int) int {
// 声明局部变量 
var result int
if (num1 > num2) {
      result = num1
   } else {
      result = num2
   }
   return result 
}

函数调用
当创建函数时，你定义了函数需要做什么，通过调用改函数来执行指定任务。

调用函数，向函数传递参数，并返回值，例如：

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 
}
以上实例在 main() 函数中调用 max（）函数，执行结果为：
最大值是 : 200

函数返回多个值
Go 函数可以返回多个值，例如：

package main
import "fmt"
func swap(x, y string) (string, string) {
   return y, x
}
func main() {
   a, b := swap("Mahesh", "Kumar")
   fmt.Println(a, b)
}
以上实例执行结果为：
Kumar Mahesh
传递类型 描述
值传递 值传递是指在调用函数时将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数。
引用传递 引用传递是指在调用函数时将实际参数的地址传递到函数中，那么在函数中对参数所进行的修改，将影响到实际参数。

默认情况下，Go 语言使用的是值传递，即在调用过程中不会影响到实际参数。

推荐阅读：
  1. shell编程基础-1
  2. 2019/1/15 python基础学习

免责声明：本站发布的内容（图片、视频和文字）以原创、转载和分享为主，文章观点不代表本网站立场，如果涉及侵权请联系站长邮箱：is@yisu.com进行举报，并提供相关证据，一经查实，将立刻删除涉嫌侵权内容。

go 编程基础 学习

上一篇：为企业应用开发提速，写给企业IT部门的低代码开发基础知识

下一篇：Java编程基础阶段笔记 day01 Java语言概述

相关阅读

您好，登录后才能下订单哦！

密码登录
登录注册
获取短信验证码
其他方式登录
点击 登录注册 即表示同意《亿速云用户服务条款》
产品服务
地区划分
帮助支持
关于我们
行业资讯-文章归档 问答-问答归档
广州亿速云计算有限公司

7*24小时在线电话：400-100-2938

7*24小时在线QQ：800811969

Copyright © Yisu Cloud Ltd. All Rights Reserved. 2018 版权所有
粤ICP备17096448号-1 粤公网安备 44010402001142号