一、Golang各个系统的环境安装
1.在linux中
cd /opt/ //切换到opt目录下
wget https://dl.google.com/go/go1.11.4.linux-amd64.tar.gz //下载64位go源码包
uname -m //查看linux多少位
tar -zxvf go.1.11.4.linux-amd64.tar.gz //解压源码包
mkdir -p /opt/gocode/{src,bin,pkg} //创建/opt/gocode/{src,bin,pkg}的三个文件夹，go的代码必须放在gopath中
vim /etc/profile //在这个文件后面添加环境变量
export GOROOT=/opt/go //Golang源代码目录，安装目录
export GOPATH=/opt/gocode //Golang项目代码目录
export PATH=$GORPPT/bin:$PATH //Linux环境变量
export GOBIN=$GOPATH/bin //go install后生成的可执行命令存放路径
source /etc/profile //读取环境变量
which go //查看go环境变量路径
go env //查看go环境信息
go version //查看go版本，确定安装成功，显示go version go1.11.4 /linux/amd64
2.在mac中
https://golang.org/dl //官方下载地址
https://dl.google.com/go/go1.11.4.darwin-amd64.pkg //下载地址
安装后配置GOPATH和GOBIN
go env //查看环境变量‘
3.在windows中
https://golang.org/dl //官方下载地址
配置环境变量
二、Golang各个系统的操作
前提：先在dos中切换到改文件的目录中，然后执行以下命令
1.在windows平台编译到linux和mac中
set cgo_enabled = 0 //禁用CGO
set goos = Linux/darwin //目标平台是Linux/mac
set goarch = amd64 //目标处理器架构是amd64
go build //生成.exe文件，copy到linux或mac上就可以执行
2.在Linux在平台编译到windows和mac中
set cgo_enabled = 0 //禁用CGO
set goos =windows/darwin //目标平台是windows/mac
set goarch = amd64 //目标处理器架构是amd64
go build //生成.exe文件，copy到linux或mac上就可以执行
3.在mac平台编译到linux和windows中
set cgo_enabled = 0 //禁用CGO
set goos = Linux/windows //目标平台是Linux/windows
set goarch = amd64 //目标处理器架构是amd64
go build //生成.exe文件，copy到linux或mac上就可以执行
三、Go基础命令
go install：把可执行文件加入到bin文件夹下，bin在环境变量中则可直接在cmd中执行
go build：将go程序变成.exe可执行文件 //go build 路径.go
go env：显示go相关的环境变量
go fmt：格式化源代码，把其中书写不规范的代码自动缩进 //go fmt 路径和包
go get：可以根据要求和实际情况从互联网上下载或更新指定的代码包及其依赖包，并对它们进行编译和安装。
go run：命令可以编译并运行命令源码文件。
go clean：命令会删除掉执行其它命令时产生的一些文件和目录。
go doc：命令可以打印附于Go语言程序实体上的文档。我们可以通过把程序实体的标识符作为该命令的参数来达到查看其文档的目的。
go test：命令用于对Go语言编写的程序进行测试(对_test文件直接做测试)。
go list：命令的作用是列出指定的代码包的信息。
go fix：会把指定代码包的所有Go语言源码文件中的旧版本代码修正为新版本的代码。
go vet：是一个用于检查Go语言源码中静态错误的简单工具。
go tool pprof：命令来交互式的访问概要文件的内容。
四、Golang项目结构
1.bin
定义：存放编译后的二进制文件
2.pkg
定义：存放编译后的库文件
3.src
3.1 个人开发
项目一：模块一/模块二
项目二：模块一/模块二
3.2 公司提交
公司代码仓库域名——公司内部模块结构——项目一：模块一/模块二
3.3 目前
网站域名——程序猿——项目一：模块一/模块二
五、Golang特性
1.编程语言类型
静态语言：强类型语言 定义变量必须指明数据类型，存储对应类型的数据 如：java，go，c
动态语言：弱类型语言 定义变量复制过程决定变量类型 如js，python
2.Go程序执行流程
.go源码文件 ——> go build ——> 执行可执行文件(.exe或linux二进制命令) ——> 运行结果 //对源代码编译成二进制后执行
.go代码文件 ——> go run代码文件 ——> 结果 //对源代码直接运行
区别：go build编译生成的二进制程序可以直接放在同类系统直接运行，无须go开发环境，go run不可以
go build生成读文件稍大，依赖的库文件打包在可执行文件中
3.Go注意事项
Go代码都是以.go后缀 执行入口函数是main()函数 严格区分大小写 结尾不需要分号
按行编译，尽量一行一条语句 简洁性是代码中不得含有未使用的变量以及未使用的包 通过大括号控制代码
4.Go语言的转义
一个制表符，代表tab
换行符
\ 转义代表
" 转义代表"
一个回车从当前行的最前面开始输出，会覆盖以前的内容，常配合 换行使用
5.Go语言注释
// 行注释
/* */ 块注释 //块注释中不得嵌套块注释
/* 本段被注释
本段被注释*/
6.Go与包
定义：开发时需要在不同文件中嗲用其他文件的函数，go中每一个文件都属于一个包，通过package管理，是最小粒度单位，以包的形式管理文件和项目目录结构，包与包之间命名不能重复，编译可执行文件必须包含package main 入口函数为main()
作用：区分同名的函数、变量等标识符，管理项目程序文件，控制函数、变量访问作用域，包中的变量以首字母大写可以被导出，首字符小写不行，不得导入未使用的包。
导入：使用import关键字导入 import "相对目录/包主文件名" 相对目录食指<workspace>/pkg/<os_arch>开始的子目录，如import "fmt"，
import "fmt" 最常用导入包
import "./test/" 导入当前目录的包(相对路径)
import "gostudy/model" 加载$gopath/src/gostudy/model模块(绝对路径)
import f "fmt" 导入fmt，起别名为f，可以通过f.方式调用函数
import . "fmt" 将fmt启用别名“.”，可以直接使用齐内容
import _"fmt" 表示不使用该包，而是使用该包的init函数，而且不使用该包的其他函数
使用：package 包名 //声明包
import “包的路径” //引入包
生成可执行文件：go build -o bin/src_test.exe test/package_example/main //将main中的go文件生成一个可执行文件到bin下
//调用包goroute.go
package main
import "fmt"
func test_goroute(a int) {
fmt.Println(a)
}
//main.go
package main
import "time"
func main(){
for i:=0;i<100;i++{
go test_goroute(i)
}
time.Sleep(time.Second)
}
//定义包 src/test/package_example/calc.add.go
package calc
func Add(a int,b int) int{
return a+b
}
//定义包 src/test/package_example/calc.sub.go
package calc
func Sub(a int,b int) int{
return a-b
}
//使用包 src/test/package_example/main/main..go
package main
import (
"test/package_example/calc" //导入的包的路径为src下的路径为准
"fmt"
)
func main(){
sum := calc.Add(100,200)
sub := calc.Sub(100,200)
fmt.Printf("sum=%d,sub=%d",sum,sub)
}
7.Go格式化fmt包
7.1格式化定义：golang的fmt包实现了格式化I/O函数，类似于C的printf和scanf
普通占位符：
占位符 说明 举例 输出
%v 相应值的默认格式。 Printf("%v", people) {zhangsan}
%+v 打印结构体时，会添加字段名 Printf("%+v", people) {Name:zhangsan}
%#v 相应值的Go语法表示 Printf("#v", people) main.Human{Name:"zhangsan"}
%T 相应值的类型的Go语法表示 Printf("%T", people) main.Human %% 字面上的百分号，并非值的占位符 Printf("%%")
布尔占位符：
占位符 说明 举例 输出
%t true或false Printf("%t",true) true
整数占位符：
占位符 说明 举例 输出
%b 二进制表示 Printf("%b", 5) 101
%c 相应Unicode码点所表示的字符 Printf("%c", 0x4E2D) 中
%d 十进制表示 Printf("%d", 0x12) 18
%o 八进制表示 Printf("%d", 10) 12
%q 单引号围绕的字符字面值，由Go语法安全地转义 Printf("%q", 0x4E2D) '中'
%x 十六进制表示，字母形式为小写 a-f Printf("%x", 13) d
%X 十六进制表示，字母形式为大写 A-F Printf("%x", 13) D
%U Unicode格式：U+1234，等同于 "U+%04X" Printf("%U", 0x4E2D) U+4E2D
浮点数和复数的组成部分(实部和虚部)：
占位符 说明 举例 输出
%b 无小数部分的，指数为二的幂的科学计数法， 与 strconv.FormatFloat 的 'b' 转换格式一致。例如 -123456p-78
%e 科学计数法，例如 -1234.456e+78 Printf("%e", 10.2) 1.020000e+01
%E 科学计数法，例如 -1234.456E+78 Printf("%e", 10.2) 1.020000E+01
%f 有小数点而无指数，例如 123.456 Printf("%f", 10.2) 10.200000
%g 根据情况选择 %e 或 %f 以产生更紧凑的（无末尾的0）输出 Printf("%g", 10.20) 10.2
%G 根据情况选择 %E 或 %f 以产生更紧凑的（无末尾的0）输出 Printf("%G", 10.20+2i) (10.2+2i)
字符串与字节切片：
占位符 说明 举例 输出
%s 输出字符串表示（string类型或[]byte) Printf("%s", []byte("Go语言")) Go语言
%q 双引号围绕的字符串，由Go语法安全地转义 Printf("%q", "Go语言") "Go语言"
%x 十六进制，小写字母，每字节两个字符 Printf("%x", "golang") 676f6c616e67
%X 十六进制，大写字母，每字节两个字符 Printf("%X", "golang") 676F6C616E67
指针：
占位符 说明 举例 输出
%p 十六进制表示，前缀 0x Printf("%p",&people) 0x4f57f0
7.2fmt包的函数
输出：
fmt.Printf("名字%s 年纪%d ","Parallel",18) 格式化输出
fmt.Println("Hello world") 直接输出
输入：
Scan：从标准输入读取数据，以空格作为分隔（换行符也视作空格），依次将输入赋给参数。他会返回读取参数的个数，和读取过程中遇到的错误。
package main
import "fmt"
func main() {
var i int
var num float32
var s string
//可以传入任意类型
//scan以空格和换行分割
res, err := fmt.Scan(&i, &num, &s)
if err != nil {
fmt.Println("err is :", err)
}
fmt.Println("参数个数", res)
fmt.Println(i, num, s) //用户输入会通过空格分割 保存在三个变量中
}
Scanf：和Scan类似，可以自己定义输入格式
package main
import "fmt"
func main() {
var i int
var d float32
var s string
num, err := fmt.Scanf("%d %f %s", &i, &d, &s)
if err != nil {
fmt.Println("err is :", err)
}
fmt.Println("参数个数：", num)
/*
用户输入的i存储 数字
d存储浮点数
s存储字符串
*/
fmt.Println("用户输入信息：", i, d, s)
}
Scanln：Scanln和Scan几乎一样，只不过Scanln将换行符作为一次输入的结束
8.Go随机数math/rand包
package main
import (
"fmt"
"math/rand"
"time"
)
func main() {
//随机数，根据底层算法公式，算出的结果，根据种子数seed计算
//默认种子数是1
//修改种子数，种子数固定，随机数也固定，因此可以根据纳秒时间戳来定义
rand.Seed(time.Now().UnixNano()) //接收一个int64的数值，数值随意
num1 := rand.Intn(10) //获取[0,n) 的一个随机数
fmt.Println(num1)
num2 := rand.Intn(10) //获取[0,n) 的一个随机数
fmt.Println(num2)
num3 := rand.Intn(10) //获取[0,n) 的一个随机数
fmt.Println(num3)
}
六、Go变量和常量
1.Go变量
定义：变量是对内存中数据存储空间的表示，本质是一块内存空间，用于存储某个数值，该数值在运行时可以改变
步骤：1、声明变量，定义变量 2、给变量赋值 3、使用变量
package main
import "fmt"
func main() {
var name string //声明变量名 name
name = "Parallel" //给与变量赋值
fmt.Println("name的值是：", name) //使用变量
}
/*使用过程
读取代码
变量加载到内存 name指向内存地址的值*/
2.Go变量定义方式
局部变量：函数内部定义的变量，指的是该变量的作用范围
全局变量：函数外部，整体作用域
package main
import "fmt"
var (
d1, d2, d3 = 1, 2, 3 //一次声明多个全局变量
)
func test1() {
var age int
fmt.Println("age的值是：", age) //默认值0
var name string
fmt.Println("name的值是：", name) //默认值空
var salary float64
fmt.Println("salary的值是：", salary) //默认值0
}
func test2() {
var num, num1 = 10, 11 //一次定义多个变量
fmt.Println(num, num1)
}
func test3() {
name := "Parallel" //短声明，只能在函数内部使用
fmt.Println("name的值是：", name)
var n1, n2, n3 int //一次性声明多个变量，int默认值
fmt.Println(n1, n2, n3)
var c1, c2, c3 = "chaoge", 18, 99.99 //声明多个变量，且赋值
fmt.Println(c1, c2, c3)
a1, a2, a3 := "yu", 17, 100.0 //短声明多个变量
fmt.Println(a1, a2, a3)
}
func test4(){
_, name := Person(18, "好嗨哦") //_是一个只写的变量，不能读，等于舍弃，常用与接收函数的返回值
fmt.Println(name)
}
func main(){
test1() //执行函数
test2() //执行函数
test3() //执行函数
test4() //执行函数
}
3.Go变量类型
内置类型 值类型：
bool 布尔类型
int(32 or 64),int8,int16,int32,int64 整数类型
uint(32 or 64),uint8(byte),uint16,uint32,uint64 无符号整型
folat32,float64 浮点型
string 字符串
aray 固定长度的数组
struct 结构体
引用类型(指针类型)：
slice 切片
map 映射
chan 管道
interface 接口
4.Go常量
定义：常量使用关键字 const 定义，用于存储不会改变的数据。常量不能被重新赋予任何值。 存储在常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型
//批量声明常量
const (
a = 100
b = 1000
c //后面c，d默认和上一个常量值一样
d = "hello"
)
5.Go常量中iota常量生成器(枚举)
定义：iota用于生成一组相似规则初始化的常量，在const常量声明的语句中，第一个常量所在行，iota为0，之后每一个常量声明加一。
package main
import (
"fmt"
)
const (
A = iota //初始0
B // +1
C = "c" //iota枚举被打断 ，为 c
D // c，与上 相同。
E = iota // 4，显式恢复。注意计数包含了 C、D 两个，此时为4 。
F // 恢复iota 加一，此时为5
)
func main() {
fmt.Println(A, B, C, D, E, F) //0 1 c c 4 5
}
七、运算符
1.算数运算符
+ - * / % ++ --
2.关系运算符
== ！= > >= < <= 全部返回布尔值
3.逻辑运算符
&&：逻辑运算符and，如果两边的操作都是True，则为True，否则为False
||：||两边条件有一个成立就为真
!：逻辑运算符not，如果条件为True，则为False，否则为True
4.位运算符
&：对应的二进制数相与，上下两位均为1才为1
|：对应的二进制数相与，上下两位有一个为1就为1
^：对应的二进制数相与，上下两位不一样才为1
<<：左移n位，就是乘以2的n次方"a<<b"是把a的各二进位全部左移b位，高位丢弃，低位补0
>>：右移n位，就是除以2的n次方"a>>b"是把a的各二进位全部右移b位
5.赋值运算符
= += -= *= %= <<= >>=
&=：按位与后赋值
|=：按位与后赋值
^=：按位异或与后赋值