├── Beego框架的学习 ├── beego框架图文简介讲解01.md ├── beego框架图文简介讲解01 │ ├── 1.png │ ├── 2.png │ ├── 3.png │ └── 4.png ├── beego框架图文简介讲解02.md ├── beego框架图文简介讲解02 │ └── 1.png └── beego框架图文简介讲解03.md ├── Linux学习 ├── Linux命令-cal命令.md ├── Linux命令-cat命令.md ├── Linux命令-cd命令.md ├── Linux命令-chgrp命令.md ├── Linux命令-chmod命令.md ├── Linux命令-chmod命令 │ └── 1.png ├── Linux命令-chown命令.md ├── Linux命令-cp.md ├── Linux命令-crontab命令.md ├── Linux命令-crontab命令 │ └── 1.png ├── Linux命令-date命令.md ├── Linux命令-df命令.md ├── Linux命令-diff命令.md ├── Linux命令-du命令.md ├── Linux命令-etc-group文件详解.md ├── Linux命令-find之exec.md ├── Linux命令-find之xargs.md ├── Linux命令-find参数详解.md ├── Linux命令-find命令概述.md ├── Linux命令-grep命令.md ├── Linux命令-gzip命令.md ├── Linux命令-head命令.md ├── Linux命令-ifconfig命令.md ├── Linux命令-iostat命令.md ├── Linux命令-killall命令.md ├── Linux命令-kill命令.md ├── Linux命令-ldd命令.md ├── Linux命令-less命令.md ├── Linux命令-ln命令.md ├── Linux命令-locate命令.md ├── Linux命令-ls.md ├── Linux命令-mkdir.md ├── Linux命令-more命令.md ├── Linux命令-mv命令.md ├── Linux命令-nl命令.md ├── Linux命令-ping命令.md ├── Linux命令-ps命令.md ├── Linux命令-pwd命令.md ├── Linux命令-rm.md ├── Linux命令-rmdir命令.md ├── Linux命令-tail命令.md ├── Linux命令-tar命令.md ├── Linux命令-top命令.md ├── Linux命令-top命令 │ ├── 1.png │ ├── 2.png │ ├── 3.png │ ├── 4.png │ └── 5.png ├── Linux命令-touch.md ├── Linux命令-wc命令.md ├── Linux命令-whereis命令.md ├── Linux命令-which命令.md ├── Linux文件属性详解.md ├── Linux文件类型与拓展名.md ├── Linux目录结构.md └── README.md ├── README.md ├── goland使用介绍 ├── 1.介绍.md ├── 2.安装.md ├── 3.常用设置.md ├── 4.快捷键.md ├── 5.插件安装.md ├── 6.故障排除.md └── README.md ├── go基础学习所有代码例题 ├── 01学习 │ ├── 代码demo │ │ ├── 01第一个go语言程序.go │ │ ├── 02变量的定义和使用.go │ │ ├── 03自动推导类型.go │ │ ├── 04多重赋值和匿名变量.go │ │ ├── 05格式输出.go │ │ └── 06格式输出.go │ └── 相关资料及笔记 │ │ ├── 01内存数据存储.png │ │ ├── 02变量交换.png │ │ └── 笔记.txt ├── 02学习 │ ├── 代码demo │ │ ├── 01数据类型.go │ │ ├── 02字符和字符串区别.go │ │ ├── 03fmt输入输出.go │ │ ├── 04常量.go │ │ ├── 05iota枚举.go │ │ ├── 06算数运算符.go │ │ ├── 07赋值运算符.go │ │ ├── 08比较运算符.go │ │ ├── 09逻辑运算符.go │ │ └── 10其他运算符和运算符优先级.go │ └── 相关资料及笔记 │ │ ├── 01数据存储格式.png │ │ └── 02内存模型他.png ├── 03学习 │ ├── 代码demo │ │ ├── 01if条件语句.go │ │ ├── 02if语句嵌套.go │ │ ├── 03三只小猪称体重.go │ │ ├── 04switch语句.go │ │ ├── 05for语句.go │ │ ├── 06水仙花.go │ │ ├── 07敲7.go │ │ ├── 08跳出语句.go │ │ ├── 09嵌套循环.go │ │ ├── 10百钱百鸡.go │ │ ├── 11函数.go │ │ ├── 12不定参函数.go │ │ ├── 13函数返回值.go │ │ └── 14函数嵌套调用.go │ └── 相关资料及笔记 │ │ ├── 01if判断.png │ │ ├── 02三只小猪.png │ │ ├── 03函数调用过程.png │ │ └── 04函数嵌套调用.png ├── 04学习 │ ├── 代码demo │ │ ├── 01练习题.go │ │ ├── 01闭包.png │ │ ├── 02函数类型.go │ │ ├── 02递归函数.png │ │ ├── 03作用域.go │ │ ├── 03递归函数.png │ │ ├── 04匿名函数(1).go │ │ ├── 04匿名函数.go │ │ ├── 05闭包.go │ │ ├── 06递归函数.go │ │ ├── 07数组定义和使用.go │ │ └── 08数组练习.go │ └── 相关资料及笔记 │ │ ├── 01闭包.png │ │ ├── 02递归函数.png │ │ ├── 03递归函数.png │ │ └── 04数组定义.png ├── 05学习 │ ├── 代码demo │ │ ├── 01数组逆置.go │ │ ├── 02冒泡排序.go │ │ ├── 02冒泡排序.png │ │ ├── 03数组作为函数参数.go │ │ ├── 04随机数.go │ │ ├── 05双色球.go │ │ ├── 06多维数组.go │ │ ├── 07切片定义和使用.go │ │ ├── 08切片使用方式.go │ │ ├── 09统计字符个数.go │ │ ├── 10切片的内存地址.go │ │ └── 11切片的截取.go │ └── 相关资料及笔记 │ │ ├── 01数组逆置.png │ │ ├── 02冒泡排序.png │ │ ├── 03数组作为函数参数.png │ │ ├── 04二维数组.png │ │ ├── 05切片定义和使用.png │ │ └── 06切片添加.png ├── 06学习 │ ├── 代码demo │ │ ├── 01切片截取.go │ │ ├── 02切片作为函数参数.go │ │ ├── 03猜数字.go │ │ ├── 04字符串处理函数.go │ │ ├── 05字符串类型转换.go │ │ ├── 06数据类型转成切片.go │ │ ├── 07map创建和使用.go │ │ ├── 08map中的值.go │ │ ├── 09map作为函数参数.go │ │ ├── 10结构体定义和使用.go │ │ ├── 11结构体赋值和比较.go │ │ └── 12结构体数组和切片.go │ └── 相关资料及笔记 │ │ ├── 01切片作为函数参数.png │ │ ├── 02结构体赋值.png │ │ └── 03结构体数组.png ├── 07学习 │ ├── 代码demo │ │ ├── 01结构体作为函数参数.go │ │ ├── 02指针定义和使用.go │ │ ├── 03指针的使用.go │ │ ├── 04指针作为函数参数.go │ │ ├── 05数组指针.go │ │ ├── 06指针数组.go │ │ ├── 07指针和切片.go │ │ ├── 08结构体和指针.go │ │ └── 09new高级操作.go │ └── 相关资料及笔记 │ │ ├── 01指针定义和使用.png │ │ ├── 02内存存储.png │ │ ├── 03new创建空间.png │ │ ├── 04指针作为函数参数.png │ │ ├── 05数组指针.png │ │ ├── 06指针数组.png │ │ ├── 07切片指针.png │ │ ├── 08切片指针作为函数参数.png │ │ └── 09结构体new操作.png ├── 08学习 │ ├── 代码demo │ │ ├── 01多级指针.go │ │ ├── 02匿名字段实现继承.go │ │ ├── 03同名字段.go │ │ ├── 04指针匿名字段.go │ │ ├── 05继承常见问题.go │ │ ├── 06多重继承.go │ │ ├── 07多重继承.go │ │ ├── 08方法定义和使用.go │ │ ├── 09方法定义和使用.go │ │ ├── 10方法的接收者为指针.go │ │ ├── 11方法继承.go │ │ ├── 12方法练习.go │ │ └── 13方法重写.go │ └── 相关资料及笔记 │ │ ├── 01多级指针.png │ │ ├── 02结构体同名字段.png │ │ └── 03指针匿名字段.png ├── 09学习 │ └── 代码demo │ │ ├── 01方法值和方法表达式.go │ │ ├── 02面向对象计算器实现.go │ │ ├── 03接口定义和使用.go │ │ ├── 04多态的实现.go │ │ ├── 05接口的继承和转换.go │ │ ├── 06空接口.go │ │ ├── 07类型断言.go │ │ └── 08面型对象计算器实现.go ├── 10学习 │ ├── 代码demo │ │ ├── 01error接口.go │ │ ├── 02panic异常.go │ │ ├── 03defer延迟调用.go │ │ ├── 04recover异常拦截.go │ │ ├── 05文件创建.go │ │ ├── 06文件写入.go │ │ ├── 07文件读取.go │ │ └── 08文件拷贝.go │ └── 相关资料及笔记 │ │ └── 01defer调用过程.png └── README.md ├── go开源项目参考 ├── README.md ├── casbin--权限控制框架.md ├── cgo_golang调用c语言.md ├── colly--好用的爬虫框架.md ├── etcd--go消息队列.md ├── gin--web框架.md ├── go-cloud--golang云管理.md ├── gorm--orm框架.md ├── grpc_go语言的RPC系统.md ├── melody_websocket框架.md ├── nsq--go消息队列.md ├── open--小巧的工具框架.md └── seelog_浏览器实时查看日志.md ├── go标准库 ├── README.md ├── builtin │ ├── new_test.go │ └── print_test.go ├── fmt │ ├── fprint.go │ ├── fprintf.go │ ├── fprintln.go │ ├── fscan.go │ ├── print.go │ ├── printf.go │ ├── println.go │ ├── scan.go │ ├── scanf.go │ ├── scanln.go │ ├── sprint.go │ ├── sprintf.go │ ├── sprintln.go │ ├── sscan.go │ ├── sscanf.go │ └── sscanln.go ├── http.md ├── os │ └── os_test.go └── sync │ ├── sync.go │ └── sync.md ├── go相关教学视频 └── README.md ├── go经典题积累 ├── README.md ├── 卷1.md ├── 卷2.md ├── 卷3.md └── 卷4.md ├── go网络编程深入所有代码例题笔记 ├── 01学习 │ ├── 代码demo │ │ ├── 01-指针.go │ │ ├── 02-指针传值和传引用.go │ │ ├── 03-截取切片.go │ │ ├── 04-创建切片.go │ │ ├── 05-切片操作函数.go │ │ ├── 06-切片做函数参数1.go │ │ ├── 07-切片做函数参数2.go │ │ ├── 08-切片练习1.go │ │ ├── 09-切片练习2.go │ │ ├── 10-切片练习3.go │ │ ├── 11-map.go │ │ ├── 12-map的遍历和判断.go │ │ ├── 13-删除和传参.go │ │ └── 14-map练习.go │ └── 相关资料及笔记 │ │ ├── 01-内存布局-栈帧.png │ │ ├── 02-切片做为函数参数.png │ │ ├── 02-切片做为函数参数修改.png │ │ ├── 03-切片练习分析.png │ │ ├── map 练习分析.png │ │ ├── 变量传参-传值.jpg │ │ ├── 变量传参-传引用.jpg │ │ └── 笔记总结.txt ├── 02学习 │ ├── 代码demo │ │ ├── 01-结构体定义.go │ │ ├── 02-结构体指针.go │ │ ├── 03-结构体指针练习.go │ │ ├── 04-字符串处理函数.go │ │ ├── 05-文件创建打开关闭.go │ │ ├── 06-写文件.go │ │ ├── 07-按行读文件.go │ │ ├── 08-文件按字节读写.go │ │ ├── 09-大文件拷贝.go │ │ └── 10-目录文件访问.go │ └── 相关资料及笔记 │ │ ├── 01-内存布局-栈帧.png │ │ ├── Golang_Manual.chm │ │ ├── 笔记总结.txt │ │ └── 缓冲区.png ├── 03学习 │ ├── 代码demo │ │ ├── 00-test.go │ │ ├── 01-文件练习题2.go │ │ ├── 02-文件练习题3.go │ │ ├── 03-goroutine引入.go │ │ ├── 04-go并发.go │ │ ├── 05-Gosched.go │ │ ├── 06-Goexit.go │ │ └── 07-GOMAXPROCS.go │ └── 相关资料及笔记 │ │ ├── 并发.png │ │ ├── 笔记总结.txt │ │ ├── 线程并发同步.png │ │ └── 虚拟地址和物理地址.png ├── 04学习 │ ├── 代码demo │ │ ├── 01-channel引入.go │ │ ├── 02-使用channel数据通信.go │ │ ├── 03-channel使用常见错误.go │ │ ├── 04-无缓冲channel.go │ │ ├── 05-有缓冲channel.go │ │ ├── 06-关闭channel.go │ │ ├── 07-单向channel特性测试.go │ │ ├── 08-单向channel数据通信.go │ │ ├── 09-生产者消费者模型.go │ │ ├── 10-订单模拟.go │ │ ├── 11-Timer定时器.go │ │ ├── 12-定时器停止和重置.go │ │ └── 13-Ticker定时器.go │ └── 相关资料及笔记 │ │ ├── 父子进程交替输出.png │ │ ├── 生产者消费者模型.png │ │ └── 笔记总结.txt ├── 05学习 │ ├── 代码demo │ │ ├── 01-select.go │ │ ├── 02-斐波那契数列.go │ │ ├── 03-select实现超时退出.go │ │ ├── 04-死锁.go │ │ ├── 05-互斥锁.go │ │ ├── 06-读写锁.go │ │ ├── 07-读写锁和channel交叉使用错误.go │ │ ├── 08-生产者消费者模型1.go │ │ └── 09-生产者消费者模型2.go │ └── 相关资料及笔记 │ │ ├── 条件变量.png │ │ ├── 笔记总结.txt │ │ └── 读写锁错误.png ├── 06学习 │ ├── 代码demo │ │ ├── 01-TCP-CS模型服务器.go │ │ ├── 02-TCP-CS客户端.go │ │ ├── 03-TCP-CS并发服务器.go │ │ └── 04-TCP-CS并发客户端.go │ └── 相关资料及笔记 │ │ ├── netcat-win32-1.12.zip │ │ ├── socket.png │ │ ├── 协议.png │ │ ├── 并发服务器.png │ │ ├── 数据通信过程.png │ │ ├── 笔记总结.txt │ │ ├── 网络协议分层.png │ │ └── 网络通信其他知识.png ├── 07学习 │ ├── 代码demo │ │ ├── 01-UDP服务器.go │ │ ├── 02-UDP并发服务器.go │ │ ├── 03-获取文件属性和命令行参数.go │ │ ├── 04-文件传输-发送端.go │ │ └── 05-文件传输-接收端.go │ └── 相关资料及笔记 │ │ ├── TCP状态转换图.png │ │ ├── 三次握手.png │ │ ├── 四次挥手.png │ │ ├── 笔记总结.txt │ │ └── 网络文件传输.png ├── 08学习 │ ├── 代码demo │ │ ├── 01-chatRoom.go │ │ └── 02-test.go │ └── 相关资料及笔记 │ │ ├── 并发聊天室.png │ │ ├── 笔记总结.txt │ │ ├── 聊天和服务器.png │ │ ├── 聊天室分析草图.png │ │ └── 聊天室模型图.png ├── 09学习 │ ├── 代码demo │ │ ├── 01-获取请求包-服务器.go │ │ ├── 02-回调函数demo.go │ │ ├── 03-获取应答包-服务器.go │ │ ├── 04-获取应答报文-客户端（模拟浏览器）.go │ │ ├── 05-http服务器.go │ │ ├── 06-练习题-WEB服务器.go │ │ └── 07-http客户端.go │ └── 相关资料及笔记 │ │ ├── http协议格式.jpg │ │ └── 笔记总结.txt └── README.md ├── 【超全】Go语言超详细知识体系.md ├── 区块链学习 ├── README.md ├── 一条简单区块链的实现.md ├── 一条简单区块链的实现 │ └── 20.jpg ├── 什么是区块链.md ├── 区块链中的双花问题.md ├── 区块链中的双花问题 │ ├── 1.png │ ├── 2.png │ └── 3.png ├── 区块链以太坊相关资料.md ├── 区块链简单实现1.md ├── 区块链简单实现1 │ └── 1.png ├── 名词解释.md └── 拜占庭将军问题.md ├── 密码学学习 └── README.md ├── 相关书籍 ├── Go 学习笔记 第四版.pdf ├── Go语言圣经.pdf ├── Go语言实战 .pdf ├── Go语言编程.pdf ├── HTTP协议中文版.pdf ├── 图说区块链.pdf └── 软技能：代码之外的生存指南.pdf └── 知识体系图.png /Beego框架的学习/beego框架图文简介讲解01/1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/Beego框架的学习/beego框架图文简介讲解01/1.png -------------------------------------------------------------------------------- /Beego框架的学习/beego框架图文简介讲解01/2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/Beego框架的学习/beego框架图文简介讲解01/2.png -------------------------------------------------------------------------------- /Beego框架的学习/beego框架图文简介讲解01/3.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/Beego框架的学习/beego框架图文简介讲解01/3.png -------------------------------------------------------------------------------- /Beego框架的学习/beego框架图文简介讲解01/4.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/Beego框架的学习/beego框架图文简介讲解01/4.png -------------------------------------------------------------------------------- /Beego框架的学习/beego框架图文简介讲解02/1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/Beego框架的学习/beego框架图文简介讲解02/1.png -------------------------------------------------------------------------------- /Linux学习/Linux命令-cat命令.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Linux命令-cat命令 3 | copyright: true 4 | date: 2018-09-19 12:26:18 5 | tags: 6 | - Linux命令 7 | categories: Linux 8 | --- 9 | 10 | cat命令的用途是连接文件或标准输入并打印。这个命令常用来显示文件内容，或者将几个文件连接起来显示，或者从标准输入读取内容并显示，它常与重定向符号配合使用。 11 | 12 | ## 语法 13 | 14 | `cat(选项)(参数)` 15 | 16 | ## 选项 17 | 18 | ``` 19 | -A, --show-all 等价于 -vET 20 | -b, --number-nonblank 对非空输出行编号 21 | -e 等价于 -vE 22 | -E, --show-ends 在每行结束处显示 $ 23 | -n, --number 对输出的所有行编号,由1开始对所有输出的行数编号 24 | -s, --squeeze-blank 有连续两行以上的空白行，就代换为一行的空白行 25 | -t 与 -vT 等价 26 | -T, --show-tabs 将跳格字符显示为 ^I 27 | -u (被忽略) 28 | -v, --show-nonprinting 使用 ^ 和 M- 引用，除了 LFD 和 TAB 之外 29 | ``` 30 | 31 | ## 功能 32 | 33 | 1.一次显示整个文件:cat filename 34 | 35 | 2.从键盘创建一个文件:cat > filename 只能创建新文件,不能编辑已有文件. 36 | 37 | 3.将几个文件合并为一个文件:cat file1 file2 > file 38 | 39 | ## 常用范例 40 | 41 | 1）把 log2012.log 的文件内容加上行号后输入 log.log 这个文件里 42 | 43 | ``` 44 | # cat log.log 45 | [root@localhost test]# cat -n log2012.log > log.log 46 | # cat -n log.log 47 | 1 2012-01 48 | 2 2012-02 49 | ``` 50 | 51 | 2）使用here doc来生成文件 52 | 53 | ``` 54 | # cat >log.txt < Hello 56 | > World 57 | > Linux 58 | > PWD=$(pwd) 59 | > EOF 60 | # ls -l log.txt 61 | -rw-r--r-- 1 root root 37 10-28 17:07 log.txt 62 | # cat log.txt 63 | Hello 64 | World 65 | Linux 66 | PWD=/opt/soft/test 67 | ``` 68 | 69 | 说明： 70 | 71 | 注意粗体部分，here doc可以进行字符串替换。 72 | 73 | 备注： 74 | 75 | tac (反向列示) 76 | 77 | ``` 78 | # tac log.txt 79 | PWD=/opt/soft/test 80 | Linux 81 | World 82 | Hello 83 | ``` 84 | 85 | 说明： 86 | 87 | tac 是将 cat 反写过来，所以他的功能就跟 cat 相反， cat 是由第一行到最后一行连续显示在萤幕上，而 tac 则是由最后一行到第一行反向在萤幕上显示出来！ 88 | 89 | 参考链接： 90 | 91 | -------------------------------------------------------------------------------- /Linux学习/Linux命令-cd命令.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Linux命令-cd命令 3 | copyright: true 4 | date: 2018-09-10 12:46:13 5 | tags: 6 | - Linux命令 7 | categories: Linux 8 | --- 9 | 10 | Linux cd 命令可以说是Linux中最基本的命令语句，其他的命令语句要进行操作，都是建立在使用 cd 命令上的。所以，学习Linux 常用命令，首先就要学好 cd 命令的使用方法技巧。 11 | 12 | ## 语法 13 | 14 | ``` 15 | cd (选项) (参数) 16 | ``` 17 | 18 | ## 选项 19 | 20 | ``` 21 | -p 如果要切换到的目标目录是一个符号连接，直接切换到符号连接指向的目标目录 22 | -L 如果要切换的目标目录是一个符号的连接，直接切换到字符连接名代表的目录，而非符号连接所指向的目标目录。 23 | - 当仅实用"-"一个选项时，当前工作目录将被切换到环境变量"OLDPWD"所表示的目录。 24 | ``` 25 | 26 | ## 常用范例 27 | 28 | 1）进入系统根目录 29 | 30 | ``` 31 | cd / 32 | ``` 33 | 34 | 2）进入当前用户主目录 35 | 36 | ``` 37 | cd ~ 38 | cd 39 | ``` 40 | 41 | 3）跳转到指定目录 42 | 43 | ``` 44 | cd /opt/soft 45 | ``` 46 | 47 | 4）返回进入此目录之前所在的目录 48 | 49 | ``` 50 | cd - 51 | ``` -------------------------------------------------------------------------------- /Linux学习/Linux命令-chgrp命令.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Linux命令-chgrp命令 3 | copyright: true 4 | date: 2018-09-28 13:10:31 5 | tags: 6 | - Linux命令 7 | categories: Linux 8 | --- 9 | 10 | **chgrp命令**用来改变文件或目录所属的用户组。该命令用来改变指定文件所属的用户组。其中，组名可以是用户组的[id](http://man.linuxde.net/id)，也可以是用户组的组名。文件名可以 是由空格分开的要改变属组的文件列表，也可以是由通配符描述的文件集合。如果用户不是该文件的文件主或超级用户(root)，则不能改变该文件的组。 11 | 12 | 在UNIX系统家族里，文件或目录权限的掌控以拥有者及所属群组来管理。您可以使用chgrp指令去变更文件与目录的所属群组，设置方式采用群组名称或群组识别码皆可。 13 | 14 | ## 语法 15 | 16 | `chgrp(选项)(参数)` 17 | 18 | ## 选项 19 | 20 | ``` 21 | -c或——changes：效果类似“-v”参数，但仅回报更改的部分； 22 | -f或--quiet或——silent：不显示错误信息； 23 | -h或--no-dereference：只对符号连接的文件作修改，而不是该其他任何相关文件； 24 | -R或——recursive：递归处理，将指令目录下的所有文件及子目录一并处理； 25 | -v或——verbose：显示指令执行过程； 26 | --reference=<参考文件或目录>：把指定文件或目录的所属群组全部设成和参考文件或目录的所属群组相同； 27 | ``` 28 | 29 | ## 参数 30 | 31 | 组：指定新工作名称 32 | 33 | 文件： 指定要改变所属组的文件 34 | 35 | ## 常用实例 36 | 37 | 将`/usr/meng`及其子目录下的所有文件的用户组改为mengxin 38 | 39 | ``` 40 | chgrp -R mengxin /usr/meng 41 | ``` 42 | 43 | 转载地址： 44 | 45 | -------------------------------------------------------------------------------- /Linux学习/Linux命令-chmod命令.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Linux命令-chmod命令 3 | copyright: true 4 | date: 2018-09-26 20:16:09 5 | tags: 6 | - Linux命令 7 | categories: Linux 8 | --- 9 | 10 | chmod命令用于改变linux系统文件或目录的访问权限。用它控制文件或目录的访问权限。该命令有两种用法。一种是包含字母和操作符表达式的文字设定法；另一种是包含数字的数字设定法。 11 | 12 | 权限范围的表示法如下： 13 | 14 | `u` User，即文件或目录的拥有者； 15 | `g` Group，即文件或目录的所属群组； 16 | `o` Other，除了文件或目录拥有者或所属群组之外，其他用户皆属于这个范围； 17 | `a` All，即全部的用户，包含拥有者，所属群组以及其他用户； 18 | `r` 读取权限，数字代号为“4”; 19 | `w` 写入权限，数字代号为“2”； 20 | `x` 执行或切换权限，数字代号为“1”； 21 | `-` 不具任何权限，数字代号为“0”； 22 | `s` 特殊功能说明：变更文件或目录的权限。 23 | 24 | ## 语法 25 | 26 | `chmod(选项)(参数)` 27 | 28 | ## 选项 29 | 30 | ``` 31 | -c或——changes：效果类似“-v”参数，但仅回报更改的部分； 32 | -f或--quiet或——silent：不显示错误信息； 33 | -R或——recursive：递归处理，将指令目录下的所有文件及子目录一并处理； 34 | -v或——verbose：显示指令执行过程； 35 | ``` 36 | 37 | ## 参数 38 | 39 | 权限模式：指定文件的权限模式； 40 | 文件：要改变权限的文件。 41 | 42 | ## 知识扩展和实例 43 | 44 | Linux用 户分为：拥有者、组群(Group)、其他（other），Linux系统中，预设的情況下，系统中所有的帐号与一般身份使用者，以及root的相关信 息， 都是记录在`/etc/passwd`文件中。每个人的密码则是记录在`/etc/shadow`文件下。 此外，所有的组群名称记录在`/etc/group`內！ 45 | 46 | linux文件的用户权限的分析图 47 | 48 | ![](Linux命令-chmod命令/1.png) 49 | 50 | 例：rwx　rw-　r– 51 | 52 | r=读取属性　　//值＝4 53 | w=写入属性　　//值＝2 54 | x=执行属性　　//值＝1 55 | 56 | ``` 57 | chmod u+x,g+w f01　　//为文件f01设置自己可以执行，组员可以写入的权限 58 | chmod u=rwx,g=rw,o=r f01 59 | chmod 764 f01 60 | chmod a+x f01　　//对文件f01的u,g,o都设置可执行属性 61 | ``` 62 | 63 | 文件的属主和属组属性设置 64 | 65 | ``` 66 | chown user:market f01　　//把文件f01给uesr，添加到market组 67 | ll -d f1 查看目录f1的属性 68 | ``` 69 | 70 | 参考链接： 71 | 72 | 73 | 74 | -------------------------------------------------------------------------------- /Linux学习/Linux命令-chmod命令/1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/Linux学习/Linux命令-chmod命令/1.png -------------------------------------------------------------------------------- /Linux学习/Linux命令-crontab命令/1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/Linux学习/Linux命令-crontab命令/1.png -------------------------------------------------------------------------------- /Linux学习/Linux命令-etc-group文件详解.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Linux命令-/etc/group文件详解 3 | copyright: true 4 | date: 2018-09-28 14:21:35 5 | tags: 6 | - Linux命令 7 | categories: Linux 8 | --- 9 | 10 | Linux /etc/group文件与/etc/passwd和/etc/shadow文件都是有关于系统管理员对用户和用户组管理时相关的文件。linux /etc/group文件是有关于系统管理员对用户和用户组管理的文件,linux用户组的所有信息都存放在/etc/group文件中。具有某种共同特征的用户集合起来就是用户组（Group）。用户组（Group）配置文件主要有 /etc/group和/etc/gshadow，其中/etc/gshadow是/etc/group的加密信息文件。 11 | 12 | 将用户分组是Linux系统中对用户进行管理及控制访问权限的一种手段。每个用户都属于某个用户组；一个组中可以有多个用户，一个用户也可以属于不同的组。当一个用户同时是多个组中的成员时，在/etc/passwd文件中记录的是用户所属的主组，也就是登录时所属的默认组，而其他组称为附加组。 13 | 14 | 用户组的所有信息都存放在/etc/group文件中。此文件的格式是由冒号(:)隔开若干个字段，这些字段具体如下： 15 | 16 | 组名:口令:组标识号:组内用户列表 17 | 18 | 具体解释 19 | 20 | ## 组名： 21 | 22 | 组名是用户组的名称，由字母或数字构成。与/etc/passwd中的登录名一样，组名不应重复。 23 | 24 | ## 口令： 25 | 26 | 口令字段存放的是用户组加密后的口令字。一般Linux系统的用户组都没有口令，即这个字段一般为空，或者是*。 27 | 28 | ## 组标识号： 29 | 30 | 组标识号与用户标识号类似，也是一个整数，被系统内部用来标识组。别称GID. 31 | 32 | ## 组内用户列表： 33 | 34 | 属于这个组的所有用户的列表，不同用户之间用逗号(,)分隔。这个用户组可能是用户的主组，也可能是附加组。 35 | 36 | ## 使用实例 37 | 38 | ``` 39 | # cat /etc/group 40 | root:x:0:root,linuxsir 41 | bin:x:1:root,bin,daemon 42 | daemon:x:2:root,bin,daemon 43 | sys:x:3:root,bin 44 | ``` 45 | 46 | 说明： 47 | 48 | 我们以root:\x:0:root,linuxsir 为例： 用户组root，x是密码段，表示没有设置密码，GID是0,root用户组下包括root、linuxsir以及GID为0的其它用户。 49 | 50 | 转载链接： 51 | 52 | -------------------------------------------------------------------------------- /Linux学习/Linux命令-head命令.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Linux命令-head命令 3 | copyright: true 4 | date: 2018-09-21 13:51:10 5 | tags: 6 | - Linux命令 7 | categories: Linux 8 | --- 9 | 10 | head 与 tail 就像它的名字一样的浅显易懂，它是用来显示开头或结尾某个数量的文字区块，head 用来显示档案的开头至标准输出中，而 tail 想当然尔就是看档案的结尾。 11 | 12 | ## 语法 13 | 14 | `head(选项)(参数)` 15 | 16 | ## 选项 17 | 18 | ``` 19 | -n<数字>：指定显示头部内容的行数； 20 | -c<字符数>：指定显示头部内容的字符数； 21 | -v：总是显示文件名的头信息； 22 | -q：不显示文件名的头信息。 23 | ``` 24 | 25 | ## 功能 26 | 27 | head 用来显示档案的开头至标准输出中，默认head命令打印其相应文件的开头10行。 28 | 29 | ## 常用范例 30 | 31 | 1）显示文件的前n行 32 | 33 | ``` 34 | # cat log2014.log 35 | 2014-01 36 | 2014-02 37 | 2014-03 38 | 2014-04 39 | 2014-05 40 | 2014-06 41 | 2014-07 42 | 2014-08 43 | 2014-09 44 | 2014-10 45 | 2014-11 46 | 2014-12 47 | # head -n 5 log2014.log 48 | 2014-01 49 | 2014-02 50 | 2014-03 51 | 2014-04 52 | 2014-05 53 | ``` 54 | 55 | 2）显示文件前n个字节 56 | 57 | ``` 58 | # head -c 20 log2014.log 59 | 2014-01 60 | 2014-02 61 | 2014 62 | ``` 63 | 64 | 3）文件的除了最后n个字节以外的内容 65 | 66 | ``` 67 | # head -c -32 log2014.log 68 | 2014-01 69 | 2014-02 70 | 2014-03 71 | 2014-04 72 | 2014-05 73 | 2014-06 74 | 2014-07 75 | 2014-08 76 | 2014-09 77 | 2014-10 78 | 2014-11 79 | 2014-12 80 | ``` 81 | 82 | 4）输出文件除了最后n行的全部内容 83 | 84 | ``` 85 | # head -n -6 log2014.log 86 | 2014-01 87 | 2014-02 88 | 2014-03 89 | 2014-04 90 | 2014-05 91 | 2014-06 92 | 2014-07 93 | ``` 94 | 95 | 参考链接： 96 | 97 | 98 | 99 | -------------------------------------------------------------------------------- /Linux学习/Linux命令-ldd命令.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Linux命令-ldd命令 3 | copyright: true 4 | date: 2018-10-10 14:36:01 5 | tags: 6 | - Linux命令 7 | categories: Linux 8 | --- 9 | 10 | ldd用于打印程序或者库文件所依赖的共享库列表。 11 | 12 | ## 语法 13 | 14 | `ldd(选项)(参数)` 15 | 16 | ## 选项 17 | 18 | ``` 19 | --version：打印指令版本号； 20 | -v：详细信息模式，打印所有相关信息； 21 | -u：打印未使用的直接依赖； 22 | -d：执行重定位和报告任何丢失的对象； 23 | -r：执行数据对象和函数的重定位，并且报告任何丢失的对象和函数； 24 | --help：显示帮助信息。 25 | ``` 26 | 27 | ## 参数 28 | 29 | 文件：指定可执行程序或者文库。 30 | 31 | ## 其他 32 | 33 | 1) 34 | 35 | 　　ldd不是一个可执行程序，而只是一个shell脚本 ldd能够显示可执行模块的dependency(所属)(所属)，其原理是通过设置一系列的环境变量，如下：LD_TRACE_LOADED_OBJECTS、LD_WARN、LD_BIND_NOW、LD_LIBRARY_VERSION、LD_VERBOSE等。当LD_TRACE_LOADED_OBJECTS环境变量不为空时，任何可执行程序在运行时，它都会只显示模块的dependency(所属)，而程序并不真正执行。要不你可以在shell终端测试一下，如下： export LD_TRACE_LOADED_OBJECTS=1 再执行任何的程序，如ls等，看看程序的运行结果。 36 | 37 | 2) 38 | 39 | 　　ldd显示可执行模块的dependency(所属)的工作原理，其实质是通过ld-linux.so（elf动态库的装载器）来实现的。我们知道，ld-linux.so模块会先于executable模块程序工作，并获得控制权，因此当上述的那些环境变量被设置时，ld-linux.so选择了显示可执行模块的dependency(所属)。 实际上可以直接执行ld-linux.so模块，如：/lib/ld-linux.so.2 –list program（这相当于ldd program）。 40 | 41 | 转载链接： 42 | 43 | -------------------------------------------------------------------------------- /Linux学习/Linux命令-locate命令.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Linux命令-locate命令 3 | copyright: true 4 | date: 2018-09-23 12:49:35 5 | tags: 6 | - Linux命令 7 | categories: Linux 8 | --- 9 | 10 | locate 让使用者可以很快速的搜寻档案系统内是否有指定的档案。其方法是先建立一个包括系统内所有档案名称及路径的数据库，之后当寻找时就只需查询这个数据库，而不必实际深入档案系统之中了。在一般的 distribution 之中，数据库的建立都被放在 crontab 中自动执行。 11 | 12 | ## 语法 13 | 14 | `locate (选项)(参数)` 15 | 16 | ## 选项 17 | 18 | ``` 19 | -e 将排除在寻找的范围之外。 20 | -1 如果 是 1．则启动安全模式。在安全模式下，使用者不会看到权限无法看到 的档案。这会始速度减慢，因为 locate 必须至实际的档案系统中取得档案的 权限资料。 21 | -f 将特定的档案系统排除在外，例如我们没有到理要把 proc 档案系统中的档案 放在资料库中 22 | -q 安静模式，不会显示任何错误讯息 23 | -n 至多显示 n个输出 24 | -r 使用正规运算式 做寻找的条件 25 | -o 指定资料库存的名称 26 | -d 指定资料库的路径 27 | -h 显示辅助讯息 28 | -V 显示程式的版本讯息 29 | ``` 30 | 31 | ## 参数 32 | 33 | 查找字符串：要查找的文件名中含有的字符串。 34 | 35 | ## 功能 36 | 37 | locate命令可以在搜寻数据库是快速找到档案，数据库有updatedb程序来更新，updatedb是由cron daemon周期性建立的，locate命令在搜寻数据库时比由整个由硬盘来搜寻资料来得快，但locate所找到的档案若是最近才建立或刚更名的，可能会找不到，在内定值中，updatedb每天会跑一次，可以由修改crontab来更新设定值。（/etc/crontab） 38 | 39 | locate指令和find找寻档案的功能类似，但locate是透过update程序将硬盘中的所有档案盒目录资料先建立一个索引数据库，在执行locate时直接找该索引，查询速度会较快，索引数据库一般是由操作系统管理，但也可以直接下达update强迫系统立即修改索引数据库。 40 | 41 | ## 常用范例 42 | 43 | 1）查找和pwd相关的所有文件 44 | 45 | ``` 46 | # locate pwd 47 | /bin/pwd 48 | /etc/.pwd.lock 49 | /sbin/unix_chkpwd 50 | /usr/bin/pwdx 51 | /usr/include/pwd.h 52 | /usr/lib/python2.7/dist-packages/twisted/python/fakepwd.py 53 | ``` 54 | 55 | 2） 搜索etc目录下所有以sh开头的文件 56 | 57 | ``` 58 | # locate /etc/sh 59 | /etc/shadow 60 | /etc/shadow- 61 | /etc/shells 62 | ``` 63 | 64 | 3）搜索etc目录下，所有以m开头的文件 65 | 66 | ``` 67 | # locate /etc/m 68 | /etc/magic 69 | /etc/magic.mime 70 | /etc/mailcap 71 | /etc/mailcap.order 72 | ``` 73 | 74 | 参考链接： 75 | 76 | 77 | 78 | -------------------------------------------------------------------------------- /Linux学习/Linux命令-nl命令.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Linux命令-nl命令 3 | copyright: true 4 | date: 2018-09-19 13:16:31 5 | tags: 6 | - Linux命令 7 | categories: Linux 8 | --- 9 | 10 | **nl命令**读取 file 参数（缺省情况下标准输入），计算输入中的行号，将计算过的行号写入标准输出。在输出中，nl命令根据您在命令行中指定的标志来计算左边的行。输入文本必须写在逻辑页中。每个逻辑页有头、主体和页脚节（可以有空节）。除非使用`-p`选项，nl 命令在每个逻辑页开始的地方重新设置行号。可以单独为头、主体和页脚节设置行计算标志（例如，头和页脚行可以被计算然而文本行不能）。其默认的结果与`cat -n`有点不太一样， nl 可以将行号做比较多的显示设计，包括位数与是否自动补齐0等等的功能。 11 | 12 | ## 语法 13 | 14 | `nl (选项) (参数)` 15 | 16 | ## 选项 17 | 18 | ``` 19 | -b ：指定行号指定的方式，主要有两种： 20 | -b a ：表示不论是否为空行，也同样列出行号(类似 cat -n)； 21 | -b t ：如果有空行，空的那一行不要列出行号(默认值)； 22 | -n ：列出行号表示的方法，主要有三种： 23 | -n ln ：行号在萤幕的最左方显示； 24 | -n rn ：行号在自己栏位的最右方显示，且不加 0 ； 25 | -n rz ：行号在自己栏位的最右方显示，且加 0 ； 26 | -w ：行号栏位的占用的位数。 27 | -p ：在逻辑定界符处不重新开始计算。 28 | ``` 29 | 30 | ## 常用范例 31 | 32 | 1）用 nl 列出 log2015.log 的内容： 33 | 34 | ``` 35 | # nl log2015.log 36 | 1 2015-01 37 | 2 2015-02 38 | 39 | 40 | 3 ====== 41 | ``` 42 | 43 | 说明：文件中的空白行，nl 不会加上行号 44 | 45 | 2）用 nl 列出 log2015.log 的内容，空本行也加上行号： 46 | 47 | ``` 48 | # nl -b a log2015.log 49 | 1 2015-01 50 | 2 2015-02 51 | 3 52 | 4 53 | 5 ====== 54 | ``` 55 | 56 | 3）让行号前面自动补上0，统一输出格式： 57 | 58 | ``` 59 | # nl -b a -n rz log2015.log 60 | 000001 2015-01 61 | 000002 2015-02 62 | 000003 2015-03 63 | 000004 2015-04 64 | 000005 2015-05 65 | 000006 2015-06 66 | 000007 2015-07 67 | 000008 2015-08 68 | 000009 2015-09 69 | 000010 2015-10 70 | 000011 2015-11 71 | 000012 2015-12 72 | 000013 ======= 73 | 74 | # nl -b a -n rz -w 3 log2015.log 75 | 001 2015-01 76 | 002 2015-02 77 | 003 2015-03 78 | 004 2015-04 79 | 005 2015-05 80 | 006 2015-06 81 | 007 2015-07 82 | 008 2015-08 83 | 009 2015-09 84 | 010 2015-10 85 | 011 2015-11 86 | 012 2015-12 87 | 013 ======= 88 | ``` 89 | 90 | 说明：`nl -b a -n rz`命令行号默认为六位，要调整位数可以加上参数`-w 3`调整为3位。 91 | 92 | 参考链接： 93 | 94 | -------------------------------------------------------------------------------- /Linux学习/Linux命令-pwd命令.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Linux命令-pwd命令 3 | copyright: true 4 | date: 2018-09-10 12:48:20 5 | tags: 6 | - Linux命令 7 | categories: Linux 8 | --- 9 | 10 | Linux中用 pwd 命令来查看”当前工作目录“的完整路径。 简单得说，每当你在终端进行操作时，你都会有一个当前工作目录。 在不太确定当前位置时，就会使用pwd来判定当前目录在文件系统内的确切位置。 11 | 12 | ## 语法 13 | 14 | ``` 15 | pwd（选项） 16 | ``` 17 | 18 | ## 选项 19 | 20 | ``` 21 | -L 目录连接链接时，输出连接路径 22 | -P 输出物理路径 23 | --help：显示帮助信息； 24 | --version：显示版本信息。 25 | ``` 26 | 27 | ## 常用范例 28 | 29 | 显示当前位置 30 | 31 | ``` 32 | pwd 33 | ``` 34 | 35 | -------------------------------------------------------------------------------- /Linux学习/Linux命令-rm.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Linux命令-rm 3 | copyright: true 4 | date: 2018-09-14 13:22:49 5 | tags: 6 | - Linux命令 7 | categories: Linux 8 | --- 9 | 10 | rm命令可以删除一个目录中的一个或多个文件或目录，也可以将某个目录及其下属的所有文件及其子目录均删除掉。对于链接文件，只是删除整个链接文件，而原有文件保持不变。 11 | 12 | rm是一个危险的命令，使用的时候要特别当心，尤其对于新手，否则整个系统就会毁在这个命令（比如在/（根目录）下执行rm * -rf）。所以，我们在执行rm之前最好先确认一下在哪个目录，到底要删除什么东西，操作时保持高度清醒的头脑。 13 | 14 | ## 语法 15 | 16 | `rm (选项)(参数)` 17 | 18 | ## 选项 19 | 20 | ``` 21 | -d：直接把欲删除的目录的硬连接数据删除成0，删除该目录； 22 | -f：强制删除文件或目录； 23 | -i：删除已有文件或目录之前先询问用户； 24 | -r或-R：递归处理，将指定目录下的所有文件与子目录一并处理； 25 | --preserve-root：不对根目录进行递归操作； 26 | -v：显示指令的详细执行过程。 27 | ``` 28 | 29 | ## 参数 30 | 31 | 文件：指定被删除的文件列表，如果参数中含有目录，则必须加上`-r`或者`-R`选项。 32 | 33 | ## 常用范例 34 | 35 | 1）删除文件file，系统会先询问是否删除。 36 | 37 | ``` 38 | # rm log.log 39 | rm：是否删除 一般文件 “log.log”? y 40 | ``` 41 | 42 | 输入rm log.log命令后，系统会询问是否删除，输入y后就会删除文件，不想删除则数据n。 43 | 44 | 2）强行删除file，系统不再提示 45 | 46 | ``` 47 | rm -f log1.log 48 | ``` 49 | 50 | 3）删除任何.log文件；删除前逐一询问确认 51 | 52 | ``` 53 | rm -i *.log 54 | ``` 55 | 56 | 4）将 test1子目录及子目录中所有档案删除 57 | 58 | ``` 59 | rm -r test1 60 | ``` -------------------------------------------------------------------------------- /Linux学习/Linux命令-top命令/1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/Linux学习/Linux命令-top命令/1.png -------------------------------------------------------------------------------- /Linux学习/Linux命令-top命令/2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/Linux学习/Linux命令-top命令/2.png -------------------------------------------------------------------------------- /Linux学习/Linux命令-top命令/3.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/Linux学习/Linux命令-top命令/3.png -------------------------------------------------------------------------------- /Linux学习/Linux命令-top命令/4.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/Linux学习/Linux命令-top命令/4.png -------------------------------------------------------------------------------- /Linux学习/Linux命令-top命令/5.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/Linux学习/Linux命令-top命令/5.png -------------------------------------------------------------------------------- /Linux学习/Linux命令-whereis命令.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Linux命令-whereis命令 3 | copyright: true 4 | date: 2018-09-22 13:41:24 5 | tags: 6 | - Linux命令 7 | categories: Linux 8 | --- 9 | 10 | **whereis命令**用来定位指令的二进制程序、源代码文件和man手册页等相关文件的路径。 11 | 12 | whereis命令只能用于程序名的搜索，而且只搜索二进制文件（参数-b）、man说明文件（参数-m）和源代码文件（参数-s）。如果省略参数，则返回所有信息。 13 | 14 | 和find相比，whereis查找的速度非常快，这是因为linux系统会将 系统内的所有文件都记录在一个数据库文件中，当使用whereis和下面即将介绍的locate时，会从数据库中查找数据，而不是像find命令那样，通 过遍历硬盘来查找，效率自然会很高。 但是该数据库文件并不是实时更新，默认情况下时一星期更新一次，因此，我们在用whereis和locate 查找文件时，有时会找到已经被删除的数据，或者刚刚建立文件，却无法查找到，原因就是因为数据库文件没有被更新。 15 | 16 | ## 语法 17 | 18 | `whereis(选项)(参数)` 19 | 20 | ## 选项 21 | 22 | ``` 23 | -b 定位可执行文件。 24 | -m 定位帮助文件。 25 | -s 定位源代码文件。 26 | -u 搜索默认路径下除可执行文件、源代码文件、帮助文件以外的其它文件。 27 | -B 指定搜索可执行文件的路径。 28 | -M 指定搜索帮助文件的路径。 29 | -S 指定搜索源代码文件的路径。 30 | ``` 31 | 32 | ## 常用范例 33 | 34 | 1）将和**文件相关的文件都查找出来 35 | 36 | ``` 37 | # whereis svn 38 | svn: /usr/bin/svn /usr/local/svn /usr/share/man/man1/svn.1.gz 39 | ``` 40 | 41 | 说明： 42 | 43 | tomcat没安装，找不出来，svn安装找出了很多相关文件 44 | 45 | 2）只将二进制文件 查找出来 46 | 47 | ``` 48 | # whereis -b svn 49 | svn: /usr/bin/svn /usr/local/svn 50 | ``` 51 | 52 | 说明： 53 | 54 | whereis -m svn 查出说明文档路径，whereis -s svn 找source源文件。 -------------------------------------------------------------------------------- /Linux学习/Linux命令-which命令.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Linux命令-which命令 3 | copyright: true 4 | date: 2018-09-22 12:48:15 5 | tags: 6 | - Linux命令 7 | categories: Linux 8 | --- 9 | 10 | 我们经常在linux要查找某个文件，但不知道放在哪里了，可以使用下面的一些命令来搜索： 11 | which 查看可执行文件的位置。 12 | whereis 查看文件的位置。 13 | locate 配合数据库查看文件位置。 14 | find 实际搜寻硬盘查询文件名称。 15 | 16 | which命令的作用是，在PATH变量指定的路径中，搜索某个系统命令的位置，并且返回第一个搜索结果。也就是说，使用which命令，就可以看到某个系统命令是否存在，以及执行的到底是哪一个位置的命令。 17 | 18 | ## 语法 19 | 20 | `which 可执行文件名称` 21 | 22 | ## 选项 23 | 24 | ``` 25 | -n 　指定文件名长度，指定的长度必须大于或等于所有文件中最长的文件名。 26 | -p 　与-n参数相同，但此处的包括了文件的路径。 27 | -w 　指定输出时栏位的宽度。 28 | -V 　显示版本信息 29 | ``` 30 | 31 | ## 功能 32 | 33 | which指令会在PATH变量指定的路径中，搜索某个系统命令的位置，并且返回第一个搜索结果。 34 | 35 | ## 常用范例 36 | 37 | 1）查找文件、显示命令路径 38 | 39 | ``` 40 | # which pwd 41 | /bin/pwd 42 | ``` 43 | 44 | 参考链接： 45 | 46 | -------------------------------------------------------------------------------- /goland使用介绍/1.介绍.md: -------------------------------------------------------------------------------- 1 | # goland介绍 2 | Goland官方地址：[http://www.jetbrains.com/go/](http://www.jetbrains.com/go/) 3 | -------------------------------------------------------------------------------- /goland使用介绍/2.安装.md: -------------------------------------------------------------------------------- 1 | # goland安装 2 | 3 | ## 下载 4 | Windows下载地址：[https://download.jetbrains.com/go/goland-2018.2.1.exe](https://download.jetbrains.com/go/goland-2018.2.1.exe)
5 | macOs下载地址：[https://download-cf.jetbrains.com/go/goland-2018.2.1.dmg](https://download-cf.jetbrains.com/go/goland-2018.2.1.dmg)
6 | Linux下载地址：[https://download-cf.jetbrains.com/go/goland-2018.2.1.tar.gz](https://download-cf.jetbrains.com/go/goland-2018.2.1.tar.gz)
7 | 8 | ## 安装 9 | Windows安装：直接双击golang-xxxx.xx.xx.exe，根据安装向导即可完成安装
10 | macOs安装：直接双击golang-xxxx.xx.xx.dmg,然后将golang程序拖入APP即可完成安装
11 | Linux安装：在文件目录下执行tar -zxvf golang-xxxx.xx.xx.tar.gz将tar包进行解压，然后进入golang，执行./goland 启动程序， 12 | 然后将goland程序锁定在启动栏上 13 | 14 | ## 激活 15 | 由于官方的Goland软件，免费使用期限是30天。如果你不购买产品的话，就需要不断的卸载和重装软件才能使用。不过要是您的资金允许的话，可以去http://www.jetbrains.com/go/buy/#edition=commercial 购买正版。 如果您是学生或者老师的话，可以去https://www.jetbrains.com/zh/student/，申请账号，注册成功后就可以免费使用JetBrains的所有产品。
16 | 下面是免激活码的使用方法： 17 | 1. 首先去官网下载30天试用版本，在本地安装。成功后打开工具。这时页面会提示你选择哪种使用方式：JetBrains账号、激活码和授权服务器选项。然后选择License server 将授权服务器填 http://idea.imsxm.com/ 写进去，确定即可
18 | 2. 也可以打开软件，在菜单栏中Help->register。就可以切换到上图页面。上图是注册页面。License server address栏中输入下面任一可用服务器地址接口
19 | http://idea.imsxm.com/
20 | http://idea.youbbs.org
21 | http://btsha.com:41017
22 | http://idea.toocruel.net
23 | http://active.chinapyg.com/
24 | http://idea.congm.in
25 | http://idea.iteblog.com/key.php
26 | http://xdouble.cn:8888/
27 | -------------------------------------------------------------------------------- /goland使用介绍/3.常用设置.md: -------------------------------------------------------------------------------- 1 | ### 1.Ctrl+s后自动格式化代码 2 | > File --> Settings Tools --> File Watchers --> + --> go fmt 3 | 4 | ### 2.快捷键设置 5 | > File --> Setting --> KeyMap -------------------------------------------------------------------------------- /goland使用介绍/4.快捷键.md: -------------------------------------------------------------------------------- 1 | ## 文件相关快捷键： 2 | CTRL+E，打开最近浏览过的文件。
3 | CTRL+SHIFT+E，打开最近更改的文件。
4 | CTRL+N，可以快速打开struct结构体。
5 | CTRL+SHIFT+N，可以快速打开文件。
6 | 7 | ## 代码格式化： 8 | CTRL+ALT+T，可以把代码包在一个块内，例如if{…}else{…}。
9 | CTRL+ALT+L，格式化代码。
10 | CTRL+空格，代码提示。
11 | CTRL+/，单行注释。CTRL+SHIFT+/，进行多行注释。
12 | CTRL+B，快速打开光标处的结构体或方法（跳转到定义处）。
13 | CTRL+“+/-”，可以将当前方法进行展开或折叠。
14 | 15 | ## 查找和定位 16 | CTRL+R，替换文本。
17 | CTRL+F，查找文本。
18 | CTRL+SHIFT+F，进行全局查找。
19 | CTRL+G，快速定位到某行。
20 | 21 | ## 代码编辑 22 | ALT+Q，可以看到当前方法的声明。
23 | CTRL+Backspace，按单词进行删除。
24 | SHIFT+ENTER，可以向下插入新行，即使光标在当前行的中间。
25 | CTRL+X，删除当前光标所在行。
26 | CTRL+D，复制当前光标所在行。
27 | ALT+SHIFT+UP/DOWN，可以将光标所在行的代码上下移动。
28 | CTRL+SHIFT+U，可以将选中内容进行大小写转化。
29 | CTRL+SHIFT+SPACE，自动补全代码
30 | ALT+ENTER 检查并修复
31 | 32 | CTRL+O，实现接口的所有方法
33 | 34 | ## 界面切换 35 | ALT+1，打开/关闭Project窗口
36 | ALT+2，打开/关闭Favorites窗口
37 | ALT+7，打开文件方法列表
38 | 39 | 40 | 41 | 42 | -------------------------------------------------------------------------------- /goland使用介绍/5.插件安装.md: -------------------------------------------------------------------------------- 1 | ## markdown插件 2 | 插件功能：在golang编辑器中编辑markdown文档，并实时查看 3 | File > setting > 搜索markdown 然后完成安装 4 | -------------------------------------------------------------------------------- /goland使用介绍/6.故障排除.md: -------------------------------------------------------------------------------- 1 | #### 1、goland打开后，总是显示`Scaning files to index...` 导致代码没有提示，测试函数无法执行 2 | 这个是在加载项目，项目比较大或则计算机处理能力此时比较差，真的需要等待。 -------------------------------------------------------------------------------- /goland使用介绍/README.md: -------------------------------------------------------------------------------- 1 | ## golang使用指南 2 | 3 | * [1.goland介绍](1.介绍.md)
4 | * [2.goland安装](2.安装.md)
5 | * [3.常用设置](3.常用设置.md)
6 | * [4.快捷键](4.快捷键.md)
7 | * [5.插件安装](5.插件安装.md)
8 | * [6.故障排除](6.故障排除.md)
9 | -------------------------------------------------------------------------------- /go基础学习所有代码例题/01学习/代码demo/01第一个go语言程序.go: -------------------------------------------------------------------------------- 1 | //注释 行注释 可以注释一行 2 | 3 | /* 4 | 快注释 5 | 可以注释多行 6 | */ 7 | //程序所属包 8 | package main 9 | 10 | //导入系统fmt包 format 格式化 导入格式化输入输出包 11 | import "fmt" 12 | 13 | //func 函数格式 main 函数名 程序有且只有一个主函数（main）main 是程序的住入口 14 | //()括起来的成为函数的参数列表 可以是0个 也可以是多个 （变量名 数据类型, 变量名 数据类型）{}代码体 程序体 函数体 15 | func main01(){ 16 | //在代码中 一条语句可以写在多行 但是多条语句不能写在一行 17 | //打印输出 fmt.Println ""引起来的成为字符串 18 | fmt.Println("hello world!") 19 | fmt.Println("字符串") 20 | fmt.Println("你瞅啥") 21 | 22 | } 23 | 24 | 25 | -------------------------------------------------------------------------------- /go基础学习所有代码例题/01学习/代码demo/02变量的定义和使用.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main0201() { 6 | //变量 在程序运行过程中 其值给以发生改变的量 成为变量 7 | //变量的定义和使用 8 | //格式 var 变量名 数据类型 9 | //int 表示整型数据 10 | 11 | //var a int //声明 是没有具体的在 默认值为0 12 | //为变量赋值 = 称为赋值运算符 13 | //a = 10 14 | 15 | var a int = 10 //定义 16 | //变量参与程序计算 17 | a = a + 20 18 | fmt.Println(a) 19 | } 20 | func main0202() { 21 | //计算圆的面积和周长 22 | //面积 s=PI*r*r 23 | //周长 l=2*PI*r 24 | 25 | //PI 值为3.14 26 | //浮点型 可以存储带小数的数据 float64（小数位数为15位） float32（小数位数为7位） 27 | //默认小数位数保留6位为准确数据 28 | //浮点型数据都不是一个精准的数据 29 | var PI float64 = 3.14 30 | //半径 31 | var r float64 = 2.6 32 | //面积 33 | var s float64 34 | //周长 35 | var l float64 36 | //计算面积 37 | s = PI * r * r 38 | //计算周长 39 | l = PI * r * 2 40 | 41 | fmt.Println(s) 42 | fmt.Println(l) 43 | 44 | } 45 | -------------------------------------------------------------------------------- /go基础学习所有代码例题/01学习/代码demo/03自动推导类型.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main0301() { 6 | //自动推导类型 7 | //在一个函数范围内变量名不允许重名 8 | //var a int = 10 9 | a:=10//根据数据的值 来确定变量的类型 10 | b:=3.14 11 | fmt.Println(a) 12 | fmt.Println(b) 13 | //%T 是一个占位符表示输出变量对应的数据类型 14 | fmt.Printf("%T\n",a)//int 15 | fmt.Printf("%T\n",b)//float64 16 | 17 | } 18 | func main0302(){ 19 | a:=10 20 | b:=20 21 | 22 | //var c int 23 | //交换变量a b 的值 24 | //c:=a//自动推导类型创建变量 25 | //c=a 26 | //a=b 27 | //b=c 28 | 29 | a=a+b 30 | b=a-b 31 | a=a-b 32 | 33 | fmt.Println("a=",a) 34 | fmt.Println("b=",b) 35 | } -------------------------------------------------------------------------------- /go基础学习所有代码例题/01学习/代码demo/04多重赋值和匿名变量.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main0401() { 6 | //多重赋值 7 | //在多重赋值时变量和值的个数一一对应 8 | //在多重赋值时变量的类型可以不相同 9 | //a:=10 10 | //b:=20 11 | //c:=30 12 | 13 | //1、编辑时异常 14 | //2、编译时异常 15 | //3、运行时异常 16 | //a,b,c:=10,20,30 17 | a,b,c:=10,20.345,"你瞅啥" 18 | fmt.Println(a,b,c) 19 | } 20 | 21 | 22 | func main0402(){ 23 | //_表示匿名变量 数据不接收 24 | a,_,c:=10,20,30 25 | 26 | fmt.Println(a,c) 27 | } 28 | func main(){ 29 | a:=10 30 | b:=20 31 | 32 | //通过多重赋值 33 | a,b=b,a 34 | 35 | fmt.Println(a) 36 | fmt.Println(b) 37 | } -------------------------------------------------------------------------------- /go基础学习所有代码例题/01学习/代码demo/05格式输出.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main0501() { 6 | //fmt.Print 如果没有ln打印数据不会换行 7 | fmt.Print("打印数据") 8 | 9 | fmt.Println("赢取白富美") 10 | fmt.Print("整型数据") 11 | } 12 | func main0502(){ 13 | a:=10 14 | //\n 是一个转义字符 表示换行 15 | fmt.Printf("%T\n",a) 16 | //%d是一个占位符 表示输出一个10进制整型数据 17 | fmt.Printf("%d\n",a) 18 | b:=3.595 19 | //%f是一个占位符 表示输出一个浮点型数据 默认小数位数保留6位 20 | fmt.Printf("%f\n",b) 21 | //%.2f表示数据保留两位小数 会对第三位小数四舍五入 22 | fmt.Printf("%.2f\n",b) 23 | 24 | c:="hello world" 25 | fmt.Printf("%T\n",c)//string 字符串类型 26 | //%s是一个占位符表示输出一个字符串类型数据 27 | fmt.Printf("%s\n",c) 28 | 29 | d:='a' 30 | fmt.Printf("%T\n",d)//byte 字符类型 int32 ASCII 对应整数的值 31 | //%c是一个占位符表示输出一个字符类型数据 32 | fmt.Printf("%c\n",d) 33 | 34 | e:=true//false true 35 | fmt.Printf("%T\n",e)//bool 布尔类型 用作于条件判断 36 | //%t是一个占位符表示输出一个bool类型数据 37 | fmt.Printf("%t\n",e) 38 | } 39 | func main(){ 40 | name:="法师" 41 | age:=31 42 | sex:="男" 43 | 44 | fmt.Printf("大叫好，我叫%s，我今年%d岁了，我是%s生\n",name,age,sex) 45 | } -------------------------------------------------------------------------------- /go基础学习所有代码例题/01学习/代码demo/06格式输出.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main0601() { 6 | var score int 7 | //通过键盘为score赋值 & 取地址运算符 8 | //fmt.Scan(&score) 9 | fmt.Scanf("%d", &score) 10 | fmt.Println(score) 11 | } 12 | func main() { 13 | //通过键盘输入三门成绩 计算总成绩和平均成绩 14 | var c, m, e int 15 | 16 | //通过键盘为三门成绩赋值 数据间隔空格 或者回车 17 | //fmt.Scan(&c, &m, &e) 18 | fmt.Scanf("%d%d%d", &c, &m, &e) 19 | //计算总成绩 20 | sum := c + m + e 21 | 22 | fmt.Println("总成绩：", sum) 23 | fmt.Println("平均成绩： ", sum/3) //整型数据相除 得到的结果是整型数据 24 | 25 | 26 | 27 | } 28 | -------------------------------------------------------------------------------- /go基础学习所有代码例题/01学习/相关资料及笔记/01内存数据存储.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/go基础学习所有代码例题/01学习/相关资料及笔记/01内存数据存储.png -------------------------------------------------------------------------------- /go基础学习所有代码例题/01学习/相关资料及笔记/02变量交换.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/go基础学习所有代码例题/01学习/相关资料及笔记/02变量交换.png -------------------------------------------------------------------------------- /go基础学习所有代码例题/01学习/相关资料及笔记/笔记.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/go基础学习所有代码例题/01学习/相关资料及笔记/笔记.txt -------------------------------------------------------------------------------- /go基础学习所有代码例题/02学习/代码demo/01数据类型.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main0101() { 6 | //数据类型 7 | 8 | //var 变量名 数据类型 9 | //bool 10 | 11 | var a bool //声明 默认值为 false 12 | //bool类型值只有两个 真 true 假 false 13 | a=true 14 | 15 | fmt.Println(a) 16 | //%t是一个占位符 表示输出一个bool类型的值 17 | fmt.Printf("%t",a) 18 | 19 | } 20 | func main0102(){ 21 | //整型数据 22 | var a int 23 | //当赋值给int8时超出了取值范围会报错 24 | //与符号数据取值范围 25 | //-2^（8-1）~ 2^(8-1)-1 26 | a=140 27 | fmt.Println(a) 28 | 29 | //无符号整型数据定义 30 | //u -> unsigned 31 | // 0 ~ (2^8)-1 32 | //无符号只能存储0和正整数 33 | var b uint8 34 | //b=0 35 | fmt.Println(b) 36 | 37 | } 38 | 39 | func main0103(){ 40 | //浮点型数据定义和使用 41 | //浮点型数据小数位数都是不精准的 float32 默认保留7位 42 | var a float32 43 | a=3.14//3.140000000124 44 | a=a*a 45 | fmt.Println(a) 46 | //%f是一个占位符 表示输出浮点数据 默认保留六位小数 47 | //%.2f小数点默认保留两位 会对第三位四舍五入 48 | //fmt.Printf("%.2f",a) 49 | 50 | 51 | //float64 小数位数默认保留15位 比float32更精准 52 | //var b float64 =3.14 53 | b:=3.14//float64 54 | b=b*b 55 | fmt.Println(b) 56 | fmt.Printf("%.2f",a) 57 | 58 | } 59 | 60 | func main(){ 61 | //字符类型定义和使用 62 | //字符型 63 | //var a byte //默认值为0 64 | //a:='0' 65 | //a='a' 66 | //a='0'//字符0 67 | 68 | 69 | //将小写字母转成大写字母 减32 70 | a:='a' 71 | a=a-32//允许参与整型计算 72 | //如果使用println打印数据时 显示byte对应的ASCII值 73 | //fmt.Println(a) 74 | //如果定义类型为byte 打印变量类型为uint8 75 | //如果通过自动推导类型创建变量 打印类型为int32 76 | fmt.Printf("%T",a) 77 | 78 | //fmt.Printf("%c",a) 79 | } 80 | 81 | func main0105(){ 82 | //字符串类型 83 | //var a string //默认值为 "" "\0" \0是字符串的结束标志 有系统自动添加 84 | //a="hello world" 85 | ////字符串在打印时 打印\0之前内容 86 | //fmt.Println(a) 87 | //fmt.Printf("%s",a) 88 | 89 | var a string="相加" 90 | b:="操作" 91 | //字符串类型也允许相加操作 理解为字符串拼接 92 | a=a+b 93 | fmt.Println(a) 94 | } -------------------------------------------------------------------------------- /go基础学习所有代码例题/02学习/代码demo/02字符和字符串区别.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | //字符类型定义 ''单引号引起来字符 7 | //var a byte 8 | ////a='a' 9 | ////转义字符 也是字符的一种用\开头 \0 10 | ////a='\n' 11 | ////a='男'//err 一个汉字占3个字节 12 | //fmt.Printf("==%c==",a) 13 | //fmt.Println(a) 14 | ////当定义\0是 默认将\0当做八进制数据 15 | //a=0//相当于\0 16 | 17 | //字符串类型 18 | //在字符串结尾有\0表示结尾 19 | //var b string="表示结尾" 20 | var b string = "hello world" 21 | //len(string) 计算字符串中字符个数 不包含\0 返回值为int类型 返回值为个数 22 | var count int 23 | count = len(b) 24 | //fmt.Println(b) 25 | //fmt.Println(len(b)) 26 | fmt.Println(count) 27 | 28 | //\t转义字符 水平制表符 一次跳过8个空格 打印数据对齐会使用到 29 | //fmt.Printf("\t你好") 30 | } 31 | -------------------------------------------------------------------------------- /go基础学习所有代码例题/02学习/代码demo/03fmt输入输出.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main0301() { 6 | //打印 % 需要使用%% 7 | //fmt.Printf("35%%") 8 | //fmt.Println("35%") 9 | //十进制数据 10 | //a:=123 11 | //八进制数据是以0开头 12 | //var a int 13 | //a=0123 14 | //十六进制数据 是以0x开头的 15 | var a int 16 | a=0xABC 17 | //二进制 逢二进一 所有数据都是1 0 组成的 18 | //%b 占位符 表示输出二进制 19 | fmt.Printf("%b\n",a) 20 | 21 | //八进制 逢八进一 所有数据用0-7组成 22 | //%o 占位符 表示输出八进制 23 | fmt.Printf("%o\n",a) 24 | 25 | //十六进制 逢十六进一 所有数据都是 0-9 A-F 10A 11B 12C 13D 14E 15F 26 | //%x 占位符 表示输出十六进制 小写字母 27 | fmt.Printf("%x\n",a) 28 | //%X 占位符 表示输出十六进制 大写字母 29 | fmt.Printf("%X\n",a) 30 | //十进制 31 | fmt.Printf("%d\n",a) 32 | 33 | //%p占位符 表示数据的内存地址 34 | fmt.Printf("a的内存地址：%p\n",&a) 35 | } 36 | 37 | func main(){ 38 | //所有数据的内存地址都是一个无符号十六进制整型数据 39 | a:="hello" 40 | fmt.Printf("%p\n",&a) 41 | } 42 | -------------------------------------------------------------------------------- /go基础学习所有代码例题/02学习/代码demo/04常量.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main0401() { 6 | //变量定义格式 7 | //var 变量名 数据类型 8 | //常量定义和使用 9 | //const 常量名 数据类型 10 | //常量是在程序运行过程中 其值不能发生改变的量 成为常量 11 | //常量一般用大写字母表示 和变量进行区分 12 | const PI float64 = 3.14 13 | //常量定以后值不能发生改变 14 | //PI=3.14159//err 15 | var b float64 16 | //代码写完后可以进行格式化 ctrl+alt+l 17 | b = PI 18 | fmt.Println(PI * 2.5 * 2.5) 19 | //常量可以参与程序计算或者赋值给变量 20 | fmt.Println(b) 21 | 22 | fmt.Printf("%p\n", &b) 23 | //常量的地址不允许访问 常量是在数据区下的常量区进行存储 24 | //fmt.Printf("%p\n",&PI)//err 25 | } 26 | 27 | func main(){ 28 | //字面常量 29 | fmt.Println(3.14) 30 | fmt.Println("hello world") 31 | a:="hello" 32 | a=a+"world" 33 | fmt.Println(a) 34 | } -------------------------------------------------------------------------------- /go基础学习所有代码例题/02学习/代码demo/05iota枚举.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main0501() { 6 | 7 | //枚举定义和使用 8 | const ( 9 | //在定义枚举时默认值为0 每换一行值增加1 10 | //在定义枚举是可以不动写 =iota 11 | a = iota //0 12 | b = iota //1 13 | c = iota //2 14 | 15 | d 16 | e 17 | ) 18 | //a=100//err 19 | fmt.Println(a, b, c, d, e) 20 | } 21 | func main0502() { 22 | const ( 23 | //iota枚举里面数据可以赋值 不建议赋值 24 | //枚举里面数据都是整型数据 25 | a = iota 26 | b = 10 27 | c = iota 28 | d 29 | e 30 | ) 31 | fmt.Println(a, b, c, d, e) 32 | } 33 | func main() { 34 | const ( 35 | //枚举值里面数据如果不换行 一行内的值相同 36 | //枚举定义时如果没有赋值 会重复上一行格式 37 | a = iota 38 | b, c = iota, iota 39 | d, e 40 | ) 41 | fmt.Println(a, b, c, d, e) 42 | } 43 | -------------------------------------------------------------------------------- /go基础学习所有代码例题/02学习/代码demo/06算数运算符.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main0601() { 6 | a := 10 7 | b := 2 8 | //fmt.Println(a + b) 9 | //fmt.Println(a - b) 10 | //fmt.Println(a * b) 11 | fmt.Println(a / b) //0.5 整数相除得到的结果也是整数 0不能作为除数 12 | } 13 | func main0602() { 14 | a := 10 15 | b := 6 16 | c := a % b 17 | //取模运算符 除数不能为0 18 | //取模不能对浮点型进行操作 19 | fmt.Println(c) 20 | } 21 | 22 | func main0603() { 23 | //自增和自减 24 | a := 10 25 | //a=a+1 26 | //a++//自增 数本身+1操作 27 | a-- //a=a-1 28 | a-- //a=a-1 29 | //自增和自减不能出现在表达式中 引起程序的二义性 30 | a-- 31 | //a=a++ - a-- * a++//err 32 | fmt.Println(a) 33 | } 34 | 35 | func main064() { 36 | a := 10 37 | b := 20 38 | c := 3.99 39 | //类型转换 格式 数据类型(变量) 数据类型(表达式) 40 | //sum:=float64(a)+float64(b)+c 41 | //sum:=float64(a+b)+c 42 | //将浮点型转成整型 值保留整数部分 忽略小数部分 43 | sum := a + b + int(c) 44 | fmt.Println(sum) 45 | fmt.Printf("%T", sum) 46 | } 47 | 48 | func main0604() { 49 | //int32 和int64都是整型 但是不允许类型转换 50 | //var a int32 = 10 51 | //var b int64 = 20 52 | //fmt.Println(int64(a) + b) 53 | 54 | //数据类型在转换时 如果高位转成低位可能会导致溢出 数据发生变化 55 | var a int8 = 127 56 | var b int16 = 250 57 | //fmt.Println(int8(b))溢出 58 | fmt.Println(int16(a) + b) 59 | 60 | } 61 | func main() { 62 | //107653是几天几小时几分几秒 63 | var s int = 107653 64 | m := s / 60 65 | h := m / 60 66 | d := h / 24 67 | 68 | //fmt.Println("天：", timer/60/60/24%365) 69 | //fmt.Println("时：", timer/60/60%24) 70 | //fmt.Println("分：", timer/60%60) 71 | //fmt.Println("秒：", timer%60) 72 | 73 | fmt.Println("天：", d % 365) 74 | fmt.Println("时：", h % 24) 75 | fmt.Println("分：", m % 60) 76 | fmt.Println("秒：", s % 60) 77 | 78 | //13+54*60+5*60*60+1*24*60*60=107653 79 | 80 | } 81 | -------------------------------------------------------------------------------- /go基础学习所有代码例题/02学习/代码demo/07赋值运算符.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | a := 10 7 | b := 20 8 | 9 | //a *= b 10 | //a /= b//a=a/b 11 | a %= b //a=a%b 12 | fmt.Println(a) 13 | fmt.Println(b) 14 | //var c int 15 | //// = 赋值运算符 左值运算符 16 | //c = a + b 17 | // 18 | ////a=a+b 19 | //a += b//30 20 | // 21 | //fmt.Println(a) 22 | //fmt.Println(c) 23 | // 24 | //a -= b//30-20 a=a-b 25 | //fmt.Println(a) 26 | } 27 | -------------------------------------------------------------------------------- /go基础学习所有代码例题/02学习/代码demo/08比较运算符.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | a := 10 7 | b := 20 8 | //比较运算符结果是bool类型 9 | // > 大于 < 小于 >= 大于等于 <= 小于等于 == 相等于 !=不等于 10 | //c := a < b 11 | c:=a == b 12 | fmt.Println(c) 13 | } 14 | -------------------------------------------------------------------------------- /go基础学习所有代码例题/02学习/代码demo/09逻辑运算符.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main0901() { 6 | //a:=10 7 | //b:=20 8 | ////逻辑非 ! 非真为假 非假为真 9 | //c:=!!(a>b) 10 | a := false 11 | b := !a 12 | 13 | fmt.Println(b) 14 | } 15 | 16 | func main0902() { 17 | a := 10 18 | b := 20 19 | c := 30 20 | 21 | //逻辑与 表达式1 && 表达式2 同真为真 其余为假 22 | d := a > b && a < c 23 | 24 | fmt.Println(d) 25 | } 26 | func main() { 27 | 28 | a := 10 29 | b := 20 30 | c := 30 31 | //逻辑或 表达式1 || 表达式2 同假为假 其余为真 32 | d := a < b || a > c 33 | 34 | fmt.Println(d) 35 | // 36 | } 37 | -------------------------------------------------------------------------------- /go基础学习所有代码例题/02学习/代码demo/10其他运算符和运算符优先级.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main1001() { 6 | //& 取地址运算符 fmt.Scan() 7 | a := 10 8 | p := &a //p是一个指针变 9 | fmt.Printf("%p\n", p) 10 | //* 取值运算符 11 | fmt.Println(*p) 12 | // >> << 位移运算符 ^ & | ~ 位运算符 13 | } 14 | 15 | //运算符优先级 16 | 17 | //括号 () 数组下标[] 结构体成员选择 . 18 | 19 | //单目 20 | //算数 ++ -- 逻辑 ! 取地址 & 取值 * 21 | 22 | //双目 23 | //算数 * / % 24 | //算数 + - 25 | //比较 > < >= <= == != 26 | //逻辑 || && 27 | //赋值 = += -= *= /= %= 28 | 29 | func main() { 30 | a := 10 31 | b := 20 32 | c := a > b && b > a 33 | fmt.Println(c) 34 | } 35 | -------------------------------------------------------------------------------- /go基础学习所有代码例题/02学习/相关资料及笔记/01数据存储格式.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/go基础学习所有代码例题/02学习/相关资料及笔记/01数据存储格式.png -------------------------------------------------------------------------------- /go基础学习所有代码例题/02学习/相关资料及笔记/02内存模型他.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/go基础学习所有代码例题/02学习/相关资料及笔记/02内存模型他.png -------------------------------------------------------------------------------- /go基础学习所有代码例题/03学习/代码demo/01if条件语句.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main0101() { 6 | var score int 7 | 8 | fmt.Scan(&score) 9 | //if 表达式 {代码} 如果表达式为真 执行{}内的代码 10 | if score > 700 { 11 | fmt.Println("我要上清华") 12 | }else{ 13 | fmt.Println("我要上浙大") 14 | } 15 | } 16 | func main0102() { 17 | var score int 18 | 19 | fmt.Scan(&score) 20 | //if 表达式1 {代码1} 如果表达式为真 执行{}内的代码 21 | //else if 表达式2 {代码2} 22 | //else {代码3} 23 | if score > 700 { 24 | fmt.Println("我要上清华") 25 | }else if score >680 { 26 | fmt.Println("我要上北大") 27 | }else{ 28 | fmt.Println("我要上浙大") 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /go基础学习所有代码例题/03学习/代码demo/02if语句嵌套.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | var score int 7 | 8 | fmt.Scan(&score) 9 | //if 语句嵌套 10 | if score > 700 { 11 | fmt.Println("我要上清华") 12 | 13 | if score > 720 { 14 | fmt.Println("我要学习计算机") 15 | } else if score > 710 { 16 | fmt.Println("我要学习挖掘机") 17 | } else { 18 | fmt.Println("我要学习美容美发") 19 | } 20 | 21 | } else if score > 680 { 22 | fmt.Println("我要上北大") 23 | 24 | if score > 690 { 25 | fmt.Println("我要学习厨师") 26 | } else if score > 685 { 27 | fmt.Println("我要学习盗墓") 28 | } else { 29 | fmt.Println("我要学习搬砖") 30 | } 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /go基础学习所有代码例题/03学习/代码demo/03三只小猪称体重.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | func main() { 8 | //有三只小猪 判断哪个最重 9 | 10 | var a, b, c int 11 | 12 | fmt.Scan(&a, &b, &c) //10 12 8 13 | 14 | if a > b { 15 | if a > c { 16 | fmt.Println("a最重") 17 | } else { 18 | fmt.Println("c最重") 19 | } 20 | } else { 21 | if b > c { 22 | fmt.Println("b最重") 23 | } else { 24 | fmt.Println("c最重") 25 | } 26 | } 27 | 28 | 29 | } -------------------------------------------------------------------------------- /go基础学习所有代码例题/03学习/代码demo/05for语句.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | 7 | //for 表达式1;表达式2;表达式3{代码} 8 | //var i int = 0 9 | //for i:=0; i < 10; i++{ 10 | // fmt.Println("表达式1") 11 | // 12 | //} 13 | 14 | //计算1-100和 15 | //sum := 0 16 | //for i := 1; i <= 100; i++ { 17 | // sum += i 18 | //} 19 | // 20 | //fmt.Println(sum) 21 | 22 | //计算1-100 偶数的和 23 | //for 循环可以嵌套if语句 24 | //sum := 0 25 | //for i := 1; i <= 100; i++ { 26 | // 27 | // if i%2 == 0 { 28 | // sum += i 29 | // } 30 | //} 31 | //fmt.Println(sum) 32 | 33 | sum:=0 34 | for i:=0;i<=100;i+=2{ 35 | sum+=i 36 | } 37 | fmt.Println(sum) 38 | 39 | } 40 | -------------------------------------------------------------------------------- /go基础学习所有代码例题/03学习/代码demo/06水仙花.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | //水仙花数 7 | //一个三位数 各个位数的立方和等于本身 8 | for i := 100; i < 1000; i++ { 9 | //个位 十位 百位 10 | a := i % 10 11 | b := i % 100 / 10 //b:=i/10%10 12 | c := i / 100 13 | 14 | if a*a*a+b*b*b+c*c*c == i { 15 | fmt.Println(i) 16 | } 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /go基础学习所有代码例题/03学习/代码demo/07敲7.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | //计算1-100之间 不包含7（个位 十位） 或者7的倍数 7 | 8 | for i := 1; i <= 100; i++ { 9 | 10 | if i%7 == 0 || i%10 == 7 || i/10 == 7 { 11 | fmt.Println("敲桌子") 12 | }else{ 13 | fmt.Println(i) 14 | } 15 | 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /go基础学习所有代码例题/03学习/代码demo/08跳出语句.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main0801() { 6 | 7 | //死循环 8 | for{ 9 | fmt.Println("跳出本层循环") 10 | 11 | //在循环中 跳出本层循环 12 | break 13 | } 14 | 15 | } 16 | func main0802(){ 17 | //var name string 18 | //var passwd string 19 | // 20 | ////为死循环添加break出口 21 | //for{ 22 | // fmt.Println("请输入用户名和密码") 23 | // fmt.Scan(&name,&passwd) 24 | // 25 | // if name=="admin" && passwd=="123456"{ 26 | // fmt.Println("成功") 27 | // //跳出循环 28 | // break 29 | // }else{ 30 | // fmt.Println("输入错误") 31 | // } 32 | //} 33 | sum:=0 34 | i:=0 35 | for { 36 | sum+=i 37 | if i==100{ 38 | break 39 | } 40 | i++ 41 | } 42 | 43 | fmt.Println(sum) 44 | } 45 | 46 | func main0803(){ 47 | 48 | sum:=0 49 | //1-100偶数的和 50 | for i:=1;i<=100;i++{ 51 | if i%2==1{ 52 | //结束本次循环 继续下次循环 53 | continue 54 | } 55 | sum+=i 56 | } 57 | 58 | fmt.Println(sum) 59 | } 60 | 61 | func main0804(){ 62 | 63 | fmt.Println("hello1") 64 | fmt.Println("hello2") 65 | //goto 从一个标志位跳到另外一个标志位 66 | //goto用法很灵活可以在一个循环 函数 跳到另外一个循环 函数 67 | //goto FLAG; 68 | fmt.Println("hello3") 69 | fmt.Println("hello4") 70 | fmt.Println("hello5") 71 | //FLAG: 72 | fmt.Println("hello6") 73 | fmt.Println("hello7") 74 | 75 | 76 | 77 | 78 | } 79 | 80 | func main(){ 81 | 82 | FLAG: 83 | fmt.Println("hello") 84 | 85 | goto FLAG; 86 | } -------------------------------------------------------------------------------- /go基础学习所有代码例题/03学习/代码demo/09嵌套循环.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main0901() { 6 | 7 | //外层执行一次 内层执行一周 8 | for i := 0; i < 5; i++ { 9 | 10 | for j := 0; j < 5; j++ { 11 | fmt.Println(i, j) 12 | } 13 | } 14 | } 15 | 16 | //九九乘法口诀 17 | // 1*1=1 18 | // 1*2=2 2*2=4 19 | // 1*3=3 2*3=6 3*3=9 20 | // 1*4=4 2*4=8 3*4=12 4*4=16 21 | 22 | func main() { 23 | 24 | //外层控制行 内层控制列 25 | for i := 1; i <= 9; i++ { 26 | for j := 1; j <= i; j++ { 27 | fmt.Printf("%d*%d=%d\t", j, i, i*j) 28 | } 29 | fmt.Println() 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /go基础学习所有代码例题/03学习/代码demo/10百钱百鸡.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main1001() { 6 | //百钱百鸡 7 | //公鸡5钱1只 母鸡3钱1只 小鸡1钱3只 花费100钱买100只鸡 8 | //公鸡 20 母鸡 33 小鸡 100 9 | count := 0 //计数器 10 | for cock := 0; cock <= 20; cock++ { 11 | for hen := 0; hen <= 33; hen++ { 12 | for chicken := 0; chicken <= 100; chicken += 3 { 13 | count++ 14 | if cock+hen+chicken == 100 && cock*5+hen*3+chicken/3 == 100 { 15 | fmt.Printf("公鸡：%d 母鸡：%d 小鸡：%d\n", cock, hen, chicken) 16 | } 17 | } 18 | } 19 | } 20 | 21 | fmt.Println(count) 22 | } 23 | 24 | func main() { 25 | count := 0 //计数器 26 | for cock := 0; cock <= 20; cock++ { 27 | for hen := 0; hen <= 33; hen++ { 28 | count++ 29 | //百鸡 30 | chicken := 100 - cock - hen 31 | //百钱 32 | if chicken%3 == 0 && cock*5+hen*3+chicken/3 == 100 { 33 | fmt.Printf("公鸡：%d 母鸡：%d 小鸡：%d\n", cock, hen, chicken) 34 | 35 | } 36 | } 37 | } 38 | 39 | fmt.Println(count) 40 | } 41 | -------------------------------------------------------------------------------- /go基础学习所有代码例题/03学习/代码demo/11函数.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | // * 6 | // *** 7 | // ***** 8 | // ******* 9 | // ********* 10 | //*********** 11 | 12 | //函数定义和调用 13 | //func 函数名(函数参数列表) 返回值类型 {代码体} 14 | 15 | //计算10+20和 16 | //函数定义(函数实现过程) 17 | func add(a int, b int) { 18 | sum := a - b 19 | fmt.Println(sum) 20 | } 21 | 22 | func main1101() { 23 | //返回值（int）=len(字符串变量(string())) 24 | 25 | a := 10 26 | b := 20 27 | //函数调用 28 | add(a, b) 29 | //函数优点 可以重复使用 修改迭代简单 30 | add(1, 2) 31 | add(55, 44) 32 | 33 | } 34 | 35 | //在函数定义时 函数形参 形式参数 36 | //形参接收实参传递的值 形参是格式要求 根据形参的类型和个数来去调用函数 37 | func test(a int, b int) { 38 | a = 100 39 | b = 200 40 | fmt.Println(a, b) 41 | } 42 | func main0111() { 43 | a := 10 44 | b := 20 45 | //在函数调用中 函数的参数称为实参 实际参数 46 | test(a, b) 47 | } -------------------------------------------------------------------------------- /go基础学习所有代码例题/03学习/代码demo/12不定参函数.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | //在整个项目中函数名是唯一的 6 | //...不定参 a相当于一组数据的集合 7 | 8 | func test1(a ...int) { 9 | //len(a) 计算集合数据个数 10 | //for i:=0;i max { 34 | max = weight[i] 35 | } 36 | } 37 | 38 | fmt.Println(max) 39 | 40 | } 41 | -------------------------------------------------------------------------------- /go基础学习所有代码例题/04学习/相关资料及笔记/01闭包.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/go基础学习所有代码例题/04学习/相关资料及笔记/01闭包.png -------------------------------------------------------------------------------- /go基础学习所有代码例题/04学习/相关资料及笔记/02递归函数.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/go基础学习所有代码例题/04学习/相关资料及笔记/02递归函数.png -------------------------------------------------------------------------------- /go基础学习所有代码例题/04学习/相关资料及笔记/03递归函数.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/go基础学习所有代码例题/04学习/相关资料及笔记/03递归函数.png -------------------------------------------------------------------------------- /go基础学习所有代码例题/04学习/相关资料及笔记/04数组定义.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/go基础学习所有代码例题/04学习/相关资料及笔记/04数组定义.png -------------------------------------------------------------------------------- /go基础学习所有代码例题/05学习/代码demo/01数组逆置.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | 7 | arr := [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10} 8 | 9 | //定义数组下标 10 | i := 0 11 | j := len(arr) - 1 12 | 13 | for i <= j { 14 | //if i>j { 15 | // break 16 | //} 17 | //数据交换 18 | arr[i], arr[j] = arr[j], arr[i] 19 | 20 | i++ 21 | j-- 22 | 23 | } 24 | fmt.Println(arr) 25 | } 26 | -------------------------------------------------------------------------------- /go基础学习所有代码例题/05学习/代码demo/02冒泡排序.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | arr := [10]int{9, 1, 5, 6, 3, 7, 10, 8, 2, 4} 7 | 8 | //冒泡排序 9 | 10 | for i := 0; i < 10-1; i++ { 11 | for j := 0; j < 10-1-i; j++ { 12 | if arr[j] > arr[j+1] { 13 | 14 | //数据交换 15 | arr[j], arr[j+1] = arr[j+1], arr[j] 16 | //temp := arr[j] 17 | //arr[j] = arr[j+1] 18 | //arr[j+1] = temp 19 | } 20 | } 21 | fmt.Println(arr) 22 | } 23 | 24 | //fmt.Println(arr) 25 | } 26 | -------------------------------------------------------------------------------- /go基础学习所有代码例题/05学习/代码demo/02冒泡排序.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/go基础学习所有代码例题/05学习/代码demo/02冒泡排序.png -------------------------------------------------------------------------------- /go基础学习所有代码例题/05学习/代码demo/03数组作为函数参数.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | //数组作为函数参数 6 | func test(arr [5]int) { 7 | 8 | //fmt.Println(arr) 9 | //sum:=0 10 | //for i := 0; i < len(arr); i++ { 11 | // sum+=arr[i] 12 | //} 13 | // 14 | //fmt.Println(sum) 15 | fmt.Printf("%p\n", &arr) 16 | //arr[2]=123 17 | //fmt.Println(arr) 18 | 19 | } 20 | func main0301() { 21 | 22 | arr := [5]int{1, 2, 3, 4, 5} 23 | 24 | //值传递 25 | test(arr) 26 | fmt.Printf("%p\n", &arr) 27 | 28 | } 29 | 30 | //数组作为函数返回值 31 | func BubbleSort(arr [10]int) [10]int { 32 | //冒泡排序 33 | for i := 0; i < len(arr)-1; i++ { 34 | for j := 0; j < len(arr)-1-i; j++ { 35 | if arr[j] > arr[j+1] { 36 | arr[j], arr[j+1] = arr[j+1], arr[j] 37 | } 38 | } 39 | } 40 | return arr 41 | 42 | } 43 | func main0302() { 44 | arr := [10]int{9, 1, 5, 6, 3, 7, 10, 8, 2, 4} 45 | //数组作为函数参数是值传递 形参不能改变实参的值 46 | //如果想改变实参的值 可以使用返回值赋值操作 47 | arr = BubbleSort(arr) 48 | 49 | fmt.Println(arr) 50 | 51 | } 52 | 53 | func StrLong(str [5]string){ 54 | 55 | max:=len(str[0]) 56 | i:=0 57 | for index,v :=range str{ 58 | if len(v)>max{ 59 | max=len(v) 60 | i=index 61 | } 62 | } 63 | 64 | fmt.Println(str[i]) 65 | } 66 | func main(){ 67 | str:=[5]string{ "马龙", "迈克尔乔丹", "雷吉米勒", "蒂姆邓肯", "科比布莱恩特" } 68 | StrLong(str) 69 | } -------------------------------------------------------------------------------- /go基础学习所有代码例题/05学习/代码demo/04随机数.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "time" 6 | "math/rand" 7 | ) 8 | 9 | func main0401() { 10 | 11 | //1、导入头文件 math/rand time 12 | //2、添加随机数种子 rand.Seed(time.Now().UnixNano()) 13 | //3、使用随机数 rand,Intn(10) 14 | //当前系统时间 15 | //fmt.Println(time.Now()) 16 | //用当前时间做随机数混淆 17 | rand.Seed(time.Now().UnixNano()) 18 | for i := 0; i < 100; i++ { 19 | //默认随机数使用的时间为1970.1.1.0.0.0 20 | fmt.Println(rand.Intn(100)) //随机0-99之间的数 % 100 21 | 22 | } 23 | } 24 | 25 | func main0402() { 26 | 27 | rand.Seed(time.Now().UnixNano()) 28 | var arr [10]int 29 | 30 | for i := 0; i < len(arr); i++ { 31 | arr[i] = rand.Intn(100) 32 | } 33 | fmt.Println(arr) 34 | 35 | for i := 0; i < 10-1; i++ { 36 | for j := 0; j < 10-1-i; j++ { 37 | if arr[j] > arr[j+1] { 38 | 39 | //数据交换 40 | arr[j], arr[j+1] = arr[j+1], arr[j] 41 | 42 | } 43 | } 44 | } 45 | 46 | fmt.Println(arr) 47 | 48 | } 49 | 50 | //双色球 红球 1-33 个数 不能重复 选择6个 篮球 1-16 选择1个 51 | 52 | func main() { 53 | 54 | rand.Seed(time.Now().UnixNano()) 55 | var redball [6]int 56 | 57 | for i := 0; i < len(redball); i++ { 58 | //redball[i]=rand.Intn(33)+1//1-33 59 | temp := rand.Intn(33) + 1 60 | 61 | //去重 62 | for j := 0; j < i; j++ { 63 | if redball[j] == temp { 64 | j = -1 65 | temp = rand.Intn(33) + 1 66 | } 67 | } 68 | redball[i] = temp 69 | } 70 | 71 | fmt.Println(redball, "+", rand.Intn(16)+1) 72 | 73 | } 74 | -------------------------------------------------------------------------------- /go基础学习所有代码例题/05学习/代码demo/05双色球.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "math/rand" 5 | "time" 6 | "fmt" 7 | ) 8 | 9 | //双色球 红球1-33 选择6个 不能重复 蓝球 1-16 选择1个 10 | func main0501() { 11 | 12 | rand.Seed(time.Now().UnixNano()) 13 | var red [6]int 14 | 15 | for i := 0; i < len(red); i++ { 16 | //red[i] = rand.Intn(33) + 1 17 | temp := rand.Intn(33) + 1 18 | //去重 19 | for j := 0; j < i; j++ { 20 | //重复 21 | if red[j] == temp { 22 | temp = rand.Intn(33) + 1 23 | j = -1 24 | } 25 | } 26 | red[i] = temp 27 | } 28 | 29 | fmt.Println(red, "+", rand.Intn(16)+1) 30 | 31 | } 32 | func main() { 33 | rand.Seed(time.Now().UnixNano()) 34 | var red [6]int 35 | 36 | for i := 0; i < len(red); i++ { 37 | flag := false 38 | temp := rand.Intn(33) + 1 39 | 40 | for j := 0; j < i; j++ { 41 | //找到重复 跳出本层程序 42 | if red[j] == temp { 43 | flag = true 44 | i-- 45 | break 46 | } 47 | } 48 | 49 | if flag == false { 50 | red[i] = temp 51 | } 52 | 53 | } 54 | fmt.Println(red, "+", rand.Intn(16)+1) 55 | } 56 | -------------------------------------------------------------------------------- /go基础学习所有代码例题/05学习/代码demo/06多维数组.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main0601() { 6 | //一维数组 7 | //var 数组名 [元素个数]数据类型 8 | 9 | //二维数组 10 | //var 数组名 [行][列]数据类型 11 | //数组元素个数=行*列 12 | 13 | //var arr [3][4]int = [3][4]int{{1, 2, 3, 4}, {2, 3, 4, 5}, {3, 4, 5, 6}} 14 | //数组如果初始化部分值 未初始化值为0 15 | //var arr [3][4]int = [3][4]int{{1, 2, 3, 4}, {3}} 16 | //数组可以找到具体下标可以赋值 17 | //var arr[3][4]int=[3][4]int{1:{1,2,3,4},2:{3,4,5,6},0:{'a','b','c','d'}} 18 | 19 | arr := [3][4]int{{1, 2, 3, 4}, {2, 3, 4, 5}, {3, 4, 5, 6}} 20 | 21 | //arr[1][1]=10 22 | 23 | //fmt.Println(arr) 24 | 25 | //fmt.Println(len(arr)) //len(二维数组)二维数组行个数 26 | //arr[0] 表示整个一维数组 27 | //fmt.Println(len(arr[0])) //len(位数数组[下标])二维数组列个数 28 | //fmt.Println(arr[0]) 29 | 30 | //for i := 0; i < len(arr); i++ { 31 | // for j := 0; j < len(arr[0]); j++ { 32 | // fmt.Print(arr[i][j]," ") 33 | // } 34 | // fmt.Println() 35 | //} 36 | //c 表示行的下标 v 二维数组中一行的值 37 | for _, v := range arr { 38 | //fmt.Println(c,v) 39 | for _, data := range v { 40 | //fmt.Printf("行：%d 列：%d 值：%d\t",c,l,data) 41 | fmt.Print(data) 42 | } 43 | fmt.Println() 44 | } 45 | } 46 | func main() { 47 | //var 数组名 [元素个数]数据类型 48 | //var 数组名 [行][列]数据类型 49 | //三维数组 var 数组名 [层][行][列] 数据类型 50 | var arr [2][3][4]int = [2][3][4]int{ 51 | { 52 | {1, 2, 3, 4}, 53 | {2, 3, 4, 5}, 54 | {3, 4, 5, 6}}, 55 | { 56 | {4, 5, 6, 7}, 57 | {5, 6, 7, 8}, 58 | {6, 7, 8, 9}}} 59 | 60 | fmt.Println(arr) 61 | 62 | for i := 0; i < 2; i++ { 63 | for j := 0; j < 3; j++ { 64 | for k := 0; k < 4; k++ { 65 | fmt.Print(arr[i][j][k]) 66 | } 67 | fmt.Println() 68 | } 69 | } 70 | //四维数组 71 | //var a [2][3][4][5]int 72 | //五维数组 73 | //var b [2][3][4][5][6]int 74 | } 75 | -------------------------------------------------------------------------------- /go基础学习所有代码例题/05学习/代码demo/07切片定义和使用.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main0701() { 6 | 7 | //数组定义和使用 8 | //var i int 9 | //fmt.Scan(&i) 10 | //a:=10 11 | //const a int = 10 12 | ////数组定义时必须事先知道大小 13 | //var arr [a]int 14 | //fmt.Println(arr) 15 | 16 | //切片的定义 17 | //切片定义时 不需要写元素个数 18 | var slice []int 19 | //slice[0]=123 20 | //fmt.Println(slice) 21 | 22 | //append 为切片添加元素 23 | slice=append(slice,1,2,3) 24 | slice=append(slice,2,3,4) 25 | //修改切片中下标为1元素的值 26 | slice[1]=123 27 | fmt.Println(len(slice)) 28 | fmt.Println(slice) 29 | } 30 | 31 | func main(){ 32 | //var slice []int=[]int{1,2,3,4,5,6} 33 | //自动推导类型 34 | //slice:=[]int{1,2,3} 35 | //使用make创建切片长度 make(切片类型,切片长度) 36 | slice:=make([]int,3) 37 | slice[0]=1 38 | slice[1]=123 39 | slice[2]=321 40 | //slice[3]=2//切片下标越界//err 41 | 42 | slice=append(slice,1) 43 | slice=append(slice,123,234,345) 44 | 45 | 46 | //fmt.Println(len(slice)) 47 | 48 | //for i:=0;i s[j+1] { 32 | s[j], s[j+1] = s[j+1], s[j] 33 | } 34 | } 35 | } 36 | 37 | } 38 | 39 | func main0202() { 40 | s := []int{9, 1, 5, 6, 10, 2, 8, 4, 7, 3} 41 | //切片作为函数参数 地址传递 形参可以改变实参值 42 | BubbleSort(s) 43 | 44 | fmt.Println(s) 45 | } 46 | 47 | //切片作为函数的返回值 48 | func test1(s []int) []int { 49 | 50 | //append 添加切片元素 会改变切片的地址 51 | s = append(s, 1, 2, 3, 4, 5) 52 | fmt.Println(s) 53 | return s 54 | 55 | } 56 | func main() { 57 | 58 | s := []int{1, 2, 3, 4, 5, 6} 59 | s = test1(s) 60 | 61 | fmt.Println(s) 62 | 63 | } 64 | -------------------------------------------------------------------------------- /go基础学习所有代码例题/06学习/代码demo/03猜数字.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "math/rand" 5 | "time" 6 | "fmt" 7 | ) 8 | 9 | func main() { 10 | 11 | rand.Seed(time.Now().UnixNano()) 12 | s := make([]int, 3) 13 | s[0] = rand.Intn(9) + 1 //1-9 14 | s[1] = rand.Intn(10) //0-9 15 | s[2] = rand.Intn(10) //0-9 16 | 17 | num := 0 18 | count := 0 19 | value := make([]int, 3) 20 | for { 21 | fmt.Println("请输入一个三位数") 22 | fmt.Scan(&num) 23 | if num <= 999 && num >= 100 { 24 | 25 | value[0] = num / 100 //百位 26 | value[1] = num / 10 % 10 //十位 27 | value[2] = num % 10 //个位 28 | 29 | for i := 0; i < 3; i++ { 30 | if s[i] == value[i] { 31 | count++ 32 | fmt.Printf("第%d位相同\n", i+1) 33 | } else if s[i] > value[i] { 34 | fmt.Println("输入的数太小了") 35 | } else { 36 | fmt.Println("输入的数太大了") 37 | 38 | } 39 | } 40 | if count == 3 { 41 | fmt.Println("恭喜您，猜对了\n") 42 | break 43 | } else { 44 | count = 0 45 | } 46 | 47 | } 48 | } 49 | 50 | } 51 | -------------------------------------------------------------------------------- /go基础学习所有代码例题/06学习/代码demo/05字符串类型转换.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func main0501() { 4 | 5 | //将bool转成字符串 6 | //str:=strconv.FormatBool(false) 7 | //fmt.Println(str) 8 | 9 | //FormatInt(数据，进制) 10 | //str:=strconv.FormatInt(123,10)//2-36 能够使用的是2-36 （0-9 a-z） 11 | //fmt.Println(str) 12 | //将十进制整型转成字符串 13 | //str:=strconv.Itoa(666) 14 | //fmt.Println(str) 15 | 16 | //将浮点型转成字符串 保留具体位数的小数 会四舍五入 17 | //str:=strconv.FormatFloat(3.1415926,'f',4,64) 18 | //fmt.Println(str) 19 | } 20 | 21 | 22 | func main(){ 23 | 24 | ////将字符串转成bool 25 | //b,err:=strconv.ParseBool("true") 26 | //if err!=nil{ 27 | // fmt.Println("出错") 28 | //}else{ 29 | // 30 | // fmt.Println(b) 31 | //} 32 | //将字符串转成整型 33 | //i,err:=strconv.ParseInt("1111011",2,64) 34 | //if err!=nil{ 35 | // fmt.Println(err) 36 | //}else{ 37 | // fmt.Println(i) 38 | // 39 | //} 40 | //将字符串转成十进制整型 41 | //i,_:=strconv.Atoi("123abc") 42 | //fmt.Println(i) 43 | //fmt.Printf("%T\n",i) 44 | 45 | //将字符串转成float类型 46 | //f,_:=strconv.ParseFloat("3.14159",64) 47 | //fmt.Println(f) 48 | } -------------------------------------------------------------------------------- /go基础学习所有代码例题/06学习/代码demo/06数据类型转成切片.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "strconv" 5 | "fmt" 6 | ) 7 | 8 | func main() { 9 | a:=10 10 | b:=true 11 | c:=3.14159 12 | d:="hello" 13 | 14 | slice:=make([]byte,0,1024) 15 | 16 | slice=strconv.AppendBool(slice,b) 17 | slice=strconv.AppendInt(slice,int64(a),10) 18 | slice=strconv.AppendFloat(slice,c,'f',3,64) 19 | slice=strconv.AppendQuote(slice,d) 20 | 21 | fmt.Printf("%s\n",slice) 22 | 23 | } 24 | -------------------------------------------------------------------------------- /go基础学习所有代码例题/06学习/代码demo/07map创建和使用.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main0701() { 6 | 7 | //map[键数据类型]值数据类型 8 | 9 | //var m map[int]int=make(map[int]int,2) 10 | // 11 | //m[0]=123 12 | //m[100]=234 13 | //m[321]=10 14 | 15 | //键在map中是唯一的 16 | //链式存储 每次数据遍历是 不应定按照存储的顺序打印 17 | var m map[int]int = map[int]int{1: 123, 2: 321, 33: 12, 22: 12} 18 | 19 | //map数据格式会随着添加数据自动增长 20 | m[110] = 119 21 | //覆盖上一次的值 22 | m[110] = 120 23 | 24 | //fmt.Println(m) 25 | //打印map中的键和值 26 | //key 键 value 值 27 | //for k,v:=range m{ 28 | // fmt.Println(k,v) 29 | //} 30 | 31 | fmt.Println(len(m)) 32 | fmt.Println(m) 33 | 34 | } 35 | func main0702() { 36 | m := make(map[string]int) 37 | 38 | m["hello"] = 1 39 | 40 | m["itcast"] = 2 41 | 42 | // map中的键和值不能交换使用 43 | fmt.Println(m["hello"]) 44 | 45 | for k, v := range m { 46 | fmt.Println(k, v) 47 | } 48 | 49 | } 50 | 51 | func main() { 52 | //统计字符出现次数 53 | var str string 54 | fmt.Scan(&str) 55 | 56 | //将字符串转成字符切片 57 | ch := []byte(str) 58 | 59 | m:=make(map[byte]int) 60 | for i := 0; i < len(ch); i++ { 61 | //fmt.Println(ch[i]) 62 | m[ch[i]]++ 63 | } 64 | 65 | for k,v:=range m { 66 | fmt.Printf("%c %d\n",k,v) 67 | } 68 | 69 | } 70 | -------------------------------------------------------------------------------- /go基础学习所有代码例题/06学习/代码demo/08map中的值.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main0801() { 6 | 7 | m:=map[int]string{101:"刘备",103:"貂蝉",105:"李逵"} 8 | 9 | //对map中的值键判断 返回值为 value值 ok 键对应值是否存在 10 | value,ok:=m[101] 11 | 12 | if ok ==true{ 13 | fmt.Println(value) 14 | }else{ 15 | fmt.Println("未找到数据") 16 | } 17 | } 18 | 19 | 20 | func main0802(){ 21 | m:=map[int]string{101:"刘备",103:"貂蝉",105:"李逵"} 22 | 23 | fmt.Println(m) 24 | //删除map元素 delete(map,键) 25 | delete(m,105) 26 | delete(m,101) 27 | fmt.Println(m) 28 | 29 | } -------------------------------------------------------------------------------- /go基础学习所有代码例题/06学习/代码demo/09map作为函数参数.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | //map作为函数参数 6 | func test2(m map[int]string) { 7 | 8 | //修改map中的元素 9 | m[103] = "PDD" 10 | //添加数据 11 | m[104] = "段誉" 12 | 13 | delete(m, 102) 14 | fmt.Println(m) 15 | 16 | } 17 | 18 | func main0901() { 19 | 20 | //map中的键是单一数据类型 需要支持 == != 不支持复合类型 数组 切片 21 | m := map[int]string{101: "张飞", 102: "马菲菲", 103: "卢本伟"} 22 | //map作为函数参数 地址传递 形参可以改变实参的值 23 | test2(m) 24 | fmt.Println(m) 25 | 26 | } 27 | 28 | func main() { 29 | //map中的值为复合类型 30 | m := make(map[string][]int) 31 | 32 | m["毕向东"] = []int{60, 59, 61} 33 | m["尹志平"] = []int{99, 100, 101} 34 | m["黎活明"] = []int{10, 15, 20} 35 | 36 | for k, v := range m { 37 | //fmt.Println(k,v) 38 | sum := 0 39 | for _, data := range v { 40 | sum += data 41 | } 42 | fmt.Printf("%s 成绩为：%d 平均分：%d\n",k,sum,sum/len(v)) 43 | 44 | } 45 | 46 | } 47 | -------------------------------------------------------------------------------- /go基础学习所有代码例题/06学习/代码demo/10结构体定义和使用.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | //type 结构体名 struct{ 6 | //结构体成员列表 7 | // 成员名 数据类型 8 | // name string 9 | // score int 10 | //} 11 | 12 | // () [] 结构体成员选择 . 13 | 14 | //代码格式化对齐 ctrl+alt+l 15 | //结构体定义在函数外 可以被项目中所有函数使用 结构体名称是唯一的 16 | type Student struct { 17 | id int 18 | name string 19 | score int 20 | age int 21 | sex string 22 | addr string 23 | } 24 | 25 | func main() { 26 | 27 | //结构体是一种数据类型 28 | //var stu Student=Student{101,"刘提纲",101,31,"女","上海浦东新区"} 29 | //自动推导类型创建结构体 30 | //stu:=Student{102,"结构体",1000,24,"男","山东龙口"} 31 | stu := Student{name: "马克", age: 18, sex: "女", score: 10, addr: "长达小区", id: 103} 32 | //结构体变量 33 | //结构体变量.成员名 34 | //stu.id =101 35 | //stu.score=100 36 | //stu.sex="男" 37 | //stu.name="刘法师" 38 | //stu.age=31 39 | //stu.addr="上海浦东新区" 40 | 41 | fmt.Println(stu) 42 | fmt.Printf("%T\n", stu) 43 | } 44 | -------------------------------------------------------------------------------- /go基础学习所有代码例题/06学习/代码demo/11结构体赋值和比较.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | type student struct { 6 | id int 7 | name string 8 | age int 9 | sex string 10 | score int 11 | addr string 12 | } 13 | 14 | func main() { 15 | 16 | 17 | stu:=student{101,"秦海东",18,"女",100,"江苏启东"} 18 | 19 | //结构体赋值 20 | s1:=stu 21 | 22 | 23 | s1.sex="男" 24 | //结构体比较时 比较所有成员是否相同 25 | //结构体变量不允许 大小比较 结构体成员可以进行大小比较 26 | if s1==stu{ 27 | fmt.Println("相同") 28 | }else{ 29 | fmt.Println("不相同") 30 | } 31 | 32 | 33 | //fmt.Println(s1) 34 | //fmt.Println(stu) 35 | // 36 | //fmt.Printf("%p\n",&stu) 37 | //fmt.Printf("%p\n",&stu.id) 38 | //fmt.Printf("%p\n",&stu.name) 39 | //fmt.Printf("%p\n",&stu.age) 40 | //fmt.Printf("%p\n",&stu.sex) 41 | //fmt.Printf("%p\n",&s1) 42 | 43 | 44 | } 45 | -------------------------------------------------------------------------------- /go基础学习所有代码例题/06学习/相关资料及笔记/01切片作为函数参数.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/go基础学习所有代码例题/06学习/相关资料及笔记/01切片作为函数参数.png -------------------------------------------------------------------------------- /go基础学习所有代码例题/06学习/相关资料及笔记/02结构体赋值.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/go基础学习所有代码例题/06学习/相关资料及笔记/02结构体赋值.png -------------------------------------------------------------------------------- /go基础学习所有代码例题/06学习/相关资料及笔记/03结构体数组.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/go基础学习所有代码例题/06学习/相关资料及笔记/03结构体数组.png -------------------------------------------------------------------------------- /go基础学习所有代码例题/07学习/代码demo/01结构体作为函数参数.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | type student struct { 6 | id int 7 | name string 8 | age int 9 | sex string 10 | score int 11 | addr string 12 | } 13 | 14 | //结构体变量作为函数参数 15 | func test1(stu student) student { 16 | //fmt.Println(stu) 17 | stu.age = 16 18 | return stu 19 | } 20 | func main0101() { 21 | 22 | //结构体变量作为函数参数 23 | stu := student{101, "惠静", 18, "女", 100, "长达小区"} 24 | 25 | //结构体变量作为函数参数是值传递 形参不能改变实参的值 26 | stu = test1(stu) 27 | 28 | fmt.Println(stu) 29 | 30 | } 31 | 32 | func test2(stu []student) { 33 | //fmt.Println(stu) 34 | stu[2].name = "老衲" 35 | } 36 | func main() { 37 | stu := []student{student{101, "惠静", 18, "女", 100, "长达小区"}, 38 | student{102, "刘菁", 18, "女", 100, "长达小区"}, 39 | student{103, "师太", 18, "女", 100, "长达小区"}} 40 | //数组作为函数参数是值传递 41 | //切片作为函数参数是地址传递 42 | test2(stu) 43 | 44 | fmt.Println(stu) 45 | 46 | } 47 | 48 | func test(stu map[int]student) { 49 | //stu[101].name="段丁方"//err 50 | stu[103] = student{101, "段丁方", 18, "女", 100, "长达小区"} 51 | 52 | delete(stu, 102) 53 | } 54 | func main0103() { 55 | stu := make(map[int]student) 56 | stu[101] = student{101, "惠静", 18, "女", 100, "长达小区"} 57 | stu[102] = student{102, "刘菁", 18, "女", 100, "长达小区"} 58 | 59 | //map作为函数参数 地址传递 60 | test(stu) 61 | fmt.Println(stu) 62 | } 63 | -------------------------------------------------------------------------------- /go基础学习所有代码例题/07学习/代码demo/02指针定义和使用.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | 7 | var a int = 10 8 | 9 | fmt.Printf("%p\n", &a) 10 | 11 | //将a的地址赋值给一个指针变量 12 | //指针* 表示一级指针 13 | var p *int = &a 14 | fmt.Printf("%p\n", p) 15 | //fmt.Printf("%p\n",&p) 16 | 17 | //通过指针间接修改变量的值 18 | *p = 100 19 | 20 | fmt.Println(a) 21 | 22 | fmt.Printf("%T\n", p) 23 | //fmt.Printf("%T\n",&p) 24 | } 25 | -------------------------------------------------------------------------------- /go基础学习所有代码例题/07学习/代码demo/03指针的使用.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | func main0301() { 8 | 9 | //定义指针如果为赋初始值默认值为nil 10 | //nil指向内存地址编号为0的空间 11 | //invalid memory address or nil pointer dereference 12 | //无效的内存地址或者是一个空指针的引用 13 | var p *int //空指针 14 | //fmt.Printf("%p\n",p) 15 | //fmt.Println(p) 16 | //指针变量指向了内存地址编号为0的空间 0-255为系统占用不允许读写操作 17 | //*p=100//err //写入操作 18 | fmt.Println(*p) //err 读操作 19 | 20 | //var slice []int//0x0 21 | //slice=append(slice,1,2,3) 22 | //var slice =make([]int,5) 23 | //var m map[int]string=make(map[int]string) 24 | //m[101]="hello" 25 | 26 | } 27 | func main0302() { 28 | //野指针 指针变量指向内存中一个未知的空间 29 | //从操作野指针对应的内存空间会报错 30 | //var p *int =*int(0xff00) 31 | var a int = 10 32 | var p *int = &a 33 | //野指针 34 | //p = 100 35 | *p = 100 36 | 37 | fmt.Println(*p) 38 | 39 | } 40 | 41 | func main() { 42 | a := 10 43 | var p *int 44 | var p1 *int 45 | //fmt.Println(p) 46 | //new 创建一块新的空间 将空间的地址赋值给一个指针变量 47 | p = new(int) //new 新建内存默认存储的值和（）内的类型是一致的 48 | p1 = p 49 | 50 | *p = 100 51 | p = &a 52 | fmt.Println(*p) 53 | fmt.Println(*p1) 54 | } 55 | -------------------------------------------------------------------------------- /go基础学习所有代码例题/07学习/代码demo/04指针作为函数参数.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func test3(a int, b int) { 6 | a, b = b, a 7 | } 8 | func test4(a *int, b *int) { 9 | 10 | //temp := *a 11 | //*a = *b 12 | //*b = temp 13 | *a, *b = *b, *a 14 | } 15 | func main() { 16 | a := 10 17 | b := 20 18 | //变量作为函数参数是值传递 19 | //test3(a, b) 20 | //指针作为函数参数是地址传递 21 | test4(&a, &b) 22 | fmt.Println(a, b) 23 | } 24 | -------------------------------------------------------------------------------- /go基础学习所有代码例题/07学习/代码demo/05数组指针.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main0501() { 6 | 7 | //数组 8 | var arr [10]int = [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 0} 9 | 10 | //定义指针指向数组 11 | //p := &arr 12 | //定义指针是要和数组元素个数数据类型保持一致 13 | var p *[10]int = &arr 14 | 15 | //数组首地址 16 | //fmt.Printf("%p\n",p) 17 | //fmt.Printf("%p\n",&arr) 18 | //fmt.Printf("%p\n",&arr[0]) 19 | 20 | //fmt.Printf("%T\n", p) 21 | //通过指针间接修改数组元素的值 22 | //(*p)[0]=123 23 | //(*p)[1]=222 24 | //数组指针加下标就可以直接修改数组元素的值 25 | //p[0]=123 26 | //p[1]=222 27 | // 28 | //fmt.Println(arr) 29 | 30 | //让数组指针和数组建立关系 31 | //for i := 0; i < len(p); i++ { 32 | // fmt.Println(p[i]) 33 | //} 34 | 35 | for i, v := range p { 36 | fmt.Println(i, v) 37 | } 38 | 39 | } 40 | 41 | //数组指针作为函数参数 42 | func test5(p *[10]int) { 43 | 44 | //fmt.Println(p) 45 | //修改数组元素的值 46 | p[0]=123 47 | p[1]=222 48 | } 49 | 50 | func main() { 51 | //数组 52 | var arr [10]int = [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 0} 53 | 54 | //数组指针作为函数参数是地址传递 55 | test5(&arr) 56 | 57 | fmt.Println(arr) 58 | } 59 | -------------------------------------------------------------------------------- /go基础学习所有代码例题/07学习/代码demo/06指针数组.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | 7 | a := 10 8 | b := 20 9 | c := 30 10 | //指针数组 11 | //每一个元素都是指针类型的 可以存储多个变量的地址 12 | var arr [3]*int 13 | arr[0] = &a 14 | arr[2] = &b 15 | arr[1] = &c 16 | 17 | fmt.Println(arr) 18 | // 19 | //fmt.Println(&a) 20 | //fmt.Println(&b) 21 | //fmt.Println(&c) 22 | 23 | //通过指针数组间接修改变量的值 24 | *arr[1]=222 25 | *arr[0]=123 26 | 27 | fmt.Println(a) 28 | fmt.Println(b) 29 | fmt.Println(c) 30 | 31 | //for i:=0;i<3;i++{ 32 | // fmt.Printf("%p\n",&arr[i]) 33 | //} 34 | //遍历指针数组 35 | //for i:=0;i 在这里我们了解go，学习go，调侃go ~~ 3 | 4 | * [1.seelog--浏览器实时查看日志](seelog_浏览器实时查看日志.md)
5 | * [2.open--小巧的打开框架](open--小巧的工具框架.md)
6 | * [3.melody_websocket框架](melody_websocket框架.md)
7 | * [4.grpc_go语言的RPC系统](grpc_go语言的RPC系统.md)
8 | * [5.gorm--orm框架](gorm--orm框架.md)
9 | * [6.casbin--权限控制框架](casbin--权限控制框架.md)
10 | * [7.colly--好用的爬虫框架](colly--好用的爬虫框架.md)
11 | -------------------------------------------------------------------------------- /go开源项目参考/casbin--权限控制框架.md: -------------------------------------------------------------------------------- 1 | 项目地址：https://github.com/casbin/casbin -------------------------------------------------------------------------------- /go开源项目参考/cgo_golang调用c语言.md: -------------------------------------------------------------------------------- 1 | 项目地址： -------------------------------------------------------------------------------- /go开源项目参考/colly--好用的爬虫框架.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/go开源项目参考/colly--好用的爬虫框架.md -------------------------------------------------------------------------------- /go开源项目参考/etcd--go消息队列.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/go开源项目参考/etcd--go消息队列.md -------------------------------------------------------------------------------- /go开源项目参考/gin--web框架.md: -------------------------------------------------------------------------------- 1 | package golang开源项目 2 | -------------------------------------------------------------------------------- /go开源项目参考/go-cloud--golang云管理.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/go开源项目参考/go-cloud--golang云管理.md -------------------------------------------------------------------------------- /go开源项目参考/gorm--orm框架.md: -------------------------------------------------------------------------------- 1 | 项目地址：https://github.com/jinzhu/gorm 2 | -------------------------------------------------------------------------------- /go开源项目参考/grpc_go语言的RPC系统.md: -------------------------------------------------------------------------------- 1 | 项目地址：https://github.com/grpc/grpc -------------------------------------------------------------------------------- /go开源项目参考/melody_websocket框架.md: -------------------------------------------------------------------------------- 1 | 项目地址：https://github.com/olahol/melody
2 | 项目demo:https://zhuanlan.zhihu.com/p/42112159 3 | 4 | -------------------------------------------------------------------------------- /go开源项目参考/nsq--go消息队列.md: -------------------------------------------------------------------------------- 1 | package golang开源项目 2 | -------------------------------------------------------------------------------- /go开源项目参考/open--小巧的工具框架.md: -------------------------------------------------------------------------------- 1 | 项目地址：https://github.com/skratchdot/open-golang
2 | 项目作用：代码直接打开浏览器、文件等。
3 | 使用方式： 4 | ```go 5 | open.Run("https://github.com/xmge/gonote") 6 | 7 | etc... 8 | 9 | ``` -------------------------------------------------------------------------------- /go开源项目参考/seelog_浏览器实时查看日志.md: -------------------------------------------------------------------------------- 1 | # seelog [![Build Status](https://travis-ci.org/xmge/seelog.svg?branch=master)](https://travis-ci.org/xmge/seelog) [![License](https://img.shields.io/badge/license-MIT-brightgreen.svg)](https://github.com/xmge/seelog/blob/master/LICENSE) 2 | 3 | 4 | > 有了seelog,妈妈再也不用担心我登录服务器查看日志le... 5 | 项目地址：https://github.com/xmge/seelog 6 | 演示地址：http://seelog.xmge.top 7 | 欢迎各位gopher使用指正:smiley: 8 | 9 | ### 项目背景 10 | > A：我去:confused:,,程序又出问题了，你去看看日志到底是哪里错啦 11 | B：好好好，我马上登陆服务器看看 12 | B：对啦，服务器密码是啥来着.... 13 | A：:cold_sweat: 密码是 &#￥&*@*~ 14 | B：额，日志文件在哪呢 15 | A：................... 16 | C：要不项目集成seelog吧，集成特别简单，集成后直接打开浏览器就能看日志了 17 | 18 | ### 项目介绍 19 | * 与golang项目集成、提供浏览器实时查看日志的功能，类似 [tail -f xxx.log](https://www.cnblogs.com/fps2tao/p/7698224.html) 20 | * 支持多浏览器同时访问 21 | * 支持浏览器websocket断线重连 22 | * 支持暂停、清屏、截图、过滤功能 23 | * 查找功能可直接使用浏览器 `Ctrl+F` 来完成 24 | 25 | ### 集成方式 26 | * 在项目中引入seelog, **go get github.com/xmge/seelog** 27 | * 在代码中 执行 **seelog.See(logpath,port)** 28 | * 在浏览器中访问 *http://host:port* 29 | 30 | ### 项目展示 31 | ![image](https://github.com/xmge/seelog/blob/master/demo.gif) 32 | -------------------------------------------------------------------------------- /go标准库/README.md: -------------------------------------------------------------------------------- 1 | ## golang标准库 2 | > 标准库对于广大亲爱的gopher而言，无疑是一笔巨大的财富，我们应该将这笔巨大的财富掌握在自己的手中，让其发挥出真正的作用，展现出耀眼的光芒。 3 | 4 | 5 | -------------------------------------------------------------------------------- /go标准库/fmt/fprint.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | fmt.Println("sdfsdf") 7 | } 8 | -------------------------------------------------------------------------------- /go标准库/fmt/fprintf.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | func main() { 8 | fmt.Println("") 9 | } 10 | -------------------------------------------------------------------------------- /go标准库/fmt/fprintln.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /go标准库/fmt/fscan.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /go标准库/fmt/print.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /go标准库/fmt/printf.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /go标准库/fmt/println.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /go标准库/fmt/scan.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /go标准库/fmt/scanf.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /go标准库/fmt/scanln.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /go标准库/fmt/sprint.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /go标准库/fmt/sprintf.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /go标准库/fmt/sprintln.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /go标准库/fmt/sscan.go: -------------------------------------------------------------------------------- 1 | package main 2 | -------------------------------------------------------------------------------- /go标准库/fmt/sscanf.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | /* 6 | 7 | 原型: int sscanf (const char *str,const char * format,........); 8 | 9 | 说明： sscanf()会将参数str的字符串根据参数format字符串来转换并格式化数据。转换后的结果存于对应的参数内。 10 | 11 | 成功则返回参数数目，失败则返回0。 12 | 13 | 注意：sscanf与scanf类似，都是用于输入的，只是后者以键盘(stdin)为输入源，前者以固定字符串为输入源。 14 | 15 | 大家都知道sscanf是一个很好用的函数，利用它可以从字符串中取出整数、浮点数和字符串等等。它的使用方法简单，特别对于整数和浮点数来说。 16 | 17 | 这里就举几个经常用到的例子来说明他的用法，便于大家深刻理解他的用法 18 | 19 | */ 20 | 21 | func main() { 22 | 23 | // 对于空格分割的字符串 进行格式化赋值 24 | var t1 = "xmge/27/男 212 324" 25 | var name,sex string 26 | var age uint 27 | fmt.Println(fmt.Sscanf(t1,"%s/%d/%s",&name,&age,&sex)) 28 | fmt.Println(name,age,sex) 29 | 30 | 31 | } -------------------------------------------------------------------------------- /go标准库/fmt/sscanln.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func TestPrit() { 4 | 5 | } -------------------------------------------------------------------------------- /go标准库/http.md: -------------------------------------------------------------------------------- 1 | ## Http包详解 -------------------------------------------------------------------------------- /go标准库/sync/sync.go: -------------------------------------------------------------------------------- 1 | package sync 2 | -------------------------------------------------------------------------------- /go标准库/sync/sync.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/go标准库/sync/sync.md -------------------------------------------------------------------------------- /go相关教学视频/README.md: -------------------------------------------------------------------------------- 1 | ## golang教学视频 2 | 3 | - 1.《Google资深工程师深度讲解Go语言》》
4 | 链接: https://pan.baidu.com/s/1IGM-Zqz92AdkskqjBxpeDA
5 | 密码：b9wc 6 | 7 | - 2.《Docker+Kubernetes(k8s)微服务容器化实践》
8 | 链接: https://pan.baidu.com/s/1dRixHcR6KkmlTkjqc4eR2A
9 | 密码: 88rh 10 | 11 | - 3.《系统学习Docker 践行DevOps理念》
12 | 链接: https://pan.baidu.com/s/1sJlyGIXhX5Z8wy9KTMQMFg
13 | 密码: kvhr 14 | 15 | - 4.《区块链入门与去中心化应用实战》
16 | 链接: https://pan.baidu.com/s/1BP7UelCYCZ-DBq_vzKpXVw
17 | 密码: 2wfr 18 | 19 | - 5.《go语言教程系列--无闻讲师》
20 | 链接: https://pan.baidu.com/s/1MICn4I-gYl8Wb65bAzEXWA
21 | 密码: 17kq 22 | 23 | - 6.《传智播客2018go语言》
24 | 链接: https://pan.baidu.com/s/1opGP5gUHBAuw4QvqFFaxKA
25 | 密码: 6ewg 26 | 27 | - 7.《220小时快速入门go语言视频》
28 | 链接: https://pan.baidu.com/s/1SOybRHWSpbu16D4SmPR_Fg
29 | 密码: ss32 30 | 31 | - 8.《go语言教程-老男孩教学》
32 | 链接: https://pan.baidu.com/s/1TfApasVzngYRxxHotq-4Fg
33 | 密码: yqqs 34 | 35 | - 9.《基于Golang协程实现流量统计系统》
36 | 链接: https://pan.baidu.com/s/1CDnuKHJn0BA9OAnsmd8adA
37 | 密码: qjr3 38 | 39 | - 10.《黑马Go语言快速入门（2018年2月更新精品，不带源码课件）》
40 | 链接：https://pan.baidu.com/s/1u50RcepOgGmgar0FG_bOMw
41 | 密码: wckx 42 | 43 | - 11.**区块链从入门到精通系统篇** 44 | 45 | 链接：https://pan.baidu.com/s/1NXbX3gS4agQgtaylUikDZw 46 | 47 | - 12.**区块链精品教程系列-智能合约篇** 48 | 49 | 链接： 50 | 51 | - 13.**区块链精品教程三-密码学篇** 52 | 53 | 链接：https://pan.baidu.com/s/11orEFkPmf2pJk-z6xTB9fg 54 | 55 | - 14.go语言超详细学习知识体系 56 | 57 | 链接： 58 | 59 | - 15.**Go语言Web开发Beego框架深入浅出** 60 | 61 | 链接： 62 | 63 | - 16.GO和C的搞笑混合编程 64 | 65 | 链接： 66 | 67 | 68 | 69 | -------------------------------------------------------------------------------- /go经典题积累/README.md: -------------------------------------------------------------------------------- 1 | ## golang面试题 2 | > 以考代练，预祝各位考生取得优异成绩！fighting 3 | 4 | * [1.卷一](卷1.md)
5 | * [2.卷二](卷2.md)
6 | * [3.卷三](卷3.md)
7 | * [4.卷四](卷4.md)
8 | -------------------------------------------------------------------------------- /go经典题积累/卷4.md: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/go经典题积累/卷4.md -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/01学习/代码demo/01-指针.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | /*func main() { 6 | var a int = 10 7 | var p *int = &a 8 | 9 | fmt.Println("a = ", a) 10 | fmt.Println("*p = ", *p) 11 | }*/ 12 | 13 | func test(d int) { 14 | var m int = 400 15 | m += d 16 | } 17 | func main() { 18 | // var a int = 10 19 | // fmt.Println("&a=", &a) 20 | var p *int = nil 21 | p = new(int) // 给指针做有效初始化 22 | 23 | test(90) 24 | 25 | *p = 100 26 | fmt.Println("*p =", *p) 27 | } 28 | 29 | 30 | 31 | 32 | -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/01学习/代码demo/02-指针传值和传引用.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | func swap(a, b int) { 8 | a, b = b, a 9 | fmt.Printf("swap: a=%d, b=%d\n", a, b) 10 | } 11 | 12 | func swap2(a, b *int) { 13 | *a, *b = *b, *a 14 | fmt.Printf("swap2: *a=%d, *b=%d\n", *a, *b) 15 | } 16 | 17 | func main() { 18 | var a int = 10 19 | var b int = 300 20 | 21 | fmt.Printf("main 1: a=%d, b=%d\n", a, b) 22 | //swap(a, b) 23 | swap2(&a, &b) 24 | fmt.Printf("main 2: a=%d, b=%d\n", a, b) 25 | 26 | } -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/01学习/代码demo/03-截取切片.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | /*func main() { 6 | arr := [10]int {1, 2, 3, 4, 5, 6, 7, 8, 9, 10} 7 | 8 | fmt.Println("len(arr) = ", len(arr)) 9 | fmt.Println("cap(arr) = ", cap(arr)) 10 | 11 | s1 := arr[1:5:5] // {2, 3, 4, 5} 12 | 13 | fmt.Println("s1 = ", s1) 14 | fmt.Println("len(s1) = ", len(s1)) 15 | fmt.Println("cap(s1) = ", cap(s1)) 16 | 17 | s2 := s1[2:3] // {2, 3, 4, 5, 6, 7} -- max : 4 18 | 19 | fmt.Println("s2 = ", s2) 20 | fmt.Println("len(s2) = ", len(s2)) 21 | fmt.Println("cap(s2) = ", cap(s2)) 22 | }*/ 23 | 24 | func main() { 25 | arr := [10]int {1, 2, 3, 4, 5, 6, 7, 8, 9, 10} 26 | 27 | s1 := arr[2:5] // 3, 4, 5 --> 3 666 5 28 | s1[1] = 666 29 | fmt.Println("s1=", s1) 30 | 31 | s2 := s1[2:7] // 5, 6, 7, 8, 9 --> 5, 6, 777, 8, 9 32 | s2[2] = 777 33 | fmt.Println("s2=", s2) 34 | fmt.Println("cap(s2) = ", cap(s2)) 35 | 36 | fmt.Println("arr=", arr) 37 | } 38 | -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/01学习/代码demo/04-创建切片.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | 7 | // 使用数组方式创建切片 8 | var s1 = [] int {1, 2, 4, 6} 9 | fmt.Println("s1=", s1) 10 | 11 | fmt.Println("len=", len(s1), "cap=", cap(s1)) 12 | 13 | // 使用make创建切片。 指定 len、指定 cap 14 | s2 := make([]string, 5, 10) // 有空间，初值为 数据类型的默认值。 15 | 16 | fmt.Println("s2 = ", s2) 17 | fmt.Printf("s2[0] = %q\n", s2[0]) 18 | fmt.Println("len=", len(s2), "cap=", cap(s2)) 19 | 20 | // 使用make创建切片。 指定 len 21 | s3 := make([]int, 7) // 没有指定容量，cap == len 22 | 23 | fmt.Println("s3 =", s3) 24 | fmt.Println("len=", len(s3), "cap=", cap(s3)) 25 | 26 | } 27 | -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/01学习/代码demo/05-切片操作函数.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | /*func main() { 6 | 7 | var s1 = []int {1, 2, 3} 8 | 9 | fmt.Println("s1=", s1, "cap=", cap(s1)) 10 | 11 | s1 = append(s1, 10) 12 | 13 | fmt.Println("s1=", s1, "cap=", cap(s1)) 14 | s1 = append(s1, 11) 15 | s1 = append(s1, 12) 16 | s1 = append(s1, 13) 17 | 18 | fmt.Println("s1=", s1, "cap=", cap(s1)) 19 | 20 | }*/ 21 | func main() { 22 | var s1 = []int {1, 2, 3, 4, 5, 7} 23 | var s2 = []int {0, 0, 0, 0, 5, 7} 24 | 25 | copy(s2[1:4], s1[1:4]) 26 | 27 | fmt.Println("s2=", s2) 28 | 29 | } 30 | -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/01学习/代码demo/06-切片做函数参数1.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | 6 | // 该示例—— 切片做函数参数，传地址（引用) 7 | func testFunc(s []int) { // 切片做函数参数 8 | s[0] = -1 // 直接修改 main中的 slice 9 | } 10 | 11 | func main() { 12 | slice := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9} 13 | 14 | fmt.Println(slice) 15 | 16 | testFunc(slice) 17 | 18 | fmt.Println(slice) 19 | } 20 | -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/01学习/代码demo/07-切片做函数参数2.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | 6 | // 切片做函数参数，传值 7 | func testFunc2(s []int) []int { // 切片做函数参数 8 | s = append(s, 777) 9 | fmt.Println("testFunc2: s=", s) 10 | 11 | return s 12 | } 13 | 14 | func main() { 15 | slice := []int{0, 1, 2} 16 | 17 | fmt.Println("main before: s=", slice) 18 | 19 | aferData := testFunc2(slice) 20 | fmt.Println("main after: s=", slice) 21 | fmt.Println("main after: aferData=", aferData) 22 | } 23 | -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/01学习/代码demo/08-切片练习1.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | // 使用append 完成字符串去空值。 6 | func noEmpty(string []string) []string { 7 | // 创建一个空切片，用来存储 非空字符串 8 | out := string[:0] // make([]string, 0) 9 | for _, word := range string { 10 | if word != "" { 11 | out = append(out, word) 12 | } 13 | } 14 | return out 15 | } 16 | 17 | // 不使用append 完成字符串去空值。 18 | func noEmpty2(string []string) []string { 19 | i := 0 20 | for _, word := range string { 21 | if word != "" { 22 | string[i] = word 23 | i++ 24 | } 25 | } 26 | return string[:i] 27 | } 28 | 29 | func main() { 30 | data := []string{"red", "", "black", "", "", "pink", "blue"} 31 | //afterData := noEmpty(data) 32 | afterData := noEmpty2(data) 33 | fmt.Println("data=", data) 34 | fmt.Println("afterData=", afterData) 35 | } 36 | -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/01学习/代码demo/09-切片练习2.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func noSame(str []string) []string { 6 | out := str[:1] // "red" --》 out 7 | 8 | for _, word := range str { 9 | i := 0 10 | for ; i < len(out); i++ { 11 | if word == out[i] { 12 | break 13 | } 14 | } 15 | if i == len(out) { 16 | out = append(out, word) 17 | } 18 | } 19 | return out 20 | } 21 | 22 | func main() { 23 | color := []string{"red", "black","Green", "red", "Green","Green","Green","Green", "pink", "blue", "pink", "blue"} 24 | data := noSame(color) 25 | fmt.Println("data:", data) 26 | } 27 | -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/01学习/代码demo/10-切片练习3.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func remove(data []int, idx int) []int { 6 | 7 | copy(data[idx:], data[idx+1:]) 8 | 9 | return data[:len(data)-1] 10 | } 11 | 12 | func main() { 13 | 14 | data := []int {5, 6, 7, 8, 9} // {5, 6, 7, 8, 9} --> {5, 6, 8, 9, 9} 15 | 16 | afterData := remove(data, 3) 17 | 18 | fmt.Println("afterData:", afterData) 19 | } 20 | -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/01学习/代码demo/11-map.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | // 1. 7 | var m1 = map[int]string{1:"red", 5021:"black", 502:"yellow"} 8 | fmt.Println("m1=", m1) 9 | 10 | // 2. 11 | var m2 = map[int]string{} 12 | m2[4] = "abc2" 13 | m2[4] = "abc8910" // key 与已有key 重复，会直接覆盖原有key -- value 14 | fmt.Println("m2=", m2) 15 | 16 | // 3. 17 | m3 := make(map[int]string, 13) // 0： 表示初始容量 。 ——map 没有 cap 18 | m3[45] = "abc" 19 | m3[46] = "abc" 20 | m3[47] = "abc" 21 | m3[452] = "abc" 22 | 23 | fmt.Println("m3=", m3, "len=", len(m3)/*, "cap=", cap(m3)*/) 24 | 25 | m4 := make(map[string]string) // 【常用】 map 可以动态扩容。 26 | 27 | m4["a"] = "aaaa" 28 | m4["b"] = "bbbb" 29 | m4["c"] = "cccc" 30 | m4["d"] = "dddd" 31 | 32 | fmt.Println("m4=", m4) 33 | 34 | } -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/01学习/代码demo/12-map的遍历和判断.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | func main() { 8 | m1 := map[int]string{1: "Luffy", 2: "Sanji", 3:"Zoro", 5:"Nami"} 9 | 10 | m1[3] = "zhangsan" //覆盖原有 map 中 key 值为 3 的 value 11 | for k, v := range m1 { 12 | fmt.Printf("[%d]%s\n", k, v) 13 | } 14 | 15 | /* for _, v := range m1 { } // 忽略 key 值，取 value 16 | for k，_ := range m1 { } // 忽略 value 值， 取 key 值*/ 17 | 18 | // 默认 range 可以省略 value 值 19 | for k := range m1 { 20 | fmt.Printf("%v\n", k) 21 | } 22 | // 判断 map 中的某一个元素是否存在。 23 | if data, has := m1[5]; !has { // has == false 24 | fmt.Printf("1, has=%v, data:%q\n", has, data) 25 | } else { 26 | fmt.Printf("2, has=%v, data:%q\n", has, data) 27 | } 28 | 29 | } 30 | -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/01学习/代码demo/13-删除和传参.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "strconv" 6 | "strings" 7 | ) 8 | 9 | func mapDelete(m map[int]string, key int) { 10 | 11 | for i:=10; i<=50; i++ { 12 | m[i] = "aaa" + strconv.Itoa(i) 13 | } 14 | fmt.Println("mapDelete: m = ", m, "len = ", len(m)) 15 | 16 | delete(m, key) 17 | 18 | strings.Fields() 19 | } 20 | 21 | func main() { 22 | m1 := map[int]string{1: "Luffy", 2: "Sanji", 3:"Zoro", 5:"Nami"} 23 | 24 | mapDelete(m1, 3) 25 | 26 | fmt.Println("main : m1=", m1, "len = ", len(m1)) 27 | } 28 | -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/01学习/代码demo/14-map练习.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "strings" 5 | "fmt" 6 | ) 7 | 8 | func wordCountFunc2(str string) map[string]int { 9 | // 按空格拆分字符串 10 | words := strings.Fields(str) 11 | m := make(map[string]int) //创建初始容量为 0 的map 12 | 13 | for _, data := range words { 14 | m[data]++ 15 | } 16 | return m 17 | } 18 | 19 | func wordCountFunc(str string) map[string]int { 20 | // 按空格拆分字符串 21 | words := strings.Fields(str) 22 | m := make(map[string]int) //创建初始容量为 0 的map 23 | 24 | for _, data := range words { 25 | if _, ok := m[data]; !ok { // 当 ok == false ，当前if 满足 26 | m[data] = 1 27 | } else { // 当 ok == true , 满足 28 | m[data]++ 29 | } 30 | } 31 | return m 32 | } 33 | 34 | func main() { 35 | string := "I love my work and I love my family family family family too love love love" 36 | 37 | //retMap := wordCountFunc(string) 38 | retMap := wordCountFunc2(string) 39 | 40 | for k, v := range retMap { 41 | fmt.Printf("%s:%d\n", k, v) 42 | } 43 | 44 | } 45 | -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/01学习/相关资料及笔记/01-内存布局-栈帧.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/go网络编程深入所有代码例题笔记/01学习/相关资料及笔记/01-内存布局-栈帧.png -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/01学习/相关资料及笔记/02-切片做为函数参数.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/go网络编程深入所有代码例题笔记/01学习/相关资料及笔记/02-切片做为函数参数.png -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/01学习/相关资料及笔记/02-切片做为函数参数修改.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/go网络编程深入所有代码例题笔记/01学习/相关资料及笔记/02-切片做为函数参数修改.png -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/01学习/相关资料及笔记/03-切片练习分析.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/go网络编程深入所有代码例题笔记/01学习/相关资料及笔记/03-切片练习分析.png -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/01学习/相关资料及笔记/map 练习分析.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/go网络编程深入所有代码例题笔记/01学习/相关资料及笔记/map 练习分析.png -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/01学习/相关资料及笔记/变量传参-传值.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/go网络编程深入所有代码例题笔记/01学习/相关资料及笔记/变量传参-传值.jpg -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/01学习/相关资料及笔记/变量传参-传引用.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/go网络编程深入所有代码例题笔记/01学习/相关资料及笔记/变量传参-传引用.jpg -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/01学习/相关资料及笔记/笔记总结.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/go网络编程深入所有代码例题笔记/01学习/相关资料及笔记/笔记总结.txt -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/02学习/代码demo/01-结构体定义.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "unsafe" 6 | ) 7 | 8 | type Person struct { 9 | name string 10 | sex byte 11 | age int 12 | } 13 | 14 | type student struct { 15 | p Person // 结构体嵌套 16 | score [1000]int 17 | } 18 | 19 | func initFunc(p Person) Person { 20 | p.name = "name1" 21 | p.age = 19 22 | p.sex = 'f' 23 | 24 | fmt.Println("initFunc p:", p) 25 | fmt.Println("tmp size:", unsafe.Sizeof(p)) 26 | 27 | return p 28 | } 29 | 30 | 31 | func main() { 32 | // 1. 顺序初始化, 必须初始化所有的成员变量 33 | var p1 Person = Person{"Luffy", 'm', 99} 34 | fmt.Println("p1=", p1) 35 | 36 | // 2. 指定成员初始化, 未初始化成员取默认值 37 | p2 := Person{name:"Zoro", age:76} 38 | fmt.Println("p2=",p2) 39 | 40 | // 取成员变量， 使用“.” 41 | p2.sex = 'f' 42 | p2.age = 111 43 | fmt.Println("p2=",p2) 44 | 45 | // 结构体地址 == 结构体首元素地址。 46 | fmt.Printf("&p2 = %p\n", &p2) 47 | fmt.Printf("&p2.name = %p\n", &p2.name) 48 | fmt.Printf("&p2.name = %p\n", &p2.sex) 49 | 50 | p3 := Person{"Luffy", 'm', 99} 51 | p4 := Person{"Luffy", 'm', 99} 52 | p5 := Person{"Luffy", 'm', 912} 53 | 54 | fmt.Println("p3 == p4 ?", p3 == p4) 55 | fmt.Println("p3 == p5 ?", p3 != p5) 56 | 57 | var tmp Person 58 | fmt.Println("tmp=", tmp) 59 | 60 | fmt.Println("tmp size:", unsafe.Sizeof(tmp)) 61 | tmp = initFunc(tmp) 62 | 63 | fmt.Println("main tmp:", tmp) 64 | 65 | } 66 | -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/02学习/代码demo/02-结构体指针.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "unsafe" 6 | ) 7 | 8 | type Person2 struct { 9 | name string 10 | sex byte 11 | age int 12 | } 13 | 14 | func main() { 15 | /* // 1 顺序初始化 16 | var p1 *Person2 = &Person2{"n1", 'f', 11} 17 | fmt.Println("p=", p1) 18 | 19 | // 2 指定成员初始化 20 | p2 := &Person2{name:"n1", sex:'f'} 21 | fmt.Println("p2=", p2) 22 | 23 | // 3. 使用另一个结构体地址初始 24 | var p3 *Person2 25 | p3 = p2 26 | fmt.Println("p3=", p3) 27 | 28 | // 4. new, 指定成员赋值 29 | p4 := new(Person2) 30 | fmt.Println("p4=", p4) 31 | p4.name = "n4" 32 | p4.age = 119 33 | p4.sex = 'm' 34 | fmt.Println("p4=", p4) 35 | 36 | // 指针变量的值(地址) == 结构体首元素的地址 37 | fmt.Printf("p4 = %p\n", p4) 38 | fmt.Printf("p4.name = %p\n", &p4.name) 39 | 40 | fmt.Println("main 1: p4=", p4) 41 | test(p4) 42 | fmt.Println("main 2: p4=", p4)*/ 43 | 44 | var temp Person2 45 | fmt.Println("main 1: temp=", temp, "temp size:", unsafe.Sizeof(temp)) 46 | 47 | test(&temp) 48 | 49 | fmt.Println("main 2: temp=", temp) 50 | } 51 | 52 | func test(p *Person2) { 53 | p.name = "111111" 54 | p.sex = 'N' 55 | p.age = 111 56 | 57 | fmt.Println("test: p=", p, "temp size:", unsafe.Sizeof(p)) 58 | } -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/02学习/代码demo/03-结构体指针练习.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | type Test struct { 6 | name string 7 | flg bool 8 | age int 9 | interest []string 10 | } 11 | 12 | func initPerson (t *Test) { 13 | t.age = 10 14 | t.name = "Nami" 15 | t.flg = true 16 | t.interest = append(t.interest, "shopping") 17 | t.interest = append(t.interest, "sleeping") 18 | } 19 | 20 | 21 | func initPerson2 () *Test { 22 | //t := new(Test) // heap 23 | var t Test // 局部变量 —— 随着栈帧的释放，消失（无意义） 24 | t.age = 10 25 | t.name = "Nami" 26 | t.flg = true 27 | t.interest = append(t.interest, "shopping") 28 | t.interest = append(t.interest, "sleeping") 29 | 30 | return &t 31 | } 32 | 33 | func main() { 34 | /* var test Test initPerson(&test) 35 | fmt.Println("test=", test)*/ 36 | 37 | ret := initPerson2() 38 | 39 | fmt.Println("ret = ", ret) 40 | 41 | } 42 | -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/02学习/代码demo/04-字符串处理函数.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "strings" 5 | "fmt" 6 | ) 7 | 8 | /*func main() { 9 | flg := strings.Contains("hello", "lloi") 10 | fmt.Println("flg = ", flg) 11 | 12 | str := []string {"hello", "go", "haha", "xixi", "hoho"} 13 | retStr := strings.Join(str, "%") 14 | fmt.Println("retStr:", retStr) 15 | 16 | res := strings.Trim("hello", "o") 17 | fmt.Printf("res:%q\n", res) 18 | 19 | data := "a man a plan a canal panama a" 20 | resStr := strings.Replace(data, "a", "abc", 2) 21 | fmt.Printf("res:%q\n", resStr) 22 | }*/ 23 | 24 | func main() { 25 | 26 | str := "I love my work and I love my family too" 27 | /* ret := strings.Split(str, "I ") 28 | for _, word := range ret { 29 | fmt.Println(word) 30 | }*/ 31 | retStr := strings.Fields(str) 32 | for _, word := range retStr { 33 | fmt.Println(word) 34 | } 35 | 36 | flg := strings.HasSuffix("word cup.png", ".jpg") 37 | fmt.Println("flg = ", flg) 38 | 39 | flg =strings.HasPrefix("word cup.png", "worl") 40 | fmt.Println("flg = ", flg) 41 | 42 | } 43 | -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/02学习/代码demo/05-文件创建打开关闭.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "os" 5 | "fmt" 6 | ) 7 | 8 | /*func main() { 9 | f, err := os.Create("C:/itcast/test.txt") 10 | if err != nil { 11 | fmt.Println("Create err:", err) 12 | return 13 | } 14 | defer f.Close() 15 | 16 | fmt.Println("create successful") 17 | }*/ 18 | 19 | /*func main() { 20 | 21 | f, err := os.Open("C:/itcast/test.txt") 22 | if err != nil { 23 | fmt.Println("open err: ", err) 24 | return 25 | } 26 | defer f.Close() 27 | 28 | _, err = f.WriteString("hello world") 29 | if err != nil { 30 | fmt.Println("WriteString err: ", err) 31 | return 32 | } 33 | fmt.Println("open successful") 34 | }*/ 35 | 36 | func main() { 37 | f, err := os.OpenFile("C:/itcast/test.txt", os.O_RDWR | os.O_CREATE, 0600) // 777--rwx rwx rwx 38 | if err != nil { 39 | fmt.Println("OpenFile err: ", err) 40 | return 41 | } 42 | defer f.Close() 43 | f.WriteString("hello world12345...") 44 | 45 | fmt.Println("open successful") 46 | } 47 | -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/02学习/代码demo/06-写文件.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "os" 5 | "fmt" 6 | "io" 7 | ) 8 | 9 | func main() { 10 | 11 | f, err := os.Create("./test.txt") 12 | if err != nil { 13 | fmt.Println("Create err:", err) 14 | return 15 | } 16 | defer f.Close() 17 | 18 | n, err := f.WriteString("hello world\r\n") 19 | if err != nil { 20 | fmt.Println("WriteString err:", err) 21 | return 22 | } 23 | fmt.Println("n = ", n) 24 | 25 | //off, err := f.Seek(5, io.SeekStart) 26 | off, err := f.Seek(-5, io.SeekEnd) 27 | if err != nil { 28 | fmt.Println("Seek err:", err) 29 | return 30 | } 31 | fmt.Println("off:", off) 32 | 33 | n, err = f.WriteAt([]byte("1111"), off) 34 | if err != nil { 35 | fmt.Println("WriteAt err:", err) 36 | return 37 | } 38 | 39 | fmt.Println("write successful") 40 | } 41 | -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/02学习/代码demo/07-按行读文件.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "os" 5 | "fmt" 6 | "bufio" 7 | "io" 8 | ) 9 | 10 | func main() { 11 | f, err := os.Open("test.txt") 12 | if err != nil { 13 | fmt.Println("Open err:", err) 14 | return 15 | } 16 | defer f.Close() 17 | 18 | // 获取阅读器 reader， 自带缓冲区（用户缓冲）。 19 | reader := bufio.NewReader(f) 20 | 21 | for { // 循环读取文件， 当 err == io.EOF 结束循环 22 | // 使用 带分割符的 函数，读取指定数据 ‘\n’获取一行 23 | buf, err := reader.ReadBytes('\n') 24 | // 成功读取到的一行数据 保存在 buf中 25 | fmt.Printf("buf:%s", buf) 26 | if err != nil && err == io.EOF { 27 | break 28 | } 29 | } 30 | fmt.Println("文件读取完毕") 31 | } 32 | -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/02学习/代码demo/08-文件按字节读写.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | /*func main() { 4 | f, err := os.OpenFile("test.txt", os.O_RDWR, 0600) 5 | if err != nil { 6 | fmt.Println("Open err:", err) 7 | return 8 | } 9 | defer f.Close() 10 | 11 | buf := make([]byte, 4096) // 4k 12 | 13 | n, err := f.Read(buf) 14 | if err != nil { 15 | fmt.Println("Read err:", err) 16 | return 17 | } 18 | fmt.Printf("read data:%s", buf[:n]) 19 | }*/ 20 | 21 | /*func main() { 22 | f, err := os.OpenFile("test.txt", os.O_RDWR, 0600) 23 | if err != nil { 24 | fmt.Println("Open err:", err) 25 | return 26 | } 27 | defer f.Close() 28 | 29 | n, err := f.Write([]byte("AAA")) 30 | if err != nil { 31 | fmt.Println("Write err:", err) 32 | return 33 | } 34 | fmt.Println("n = ", n) 35 | }*/ 36 | 37 | 38 | -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/02学习/代码demo/09-大文件拷贝.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "os" 5 | "fmt" 6 | "io" 7 | ) 8 | 9 | func main() { 10 | // 创建 待读取的文件，和 待写入的文件 11 | f_r, err := os.Open("C:/itcast/01-结构体的定义和初始化.avi") 12 | if err != nil { 13 | fmt.Println("open err:", err) 14 | return 15 | } 16 | defer f_r.Close() 17 | 18 | f_w, err := os.Create("./test.avi") 19 | if err != nil { 20 | fmt.Println("Create err:", err) 21 | return 22 | } 23 | defer f_w.Close() 24 | 25 | buf := make([]byte, 4096) //创建缓冲区，存储读到的数据 26 | 27 | // 循环从 f_r 对应文件中读取数据， 28 | for { 29 | n, err := f_r.Read(buf) 30 | if err == io.EOF { 31 | fmt.Println("读取文件完成") 32 | break 33 | } 34 | if err != nil { 35 | fmt.Println("Read err:", err) 36 | return 37 | } 38 | // 原封不动写到 f_w 文件中, 读多少，写多少 39 | n, err = f_w.Write(buf[:n]) 40 | if err != nil { 41 | fmt.Println("Write err:", err) 42 | return 43 | } 44 | } 45 | 46 | os.OpenFile() 47 | } 48 | -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/02学习/代码demo/10-目录文件访问.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "os" 5 | "fmt" 6 | ) 7 | 8 | func main() { 9 | var dir string 10 | fmt.Print("请输入一个待判定的目录：") 11 | fmt.Scan(&dir) 12 | 13 | // 打开目录 14 | f, err := os.OpenFile(dir, os.O_RDONLY, os.ModeDir) 15 | if err != nil { 16 | fmt.Println("OpenFile err:", err) 17 | return 18 | } 19 | defer f.Close() 20 | 21 | // 读取目录项 -- 将一个目录下的所有内容， 存入[]FileInfo 22 | fileInfo, err := f.Readdir(-1) 23 | if err != nil { 24 | fmt.Println("Readdir err:", err) 25 | return 26 | } 27 | 28 | // 依次取出目录项 29 | for _, dirInfo := range fileInfo { 30 | if dirInfo.IsDir() { 31 | fmt.Printf("%s 是一个 目录\n", dirInfo.Name()) 32 | } else { 33 | fmt.Printf("%s is not 目录\n", dirInfo.Name()) 34 | } 35 | } 36 | 37 | } 38 | -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/02学习/相关资料及笔记/01-内存布局-栈帧.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/go网络编程深入所有代码例题笔记/02学习/相关资料及笔记/01-内存布局-栈帧.png -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/02学习/相关资料及笔记/Golang_Manual.chm: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/go网络编程深入所有代码例题笔记/02学习/相关资料及笔记/Golang_Manual.chm -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/02学习/相关资料及笔记/笔记总结.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/go网络编程深入所有代码例题笔记/02学习/相关资料及笔记/笔记总结.txt -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/02学习/相关资料及笔记/缓冲区.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/go网络编程深入所有代码例题笔记/02学习/相关资料及笔记/缓冲区.png -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/03学习/代码demo/00-test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "os" 5 | "fmt" 6 | "bufio" 7 | "io" 8 | "strings" 9 | ) 10 | 11 | func main() { 12 | 13 | f, err := os.Open("C:/itcast/test2/test.txt") 14 | if err != nil { 15 | fmt.Println("Open err:", err) 16 | return 17 | } 18 | defer f.Close() 19 | 20 | // 1 创建 reader 21 | reader := bufio.NewReader(f) 22 | var counter int = 0 23 | 24 | // for 循环 按行读取文件，--- this is a test for love --》[]string 25 | for { 26 | // 2 指定分隔符，按行提取数据 27 | buf, err := reader.ReadBytes('\n') // buf中保存读到的一行数据 28 | if err != nil && err == io.EOF { 29 | break 30 | } 31 | if err != nil { 32 | fmt.Println("ReadBytes err:", err) 33 | return 34 | } 35 | // 将一行数据中的所有单词 拆分 36 | //words := strings.Fields(string(buf)) 37 | words := strings.Split(string(buf), " ") 38 | for _, word := range words { 39 | fmt.Printf("word:%q\n", word) 40 | if word == "love" { 41 | counter++ // 统计 个数。 42 | } 43 | } 44 | fmt.Println("===============================") 45 | } 46 | fmt.Println("count:", counter) 47 | } 48 | -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/03学习/代码demo/01-文件练习题2.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "os" 6 | "strings" 7 | "io" 8 | ) 9 | 10 | func copyMp3ToDir(fileName, path string) { 11 | pathName := path + "/" + fileName 12 | fr, err := os.Open(pathName) // 打开 源文件 13 | if err != nil { 14 | fmt.Println("Open err:", err) 15 | return 16 | } 17 | defer fr.Close() 18 | 19 | fw, err :=os.Create("./" + fileName) // 打开拷贝的文件 20 | if err != nil { 21 | fmt.Println("Create err:", err) 22 | return 23 | } 24 | defer fw.Close() 25 | 26 | // 创建一个用于read 存储数据的 buf 27 | buf := make([]byte, 4096) 28 | 29 | // 循环从 fr 中读取数据， 原封不动 写到 fw中 30 | for { 31 | n, err := fr.Read(buf) 32 | if n == 0 { 33 | fmt.Println("文件拷贝完毕") 34 | break 35 | } 36 | if err != nil && err != io.EOF { 37 | fmt.Println("err:", err) 38 | } 39 | fw.Write(buf[:n]) // 读多少，写多少 40 | } 41 | 42 | } 43 | 44 | func main() { 45 | // 请用户指定 目录 46 | var path string 47 | fmt.Print("请输入目录位置：") 48 | fmt.Scan(&path) 49 | 50 | // 打开指定目录位置 51 | dir_fp, err := os.OpenFile(path, os.O_RDONLY, os.ModeDir) 52 | if err != nil { 53 | fmt.Println("Openfile err:", err) 54 | return 55 | } 56 | defer dir_fp.Close() 57 | 58 | // 读取目录项 59 | dirsInfo, err := dir_fp.Readdir(-1) 60 | if err != nil { 61 | fmt.Println("Readdir err:", err) 62 | return 63 | } 64 | // 从目录项[] 中提取每一个目录项 65 | for _, dir := range dirsInfo { 66 | fileName := dir.Name() 67 | // 根据后缀名，筛选文件 68 | if strings.HasSuffix(fileName, ".mp3") { 69 | 70 | // 将该文件 copy 至指定目录 71 | copyMp3ToDir(fileName, path) 72 | //fmt.Println("mp3文件有：", fileName) 73 | } 74 | } 75 | } 76 | -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/03学习/代码demo/03-goroutine引入.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "time" 6 | ) 7 | func singing() { 8 | for i:= 0; i<5; i++ { 9 | fmt.Println("======正在唱：青藏高原=====") 10 | time.Sleep(time.Second) 11 | } 12 | } 13 | 14 | func dancing() { 15 | for i:= 0; i<5; i++ { 16 | fmt.Println("======正在跳：赵四街舞=====") 17 | time.Sleep(time.Second) 18 | } 19 | } 20 | 21 | func main() { 22 | go singing() // 子 go 程 -- Goroutine --- Coroutine 23 | go dancing() 24 | /* for { // 作用是，保证主go程不结束 —— 进程地址空间 不会消失。 25 | ; 26 | }*/ 27 | } 28 | -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/03学习/代码demo/04-go并发.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "time" 6 | ) 7 | 8 | func task() { 9 | for { 10 | fmt.Println(" I am task") 11 | time.Sleep(300 * time.Millisecond) 12 | } 13 | } 14 | 15 | func main() { 16 | 17 | // 创建子go程 18 | go task() 19 | 20 | go func () { 21 | for { 22 | fmt.Println("I am 匿名 goroutine") 23 | time.Sleep(300 * time.Millisecond) 24 | } 25 | }() 26 | 27 | i := 0 28 | // 主 go程的 执行指令 29 | for { 30 | i++ 31 | fmt.Println("I am main goroutine, i=", i) 32 | time.Sleep(300 * time.Millisecond) 33 | if i == 3 { 34 | break 35 | } 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/03学习/代码demo/05-Gosched.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "runtime" 6 | ) 7 | 8 | func main() { 9 | 10 | go func(s string) { 11 | for i:=0; i<2;i++ { 12 | fmt.Println(s) 13 | } 14 | }("hello") 15 | 16 | for i:=0; i<2; i++ { 17 | runtime.Gosched() // 主动让出 cpu 使用权 18 | fmt.Println("world") 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/03学习/代码demo/06-Goexit.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "time" 6 | "os" 7 | ) 8 | 9 | func mm() { 10 | for i:=0; i<5;i++{ 11 | fmt.Println("11111111111111") 12 | time.Sleep(100 * time.Millisecond) 13 | if i == 2 { 14 | //return 15 | //runtime.Goexit() 16 | os.Exit(-24) 17 | } 18 | } 19 | } 20 | 21 | func test() { 22 | mm() 23 | //runtime.Goexit() // 将 go 程 结束 24 | defer fmt.Println("cccc") 25 | fmt.Println("dddd") 26 | } 27 | 28 | func main() { 29 | 30 | fmt.Println("aaaa") 31 | go test() 32 | time.Sleep(10 * time.Millisecond) 33 | 34 | fmt.Println("bbbb") 35 | 36 | for { 37 | fmt.Println("2222222222") 38 | time.Sleep(300 * time.Millisecond) 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/03学习/代码demo/07-GOMAXPROCS.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "runtime" 6 | ) 7 | 8 | func main() { 9 | n := runtime.GOMAXPROCS(1) // 第一次 测试 10 | fmt.Printf("n = %d\n", n) 11 | 12 | n = runtime.GOMAXPROCS(2) // 第二次 测试 13 | fmt.Printf("n = %d\n", n) 14 | 15 | n = runtime.GOMAXPROCS(8) // 第二次 测试 16 | fmt.Printf("n = %d\n", n) 17 | 18 | for { 19 | go fmt.Print(0) // 子go程 20 | fmt.Print(1) // 主go程 21 | } 22 | } 23 | 24 | -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/03学习/相关资料及笔记/并发.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/go网络编程深入所有代码例题笔记/03学习/相关资料及笔记/并发.png -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/03学习/相关资料及笔记/笔记总结.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/go网络编程深入所有代码例题笔记/03学习/相关资料及笔记/笔记总结.txt -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/03学习/相关资料及笔记/线程并发同步.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/go网络编程深入所有代码例题笔记/03学习/相关资料及笔记/线程并发同步.png -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/03学习/相关资料及笔记/虚拟地址和物理地址.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/go网络编程深入所有代码例题笔记/03学习/相关资料及笔记/虚拟地址和物理地址.png -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/04学习/代码demo/01-channel引入.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "time" 6 | ) 7 | 8 | /*// 定义一个用于通信的 channel, 完成go程同步 9 | var channel = make(chan int) 10 | 11 | func printer(s string) { 12 | for _, ch := range s { 13 | fmt.Printf("%c", ch) // 屏幕（硬件）—— 标准输出（文件）stdout 14 | time.Sleep(300 * time.Millisecond) 15 | } 16 | fmt.Println("") 17 | } 18 | func person1() { 19 | printer("hello") // 先 20 | // 写 channel 21 | channel <- 666 22 | } 23 | func person2() { 24 | // 读 channel 25 | <- channel 26 | printer("world") // 后 27 | } 28 | func main() { 29 | go person1() 30 | go person2() 31 | 32 | for { // 防止主go程提早结束 33 | ; 34 | } 35 | }*/ 36 | 37 | // 定义一个用于通信的 channel, 完成go程同步 38 | var channel = make(chan bool) 39 | 40 | func printer(s string) { 41 | for _, ch := range s { 42 | fmt.Printf("%c", ch) // 屏幕（硬件）—— 标准输出（文件）stdout 43 | time.Sleep(300 * time.Millisecond) 44 | } 45 | fmt.Println("") 46 | } 47 | func person1() { 48 | // 读 channel 49 | myBool := <- channel 50 | fmt.Println("person1 读到：", myBool) 51 | printer("hello") // 后 52 | } 53 | func person2() { 54 | printer("world") // 先 55 | // 写 channel 56 | channel <- true 57 | } 58 | func main() { 59 | go person1() 60 | go person2() 61 | 62 | for { // 防止主go程提早结束 63 | ; 64 | } 65 | } 66 | -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/04学习/代码demo/02-使用channel数据通信.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "time" 6 | ) 7 | 8 | /*func newTask() { 9 | defer fmt.Println("子go程打印完毕") 10 | for i:=0; i<2;i++ { 11 | ch <- i 12 | fmt.Println("子go程 i = ", i) 13 | } 14 | } 15 | func main() { 16 | go newTask() 17 | for i:=0; i<2; i++ { 18 | num := <-ch 19 | fmt.Println("主go程读到：", num) 20 | //fmt.Println("主go程读到：", <-ch ) 21 | } 22 | }*/ 23 | 24 | /*var ch = make(chan int) 25 | func main() { 26 | 27 | // 创建匿名子go程 28 | go func() { 29 | for i:=0; i<5;i++ { 30 | fmt.Println("子go程 i = ", i) 31 | } 32 | ch <- 889 33 | }() 34 | 35 | num := <- ch 36 | fmt.Println("num = ", num) 37 | }*/ 38 | 39 | /*func main() { 40 | 41 | ch := make(chan int) 42 | 43 | // 创建匿名子go程 44 | go func() { 45 | fmt.Println("子 go 程 start ....") 46 | for i:=0; i<5;i++ { 47 | ch <- i 48 | fmt.Println("子go程 i = ", i) 49 | } 50 | }() 51 | 52 | time.Sleep(time.Second * 5) // 保证子go程 ，先执行 53 | 54 | for i:=0; i<5; i++ { 55 | num := <-ch 56 | fmt.Println("主go程读到：", num) 57 | } 58 | }*/ 59 | 60 | // 实现主子 go 程交替输出 61 | func main() { 62 | 63 | // 在主、子go程之间进行数据传递。 指定了 读写数据的先后顺序。 子先，主后 64 | ch := make(chan int) 65 | 66 | // 在 主子 go 程使用 stdout，指定先后顺序， 子先，主后 67 | ch2 := make(chan string) 68 | 69 | // 创建匿名子go程 70 | go func() { 71 | fmt.Println("子 go 程 start ....") 72 | for i:=0; i<5;i++ { 73 | ch <- i 74 | fmt.Println("子go程 i = ", i) 75 | ch2 <- "write finish" 76 | } 77 | }() 78 | time.Sleep(time.Second * 1) // 保证子go程 ，先执行 79 | 80 | for i:=0; i<5; i++ { 81 | num := <-ch 82 | <- ch2 // 读到 子go程 发送的 控制 使用stdout 的字符串，之后，在 使用stdout 83 | fmt.Println("主go程读到：", num) 84 | } 85 | } 86 | -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/04学习/代码demo/03-channel使用常见错误.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | func main() { 8 | 9 | cha := make(chan int) 10 | num := <- cha 11 | fmt.Println("读 到 channel 中的数据：", num) 12 | 13 | go func() { // 子 go程 14 | cha <- 456 15 | fmt.Println("写 channel 完成") 16 | 17 | //time.Sleep(time.Second) 18 | }() 19 | } 20 | -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/04学习/代码demo/04-无缓冲channel.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "time" 6 | ) 7 | 8 | func main() { 9 | 10 | // 在主、子go程之间进行数据传递。 指定了 读写数据的先后顺序。 子先，主后 11 | ch := make(chan int, 0) 12 | fmt.Println("len(ch)=", len(ch), "cap(ch)=", cap(ch)) 13 | 14 | // 创建匿名子go程 15 | go func() { 16 | fmt.Println("子 go 程 start ....") 17 | for i:=0; i<5;i++ { 18 | ch <- i 19 | fmt.Println("子go程 i = ", i, "len(ch)=", len(ch), "cap(ch)=", cap(ch)) 20 | time.Sleep(time.Second) 21 | } 22 | }() 23 | 24 | for i:=0; i<5; i++ { 25 | num := <-ch 26 | fmt.Println("主go程读到：", num) 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/04学习/代码demo/05-有缓冲channel.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "time" 6 | ) 7 | 8 | func main() { 9 | 10 | ch := make(chan int, 3) 11 | fmt.Println("len(ch)=", len(ch), "cap(ch)=", cap(ch)) 12 | 13 | // 创建匿名子go程 14 | go func() { 15 | fmt.Println("子 go 程 start ....") 16 | for i:=0; i<7;i++ { 17 | ch <- i 18 | fmt.Println("写---i = ", i, "len(ch)=", len(ch), "cap(ch)=", cap(ch)) 19 | } 20 | }() 21 | 22 | time.Sleep(time.Second * 1) 23 | 24 | for i:=0; i<7; i++ { 25 | num := <-ch 26 | fmt.Println("----读：", num, "len(ch)=", len(ch), "cap(ch)=", cap(ch)) 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/04学习/代码demo/06-关闭channel.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | /*func main() { 6 | ch := make(chan bool) 7 | go func() { 8 | for i:=0; i<3; i++ { 9 | ch <- true 10 | } 11 | close(ch) 12 | //ch <- 789 13 | }() 14 | for { 15 | if num, ok := <-ch; ok == true { 16 | fmt.Println("读到 子 go 程数据：", num) 17 | } else { 18 | num := <-ch 19 | // 说明写端已经关闭了。 20 | fmt.Println("检测到 子go程关闭channel, num:", num) 21 | break 22 | } 23 | } 24 | }*/ 25 | 26 | // 简单判别 channel 关闭方法 27 | func main() { 28 | ch := make(chan int) 29 | go func() { 30 | for i:=0; i<7; i++ { 31 | ch <- i 32 | } 33 | close(ch) 34 | //ch <- 789 35 | }() 36 | /* for { 37 | if num, ok := <-ch; ok == true { 38 | fmt.Println("读到 子 go 程数据：", num) 39 | } else { 40 | // 说明写端已经关闭了。 41 | fmt.Println("检测到 子go程关闭channel, num:", num) 42 | break 43 | } 44 | }*/ 45 | for num := range ch { 46 | fmt.Println("读到 子 go 程数据：", num) 47 | } 48 | fmt.Println("子go程数据读取完毕。channel关闭") 49 | } -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/04学习/代码demo/07-单向channel特性测试.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | ch :=make(chan int) 7 | var send chan <- int // 单向写channel 8 | send = ch 9 | send <- 907 10 | //<- send 11 | 12 | var recv <-chan int = ch // 单向读channel 13 | fmt.Println("recv:", <-recv) 14 | //recv <- 8987 15 | 16 | //var ch2 chan int = send 17 | } 18 | -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/04学习/代码demo/08-单向channel数据通信.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | // 限定当前函数内部，只能做写操作。 6 | func send(out chan<- int) { 7 | out <- 666 8 | fmt.Println("send 666 over") 9 | } 10 | 11 | func recv(in <-chan int) { 12 | num := <-in 13 | fmt.Println("recv num=", num) 14 | } 15 | 16 | func main() { 17 | // 创建一个 双向 channel 18 | ch := make(chan int) 19 | 20 | go send(ch) 21 | go recv(ch) 22 | 23 | for { 24 | ; 25 | } 26 | } -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/04学习/代码demo/09-生产者消费者模型.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func producer(send chan<- int) { 6 | for i:=0; i<10; i++ { 7 | send <- i * i 8 | //fmt.Println("生产者 产生：", i*i) 9 | } 10 | close(send) 11 | } 12 | func consumer(recv <-chan int) { 13 | for { 14 | if num, ok := <-recv; ok { 15 | fmt.Println("消费者 消费：", num) 16 | } else { 17 | break 18 | } 19 | } 20 | /* // 判断 channel 是否关闭。 21 | for num := range recv { 22 | fmt.Println("消费者 消费：", num) 23 | }*/ 24 | } 25 | func main() { 26 | // 创建缓冲区，带缓冲 双向 channel 27 | ch := make(chan int, 5) 28 | go producer(ch) // 子go程 --- 生产者 29 | consumer(ch) // 主 go 程 --- 消费者 30 | } 31 | -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/04学习/代码demo/10-订单模拟.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | type orderInfo struct { 6 | id int 7 | } 8 | // 生产者 9 | func makeOrder(make chan<- orderInfo) { 10 | for i:=0; i<5; i++ { 11 | order := orderInfo{i+1} // 模拟产生订单 12 | make <- order //将订单放入单的缓冲区 13 | } 14 | close(make) 15 | } 16 | // 消费 17 | func dealOrder(deal <-chan orderInfo) { 18 | for order := range deal { 19 | fmt.Println("处理掉订单：", order.id) 20 | } 21 | } 22 | 23 | func main() { 24 | 25 | ch := make(chan orderInfo, 4) // 存放订单的缓冲区 26 | 27 | go makeOrder(ch) 28 | 29 | dealOrder(ch) 30 | } 31 | -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/04学习/代码demo/11-Timer定时器.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "time" 5 | "fmt" 6 | ) 7 | 8 | /*func main() { 9 | // 打印当前时间 10 | fmt.Println("now: ", time.Now()) 11 | 12 | // 创建 Timer 定时器 13 | myTimer := time.NewTimer(time.Second * 2) 14 | 15 | time := <-myTimer.C // 默认读——阻塞，定时时长到达后，系统写入当前时间，解除阻塞 16 | 17 | fmt.Println("定时后:", time) 18 | }*/ 19 | 20 | func main() { 21 | fmt.Println("now: ", time.Now()) 22 | 23 | time := <-time.After(time.Second * 2) 24 | 25 | fmt.Println("定时后:", time) 26 | } -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/04学习/代码demo/12-定时器停止和重置.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "time" 5 | "fmt" 6 | ) 7 | 8 | func main() { 9 | myTimer := time.NewTimer(time.Second * 5) 10 | 11 | go func() { 12 | <-myTimer.C 13 | fmt.Println("定时时间到！") 14 | }() 15 | //myTimer.Stop() 16 | myTimer.Reset(time.Second * 1) 17 | for { 18 | ; 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/04学习/代码demo/13-Ticker定时器.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "time" 6 | ) 7 | 8 | func main() { 9 | fmt.Println("now: ", time.Now()) 10 | myTicker := time.NewTicker(time.Second * 2) 11 | 12 | for { 13 | time := <-myTicker.C 14 | fmt.Println("定时后:", time) 15 | } 16 | } 17 | 18 | /*func main() { 19 | // 打印当前时间 20 | fmt.Println("now: ", time.Now()) 21 | // 创建 Timer 定时器 22 | myTimer := time.NewTimer(time.Second * 2) 23 | for { 24 | time := <-myTimer.C // 默认读——阻塞，定时时长到达后，系统写入当前时间，解除阻塞 25 | fmt.Println("定时后:", time) 26 | } 27 | }*/ 28 | -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/04学习/相关资料及笔记/父子进程交替输出.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/go网络编程深入所有代码例题笔记/04学习/相关资料及笔记/父子进程交替输出.png -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/04学习/相关资料及笔记/生产者消费者模型.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/go网络编程深入所有代码例题笔记/04学习/相关资料及笔记/生产者消费者模型.png -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/04学习/相关资料及笔记/笔记总结.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/go网络编程深入所有代码例题笔记/04学习/相关资料及笔记/笔记总结.txt -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/05学习/代码demo/01-select.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "time" 6 | ) 7 | 8 | func main() { 9 | ch := make(chan int) // 用来进行数据通信 10 | quit := make(chan bool) // 用来判断是否结束go程的channel 11 | 12 | go func() { 13 | for i:=0; i<5; i++ { 14 | ch <- i 15 | time.Sleep(time.Millisecond * 300) 16 | } 17 | close(ch) 18 | fmt.Println("子go程打印完毕") 19 | quit <- true // 通知主go程可以终止 20 | }() 21 | for { 22 | select { 23 | case num := <-ch : 24 | fmt.Println("num = ", num) 25 | case <-quit : 26 | //time.Sleep(time.Second) 27 | fmt.Println("主go程 收到子消息， 结束运行") 28 | //break // 只能跳出当前 的 select 29 | return 30 | //runtime.Goexit() // 退出主 go 程 ———— 不会清理进程地址空间。 31 | //os.Exit(0) 32 | } 33 | fmt.Println("==========================") 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/05学习/代码demo/02-斐波那契数列.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "runtime" 6 | ) 7 | 8 | func fibonacci(ch <-chan int, quit <-chan bool) { 9 | for { 10 | select { 11 | case num := <-ch: // 打印一个 fibonacci 数值 12 | fmt.Print(num, " ") 13 | case <-quit : // 接收到go程结束通知 14 | //return 15 | runtime.Goexit() 16 | } 17 | } 18 | } 19 | func main() { 20 | ch := make(chan int) 21 | quit := make(chan bool) 22 | // 创建一个打印fibonacci数列的 子go程 23 | go fibonacci(ch, quit) 24 | x, y := 1, 1 25 | for i:=0; i<50; i++ { 26 | ch <- x 27 | x, y = y, x+y 28 | } 29 | // 写完 20 个数，通知子go程结束 30 | quit <- false 31 | } 32 | -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/05学习/代码demo/03-select实现超时退出.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "time" 6 | ) 7 | 8 | func main() { 9 | 10 | ch := make(chan int) 11 | quit := make(chan bool) 12 | 13 | go func() { 14 | 15 | for { 16 | select { 17 | case num:=<-ch: 18 | fmt.Println("num = ", num) 19 | case <-time.After(time.Second * 3): 20 | fmt.Println("time out") 21 | quit <- true 22 | //return // Goexit(） 等价 23 | goto ABC // lable:标签名， 改名字任意 24 | } 25 | } 26 | ABC: // 不能超出当前函数。 27 | fmt.Println("----break to lable----") 28 | }() 29 | 30 | for i:=0; i<2; i++ { 31 | ch <- i 32 | time.Sleep(time.Second * 2) 33 | } 34 | 35 | <-quit // 阻塞 36 | fmt.Println("主 go 程 执行结束。") 37 | } 38 | -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/05学习/代码demo/04-死锁.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // 死锁1 4 | /*func main() { 5 | ch := make(chan int) 6 | ch <- 88 7 | num := <-ch 8 | fmt.Println("num = ", num) 9 | }*/ 10 | 11 | // 死锁2 12 | /*func main() { 13 | ch := make(chan int) 14 | go func() { 15 | num := <-ch // 读 16 | fmt.Println("num = ", num) 17 | }() 18 | ch <- 99 // 写 —— 阻塞 19 | for { 20 | ; 21 | } 22 | }*/ 23 | 24 | // 死锁3 25 | func main() { 26 | ch1 := make(chan int) 27 | ch2 := make(chan int) 28 | go func() { 29 | for { 30 | select { 31 | case <-ch1: 32 | ch2 <- 777 33 | } 34 | } 35 | }() 36 | for { 37 | select { 38 | case <-ch2 : 39 | ch1 <- 999 40 | } 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/05学习/代码demo/05-互斥锁.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "time" 6 | "sync" 7 | ) 8 | //var ch = make(chan int) 9 | var mutex sync.Mutex // 创建一个互斥锁（互斥量） 10 | 11 | func printer(s string) { 12 | mutex.Lock() // 访问共享数据前 加锁。 13 | defer mutex.Unlock() // 访问共享数据结束，解锁。 14 | for _, char := range s { 15 | fmt.Printf("%c", char) // stdout 16 | time.Sleep(time.Millisecond * 300) 17 | } 18 | fmt.Println("") 19 | } 20 | 21 | func person1() { 22 | printer("hello") 23 | } 24 | 25 | func person2() { 26 | printer("world") 27 | } 28 | 29 | func main() { 30 | go person1() 31 | go person2() 32 | 33 | for { 34 | ; 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/05学习/代码demo/06-读写锁.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "runtime" 5 | "math/rand" 6 | "time" 7 | "fmt" 8 | "sync" 9 | ) 10 | // 使用读写锁 11 | var rwMutex sync.RWMutex 12 | 13 | var counter int = 0 // 模拟公共区 14 | 15 | func readGo(idx int) { // 读go程 16 | for { // 一个go程可以读 无限 次。 17 | rwMutex.RLock() // 读模式加 读写锁 18 | num := counter // 从公共区中，读取数据 19 | fmt.Printf("%dth 读 go程，读到：%d\n", idx, num) 20 | rwMutex.RUnlock() // 解锁 读写锁 21 | 22 | time.Sleep(time.Millisecond * 500) // 放大实验现象 23 | } 24 | } 25 | 26 | func writeGo(idx int) { 27 | for { // 一个go程可以写 无限 次。 28 | // 生产一个随机数 29 | num := rand.Intn(500) 30 | rwMutex.Lock() // 写模式加 读写锁 31 | counter = num // 写数据到 公共区中 32 | fmt.Printf("-----%dth 写 go程，写入：%d\n", idx, counter) 33 | rwMutex.Unlock() // 解锁 读写锁 34 | 35 | time.Sleep(time.Millisecond * 200) // 放大实验现象 36 | } 37 | } 38 | 39 | func main() { 40 | // 播种随机数种子。 41 | rand.Seed(time.Now().UnixNano()) 42 | 43 | for i:=0; i<5; i++ { // 同时创建 N 个 读go程 44 | go readGo(i+1) 45 | } 46 | for i:=0; i<5; i++ { // 同时创建 N 个 写go程 47 | go writeGo(i+1) 48 | } 49 | for { // 防止 主 go 程 退出 50 | runtime.GC() 51 | } 52 | } 53 | -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/05学习/代码demo/07-读写锁和channel交叉使用错误.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "runtime" 5 | "math/rand" 6 | "time" 7 | "fmt" 8 | "sync" 9 | ) 10 | // 使用读写锁 11 | var rwMutex2 sync.RWMutex 12 | 13 | func readGo2(idx int, in <-chan int) { // 读go程 14 | for { 15 | time.Sleep(time.Millisecond * 500) // 放大实验现象// 一个go程可以读 无限 次。 16 | rwMutex2.RLock() // 读模式加 读写锁 17 | num := <-in // 从 公共的 channel 中获取数据 18 | fmt.Printf("%dth 读 go程，读到：%d\n", idx, num) 19 | rwMutex2.RUnlock() // 解锁 读写锁 20 | } 21 | } 22 | 23 | func writeGo2(idx int, out chan<- int) { 24 | for { // 一个go程可以写 无限 次。 25 | // 生产一个随机数 26 | num := rand.Intn(500) 27 | rwMutex2.Lock() // 写模式加 读写锁 28 | out <- num 29 | fmt.Printf("-----%dth 写 go程，写入：%d\n", idx, num) 30 | rwMutex2.Unlock() // 解锁 读写锁 31 | 32 | //time.Sleep(time.Millisecond * 200) // 放大实验现象 33 | } 34 | } 35 | 36 | func main() { 37 | // 播种随机数种子。 38 | rand.Seed(time.Now().UnixNano()) 39 | 40 | // 创建 模拟公共区的 channel 41 | ch := make(chan int, 5) 42 | 43 | for i:=0; i<5; i++ { // 同时创建 N 个 读go程 44 | go readGo2(i+1, ch) 45 | } 46 | for i:=0; i<5; i++ { // 同时创建 N 个 写go程 47 | go writeGo2(i+1, ch) 48 | } 49 | for { // 防止 主 go 程 退出 50 | runtime.GC() 51 | } 52 | } 53 | -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/05学习/代码demo/08-生产者消费者模型1.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "math/rand" 5 | "time" 6 | "fmt" 7 | "runtime" 8 | ) 9 | 10 | func producer(out chan<- int, idx int) { 11 | for { 12 | num := rand.Intn(500) 13 | out <- num 14 | fmt.Printf("-----%dth 生产者，生产：%d\n", idx, num) 15 | time.Sleep(time.Millisecond * 500) 16 | } 17 | } 18 | 19 | func consumer(in <-chan int, idx int) { 20 | for { 21 | num := <- in 22 | fmt.Printf("%dth 消费者，消费：%d\n", idx, num) 23 | time.Sleep(time.Millisecond * 200) 24 | } 25 | } 26 | 27 | func main() { 28 | rand.Seed(time.Now().UnixNano()) 29 | ch := make(chan int, 5) 30 | 31 | for i := 0; i < 5; i++ { 32 | go producer(ch, i+1) 33 | } 34 | 35 | for i := 0; i < 5; i++ { 36 | go consumer(ch, i+1) 37 | } 38 | 39 | for { 40 | runtime.GC() 41 | } 42 | } 43 | 44 | 45 | -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/05学习/代码demo/09-生产者消费者模型2.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "math/rand" 5 | "time" 6 | "fmt" 7 | "runtime" 8 | "sync" 9 | ) 10 | 11 | // 创建条件变量 12 | var cond sync.Cond 13 | 14 | func producer2(out chan<- int, idx int) { 15 | for { 16 | // 加条件变量中的锁 17 | cond.L.Lock() 18 | for len(out) == 5 { 19 | //if len(out) == 5 { 20 | cond.Wait() 21 | } 22 | // 访问共享数据区 23 | num := rand.Intn(500) 24 | out <- num 25 | fmt.Printf("-----%dth 生产者，生产：%d\n", idx, num) 26 | // 解锁 27 | cond.L.Unlock() 28 | // 唤醒阻塞在条件变量上的对端 —— 消费者 29 | cond.Signal() 30 | //time.Sleep(time.Millisecond * 500) 31 | } 32 | } 33 | func consumer2(in <-chan int, idx int) { 34 | for { 35 | cond.L.Lock() 36 | //if len(in) == 0 { 37 | for len(in) == 0 { 38 | cond.Wait() 39 | } 40 | num := <- in 41 | fmt.Printf("%dth 消费者，消费：%d\n", idx, num) 42 | cond.L.Unlock() 43 | cond.Signal() 44 | 45 | //time.Sleep(time.Millisecond * 200) 46 | } 47 | } 48 | 49 | func main() { 50 | rand.Seed(time.Now().UnixNano()) 51 | ch := make(chan int, 5) 52 | 53 | // 初始化 cond 54 | cond.L = new(sync.Mutex) 55 | 56 | for i := 0; i < 5; i++ { 57 | go producer2(ch, i+1) 58 | } 59 | 60 | for i := 0; i < 5; i++ { 61 | go consumer2(ch, i+1) 62 | } 63 | 64 | for { 65 | runtime.GC() 66 | } 67 | } 68 | 69 | 70 | -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/05学习/相关资料及笔记/条件变量.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/go网络编程深入所有代码例题笔记/05学习/相关资料及笔记/条件变量.png -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/05学习/相关资料及笔记/笔记总结.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/go网络编程深入所有代码例题笔记/05学习/相关资料及笔记/笔记总结.txt -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/05学习/相关资料及笔记/读写锁错误.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/go网络编程深入所有代码例题笔记/05学习/相关资料及笔记/读写锁错误.png -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/06学习/代码demo/01-TCP-CS模型服务器.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "net" 5 | "fmt" 6 | ) 7 | 8 | func main() { 9 | // 创建用于监听的 socket 10 | listener, err := net.Listen("tcp", "127.0.0.1:7020") 11 | if err != nil { 12 | fmt.Println("Listen err:", err) 13 | return 14 | } 15 | fmt.Println("监听套接字，创建成功。。。") 16 | // 服务器结束前关闭 listener 17 | defer listener.Close() 18 | 19 | // 创建用户数据通信的socket 20 | conn, err := listener.Accept() // 阻塞等待... 21 | if err != nil { 22 | fmt.Println("Accept err:", err) 23 | return 24 | } 25 | defer conn.Close() 26 | 27 | fmt.Println("通信套接字，创建成功。。。") 28 | 29 | // 创建一个用保存数据的缓冲区 30 | buf := make([]byte, 4096) 31 | 32 | for { 33 | // 获取客户端发送的数据内容 34 | n, err := conn.Read(buf) 35 | if err != nil { 36 | fmt.Println("Read err:", err) 37 | return 38 | } 39 | // 处理 客户端 的数据 40 | fmt.Println("读到客户端发送：", string(buf[:n])) 41 | 42 | // 回写数据给客户端 43 | _, err = conn.Write([]byte("This is Server\n")) 44 | if err != nil { 45 | fmt.Println("Write err:", err) 46 | return 47 | } 48 | } 49 | } -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/06学习/代码demo/02-TCP-CS客户端.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "net" 5 | "fmt" 6 | "time" 7 | ) 8 | 9 | func main() { 10 | // 创建用于通信socket 11 | conn, err := net.Dial("tcp", "127.0.0.1:7020") // IP地址/prot端口号--服务器的 12 | if err != nil { 13 | fmt.Println("Dial err:", err) 14 | return 15 | } 16 | // 关闭连接 17 | defer conn.Close() 18 | 19 | for { 20 | // 发送数据 write 21 | _, err = conn.Write([]byte("hello socket")) 22 | if err != nil { 23 | fmt.Println("Write err:", err) 24 | return 25 | } 26 | buf := make([]byte, 4096) 27 | // 接收数据 read 28 | n, err := conn.Read(buf) 29 | if err != nil { 30 | fmt.Println("Read err:", err) 31 | return 32 | } 33 | fmt.Println("读到 服务器 回发：", string(buf[:n])) 34 | 35 | time.Sleep(time.Second) 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/06学习/代码demo/03-TCP-CS并发服务器.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "net" 5 | "fmt" 6 | "strings" 7 | ) 8 | 9 | // 处理客户端数据通信 10 | func HandlerConnect(conn net.Conn) { 11 | defer conn.Close() 12 | 13 | // 获取当前客户端的 Addr 14 | cltAddr := conn.RemoteAddr() 15 | fmt.Printf("%v客户端连接成功.\n", cltAddr) 16 | 17 | buf := make([]byte, 4096) 18 | for { // 在一个客户端连接上，进行循环多次通信 19 | // 读 20 | n, err := conn.Read(buf) 21 | fmt.Println(buf[:n]) 22 | if n == 0 { 23 | fmt.Printf("服务器检测到 %v 客户端关闭", cltAddr) 24 | break 25 | } 26 | if err != nil { 27 | fmt.Println("Read err:", err) 28 | return 29 | } 30 | if string(buf[:n]) == "exit\n" || string(buf[:n]) == "exit\r\n" { // string(buf[:n-1]) == "exit" 31 | fmt.Printf("服务器发现 %v 客户端 exit ", cltAddr) 32 | break 33 | } 34 | 35 | fmt.Printf("服务器读到 %v 客户端发送数据：%s", cltAddr, string(buf[:n])) 36 | // 处理数据: 小 -- 大 37 | UpperWord := strings.ToUpper(string(buf[:n])) 38 | // 写 39 | conn.Write([]byte(UpperWord)) 40 | } 41 | } 42 | 43 | func main() { 44 | listener, err := net.Listen("tcp", "127.0.0.1:8000") 45 | if err != nil { 46 | fmt.Println("Listen err:", err) 47 | return 48 | } 49 | defer listener.Close() 50 | 51 | for { // 循环建立连接 52 | conn, err := listener.Accept() // 阻塞 53 | if err != nil { 54 | fmt.Println("Accept err:", err) 55 | return 56 | } 57 | // 创建一个新go程，用来与客户端进行数据通信。 并且将 conn 传入。 58 | go HandlerConnect(conn) 59 | } 60 | } 61 | -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/06学习/代码demo/04-TCP-CS并发客户端.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "net" 5 | "fmt" 6 | "os" 7 | ) 8 | 9 | func main() { 10 | conn, err := net.Dial("tcp", "127.0.0.1:8000") 11 | if err != nil { 12 | fmt.Println("Dial err:", err) 13 | return 14 | } 15 | defer conn.Close() 16 | 17 | // 读取用户的键盘输入。 18 | go func() { 19 | buf := make([]byte, 4096) 20 | for { 21 | // 获取键盘输入。 fmt.Scan --》 结束标记 \n 和 空格 22 | n, err := os.Stdin.Read(buf) // buf[:n] 23 | if err != nil { 24 | fmt.Println("os.Stdin.Read err:", err) 25 | return 26 | } 27 | // 直接将读到键盘输入数据，写到 socket 中，发送给服务器 28 | conn.Write(buf[:n]) 29 | } 30 | }() 31 | 32 | // 在 主go程中， 获取服务器回发数据。 33 | buf2 := make([]byte, 4096) 34 | for { 35 | // 借助 socket 从服务器读取 数据。 36 | n, err := conn.Read(buf2) 37 | if n == 0 { 38 | fmt.Println("客户端检查到服务器，关闭连接， 本端也退出") 39 | return 40 | } 41 | if err != nil { 42 | fmt.Println("os.Stdin.Read err:", err) 43 | return 44 | } 45 | fmt.Println("客户端读到：", string(buf2[:n])) 46 | } 47 | } 48 | -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/06学习/相关资料及笔记/netcat-win32-1.12.zip: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/go网络编程深入所有代码例题笔记/06学习/相关资料及笔记/netcat-win32-1.12.zip -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/06学习/相关资料及笔记/socket.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/go网络编程深入所有代码例题笔记/06学习/相关资料及笔记/socket.png -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/06学习/相关资料及笔记/协议.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/go网络编程深入所有代码例题笔记/06学习/相关资料及笔记/协议.png -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/06学习/相关资料及笔记/并发服务器.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/go网络编程深入所有代码例题笔记/06学习/相关资料及笔记/并发服务器.png -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/06学习/相关资料及笔记/数据通信过程.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/go网络编程深入所有代码例题笔记/06学习/相关资料及笔记/数据通信过程.png -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/06学习/相关资料及笔记/笔记总结.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/go网络编程深入所有代码例题笔记/06学习/相关资料及笔记/笔记总结.txt -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/06学习/相关资料及笔记/网络协议分层.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/go网络编程深入所有代码例题笔记/06学习/相关资料及笔记/网络协议分层.png -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/06学习/相关资料及笔记/网络通信其他知识.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/go网络编程深入所有代码例题笔记/06学习/相关资料及笔记/网络通信其他知识.png -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/07学习/代码demo/01-UDP服务器.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "net" 5 | "fmt" 6 | ) 7 | 8 | func main() { 9 | // 创建 UDPAddr 类型的 UDP 地址结构（IP + port）, 为了给ListenUDP传参 10 | udpAddr, err := net.ResolveUDPAddr("udp", "127.0.0.1:8009") 11 | if err != nil { 12 | fmt.Println("ResolveUDPAddr err:", err) 13 | return 14 | } 15 | // 创建用于 数据通信的 socket -- conn 16 | conn, err := net.ListenUDP("udp", udpAddr) 17 | if err != nil { 18 | fmt.Println("ListenUDP err:", err) 19 | return 20 | } 21 | defer conn.Close() 22 | 23 | buf := make([]byte, 4096) 24 | 25 | // 读取客户端数据 26 | n, cUDPAddr, err := conn.ReadFromUDP(buf) 27 | if err != nil { 28 | fmt.Println("ReadFromUDP err:", err) 29 | return 30 | } 31 | fmt.Printf("读到客户端 %v 发送数据:%s\n", cUDPAddr, string(buf[:n])) 32 | 33 | // 写数据给客户端 34 | conn.WriteToUDP([]byte("This is UDP server"), cUDPAddr) 35 | } 36 | -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/07学习/代码demo/02-UDP并发服务器.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "net" 5 | "fmt" 6 | ) 7 | 8 | func main() { 9 | 10 | srvAddr, err := net.ResolveUDPAddr("udp", "127.0.0.1:8000") 11 | if err != nil { 12 | fmt.Println("ResolveUDPAddr err:", err) 13 | return 14 | } 15 | conn, err := net.ListenUDP("udp", srvAddr) 16 | if err != nil { 17 | fmt.Println("ListenUDP err:", err) 18 | return 19 | } 20 | defer conn.Close() 21 | 22 | for { 23 | buf := make([]byte, 4096) 24 | n, cltAddr, err := conn.ReadFromUDP(buf) 25 | if err != nil { 26 | fmt.Println("ReadFromUDP err:", err) 27 | return 28 | } 29 | go func() { 30 | fmt.Printf("客户端%v,发送数据：%s\n", cltAddr, string(buf[:n])) 31 | conn.WriteToUDP(buf[:n], cltAddr) 32 | }() 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/07学习/代码demo/03-获取文件属性和命令行参数.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "os" 5 | "fmt" 6 | ) 7 | 8 | /*func main() { 9 | // 提取命令行参数 10 | list := os.Args 11 | 12 | for i:=0; i地址（指针） 11 | func addOne(x int, y bool) int { 12 | if y == true { 13 | x = x+1 14 | } 15 | return x 16 | } 17 | func subTen(x int, y bool) int { 18 | if y == true { 19 | x -= 10 20 | } 21 | return x 22 | } 23 | func useCallback(x int, y bool, p FuncP) int { 24 | 25 | return p(x, y) 26 | } 27 | func main() { 28 | var p FuncP // 空指针 29 | p = addOne 30 | fmt.Printf("type:%T, size:%d\n", p, unsafe.Sizeof(p)) 31 | 32 | fmt.Println(useCallback(5, true, p)) 33 | 34 | fmt.Println(useCallback(5, true, subTen)) 35 | 36 | //addOne(60, false) 普通函数调用方法。 37 | } 38 | -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/09学习/代码demo/03-获取应答包-服务器.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "net/http" 4 | 5 | // 借助go 封装好的 访问http的标准库，创建 服务器。 6 | 7 | func handler(w http.ResponseWriter, r *http.Request) { 8 | // w: 表示 写回给客户端（浏览器）的数据信息 9 | // r：表示从 浏览器读到的数据信息 10 | w.Write([]byte("hello http 123")) 11 | } 12 | 13 | func main() { 14 | // 1. 注册处理函数（回调函数） 15 | http.HandleFunc("/itcast", handler) 16 | 17 | // 2. 绑定服务器监听地址 18 | http.ListenAndServe("127.0.0.1:8007", nil) 19 | } 20 | -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/09学习/代码demo/04-获取应答报文-客户端（模拟浏览器）.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "net" 5 | "fmt" 6 | ) 7 | 8 | func main() { 9 | conn, err := net.Dial("tcp", "127.0.0.1: 8007") 10 | if err != nil { 11 | fmt.Println("Dial err:", err) 12 | return 13 | } 14 | defer conn.Close() 15 | 16 | // 模拟浏览器，组织 http 请求报文， 写给web服务器 17 | //requestHttpHeadr := "GET /hello HTTP/1.1\r\nHost:127.0.0.1:8007\r\n\r\n" 18 | requestHttpHeadr := "GET /hello http/1.1\r\nHost:127.0.0.1:8007\r\n\r\n" 19 | conn.Write([]byte(requestHttpHeadr)) 20 | 21 | // 读取 web服务器回发的 http应答报文 22 | buf := make([]byte, 4096) 23 | n, err := conn.Read(buf) 24 | if err != nil { 25 | fmt.Println("Read err:", err) 26 | return 27 | } 28 | fmt.Printf("||\n%s||\n", string(buf[:n])) 29 | } 30 | -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/09学习/代码demo/05-http服务器.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "net/http" 5 | "fmt" 6 | ) 7 | 8 | // 当浏览器访问服务器时，该函数自动被调用 9 | func handlerSRV(w http.ResponseWriter, r *http.Request) { 10 | w.Write([]byte("hello http")) 11 | 12 | fmt.Println("Method:", r.Method) 13 | fmt.Println("RemoteAddr:", r.RemoteAddr) 14 | fmt.Println("Proto:", r.Proto) 15 | fmt.Println("Header:", r.Header) 16 | fmt.Println("URL:", r.URL) 17 | fmt.Println("Body:", r.Body) 18 | } 19 | 20 | func main() { 21 | // 1. 注册处理函数 22 | http.HandleFunc("/", handlerSRV) 23 | 24 | // 2. 绑定服务器地址结构 25 | http.ListenAndServe("127.0.0.1:8000", nil) 26 | } 27 | -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/09学习/代码demo/06-练习题-WEB服务器.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "net/http" 5 | "os" 6 | "fmt" 7 | ) 8 | 9 | func OpenAndSendFile(fileName string, w http.ResponseWriter) { 10 | // 只读方式打开文件。 11 | path := "C:/itcast/test" // 等价于："C:\\itcast\\test" 12 | f, err := os.Open(path+fileName) 13 | if err != nil { 14 | fmt.Println("Open err:", err) 15 | //w.Write([]byte("no such file or directroy!")) 16 | w.Write([]byte("404 Not Found" + 17 | "

404 Not Found

NO SUCH FILE OR DIR IS HERE!!!
" + 18 | "")) 19 | return 20 | } 21 | defer f.Close() 22 | buf := make([]byte, 4096) 23 | for { 24 | n, _ := f.Read(buf) 25 | if n == 0 { 26 | fmt.Println("读取文件完毕\n") 27 | break 28 | } 29 | w.Write(buf[:n]) // 借助 ResponseWriter 将读到的数据内容，写回给 浏览器 30 | } 31 | } 32 | func handConn( w http.ResponseWriter, r *http.Request) { 33 | // 获取用户请求的文件名 34 | fileName := r.URL.String() 35 | // 创建函数尝试读取文件内容，回发给浏览器 36 | OpenAndSendFile(fileName, w) 37 | } 38 | 39 | func main() { 40 | http.HandleFunc("/", handConn) 41 | http.ListenAndServe("127.0.0.1:8006", nil) 42 | } 43 | -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/09学习/代码demo/07-http客户端.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "net/http" 5 | "fmt" 6 | "io" 7 | ) 8 | 9 | /*func main() { 10 | // 获取服务器数据， 11 | resp, err := http.Get("http://127.0.0.1:8006/lf.png") 12 | if err != nil { 13 | fmt.Println("Get err:", err) 14 | return 15 | } 16 | defer resp.Body.Close() // resp.close ---- bool 17 | 18 | fmt.Println("Status:", resp.Status) 19 | fmt.Println("StatusCode:", resp.StatusCode) 20 | fmt.Println("Header:", resp.Header) 21 | fmt.Println("Proto:", resp.Proto) 22 | fmt.Println("Body:", resp.Body) 23 | 24 | }*/ 25 | 26 | func main() { 27 | // 获取服务器数据， 28 | resp, err := http.Get("http://127.0.0.1:8006/lf.txt") 29 | //resp, err := http.Get("https://www.sina.com.cn/") 30 | //resp, err := http.Get("https://www.baidu.com/") 31 | //resp, err := http.Get("http://www.itcast.cn/") 32 | if err != nil { 33 | fmt.Println("Get err:", err) 34 | return 35 | } 36 | defer resp.Body.Close() // resp.close ---- bool 37 | 38 | buf := make([]byte, 4096) 39 | 40 | var result string 41 | 42 | //循环从 Body 中 读取数据内容。 43 | for { 44 | n, err := resp.Body.Read(buf) 45 | if n == 0 { 46 | break 47 | } 48 | if err != nil && err == io.EOF { 49 | fmt.Println("err:", err) 50 | } 51 | result += string(buf[:n]) 52 | } 53 | fmt.Println("resutl:", result) 54 | } -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/09学习/相关资料及笔记/http协议格式.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/go网络编程深入所有代码例题笔记/09学习/相关资料及笔记/http协议格式.jpg -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/09学习/相关资料及笔记/笔记总结.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/go网络编程深入所有代码例题笔记/09学习/相关资料及笔记/笔记总结.txt -------------------------------------------------------------------------------- /go网络编程深入所有代码例题笔记/README.md: -------------------------------------------------------------------------------- 1 | # GoAndBlockChainStudy 2 | 这里是go语言深入学习，包括网络编程，go并发编程，channel，锁的机制，通信。。。。 3 | -------------------------------------------------------------------------------- /区块链学习/README.md: -------------------------------------------------------------------------------- 1 | # 区块链学习 2 | 关于区块链的学习以及讲解，原码分析都在wumansgy.github.io博客上面可以查看到，也在持续不断更新当中，正在同步 -------------------------------------------------------------------------------- /区块链学习/一条简单区块链的实现/20.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/区块链学习/一条简单区块链的实现/20.jpg -------------------------------------------------------------------------------- /区块链学习/区块链中的双花问题/1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/区块链学习/区块链中的双花问题/1.png -------------------------------------------------------------------------------- /区块链学习/区块链中的双花问题/2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/区块链学习/区块链中的双花问题/2.png -------------------------------------------------------------------------------- /区块链学习/区块链中的双花问题/3.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/区块链学习/区块链中的双花问题/3.png -------------------------------------------------------------------------------- /区块链学习/区块链以太坊相关资料.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: 区块链以太坊相关资料 3 | copyright: true 4 | date: 2018-09-04 20:44:32 5 | tags: 6 | - 区块链 7 | - 以太坊 8 | categories: 区块链 9 | --- 10 | 11 | 收集整理了一些免费区块链、以太坊技术开发相关的文件，有需要的可以下载，文件链接： 12 | 13 | 1. web3.js API官方文档中文版： 14 | 2. 以太坊官方文档中文版 ： 15 | 3. 以太坊白皮书中文版 ： 16 | 4. Solidity的官方文档中文版 ： 17 | 5. Truffle的官方文档中文版 ： 18 | 6. C#区块链编程指南 ： 19 | 7. 区块链技术指南： ： 20 | 8. 精通比特币中文版： ： 21 | 9. Node.js区块链开发 ： 22 | 10. geth使用指南文档中文版 ： 23 | 11. 以太坊DApp开发环境搭建-Ubuntu : 24 | 12. 以太坊DApp开发环境搭建-windows ： 25 | 13. 以太坊DApp开发私链搭建-Ubuntu : 26 | 14. 以太坊DApp开发私链搭建-windows ： 27 | 15. 以太坊ganache CLI命令行参数详解： 28 | 16. 使用truflle和infura部署以太坊合约： 29 | 17. IPFS安装部署与开发环境搭建-windows： 30 | 31 | EOS.IO教程： 32 | 33 | 1. EOS智能合约与DApp开发入门： 34 | 35 | 以太坊教程： 36 | 37 | 1. 以太坊DApp开发实战入门： 38 | 2. 以太坊node.js电商实战： 39 | 3. C#开发以太坊区块链的教程： 40 | 4. java开发以太坊区块链的教程，web3j开发详解： 41 | 5. PHP开发以太坊区块链的教程： 42 | 6. python用web3.py开发以太坊区块链应用的教程： -------------------------------------------------------------------------------- /区块链学习/区块链简单实现1/1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/区块链学习/区块链简单实现1/1.png -------------------------------------------------------------------------------- /密码学学习/README.md: -------------------------------------------------------------------------------- 1 | # 密码学学习 2 | 关于密码学的学习以及讲解都在wumansgy.github.io博客上面可以查看到，也在持续不断更新当中，正在同步 -------------------------------------------------------------------------------- /相关书籍/Go 学习笔记 第四版.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/相关书籍/Go 学习笔记 第四版.pdf -------------------------------------------------------------------------------- /相关书籍/Go语言圣经.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/相关书籍/Go语言圣经.pdf -------------------------------------------------------------------------------- /相关书籍/Go语言实战 .pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/相关书籍/Go语言实战 .pdf -------------------------------------------------------------------------------- /相关书籍/Go语言编程.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/相关书籍/Go语言编程.pdf -------------------------------------------------------------------------------- /相关书籍/HTTP协议中文版.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/相关书籍/HTTP协议中文版.pdf -------------------------------------------------------------------------------- /相关书籍/图说区块链.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/相关书籍/图说区块链.pdf -------------------------------------------------------------------------------- /相关书籍/软技能：代码之外的生存指南.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/相关书籍/软技能：代码之外的生存指南.pdf -------------------------------------------------------------------------------- /知识体系图.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/wangguanfu/go-/9be8f5978045e966e1cad4cab946f00d9a398f3e/知识体系图.png --------------------------------------------------------------------------------