go 简介
#1 Go 即Golang，是Google公司2009年11月正式对外公开的一门编程语言
#2 解释型，编译型
Go是静态（编译型）强类型语言，是区别于解析型语言的弱类型语言(静态：类型固定 强类型：不同类型不允许直接运算)。
python动态强类型语言
#3 哪些是编译，哪些是解释
编译：java，c，c++，c#，go
解析型：python，js，php...
编译型语言涉及到跨平台，因为它需要编译成该平台的可执行文件，java--》运行在jvm之上
go：跨平台编译，交叉编译，在windows平台编译出mac上可执行
解释型：不存在跨平台问题，有解释器
#4 特性
跨平台的编译型语言，交叉编译
管道（channel），切片（slice），并发（routine）
有垃圾回收的机制
支持面向对象和面向过程的编程模式（go的面向对象没有类的概念）
# 5 发展（go是用c写起来的）
2009年11月7日 weekly.2009-11-06 —— 早期的版本
2015年8月19日 go1.5 —— 实现的架构变化，同时保留了和旧版本的兼容性,本次更新中移除了”最后残余的C代码”。# 从此以后，自举，自己写自己
2018年8月24日 go 1.11 ：modules，包管理
2020 年 8 月 go 1.15
# Go语言应用
中国的互联网公司，多多少少都会用，有些没用的，都在准备用
##### docker k8s 蓝鲸 云计算 百度 小米:falcon
##### 七牛云
## 应用领域，go适合做什么
服务的开发，微服务开发，运维相关，区块链，云平台
第一款开源区块链产品是用go写的
# Go语言优势
很新，生态不完善
完美契合当下高并发的互联网生态
语法简单，速度快
云计算和区块链的火，互联网企业高并发的需求
开发环境搭建
#1 ide,集成开发环境（goland等同于pycharm）
-goland（jetbrains全家桶），vscode
-推荐用goland，pycharm，idea，androidstudio
#2 开发环境 sdk
# 测试安装成功
go version
#3 注意事项（重点）
-goland 创建项目，选择go的安装路径（默认）
-gopath：所有的go代码必须放在这个路径下的src文件夹下，否则无法执行，默认创建到用户家目录下的go文件夹（mac,windows,linux）
-创建项目路径，go文件都不要出现中文
go 命令
go env # go的环境变量
-GO111MODULE=空的，没有使用MODULE模式
-GOPATH=C:Usershomego #代码存放路径
-GOROOT=c:go # go sdk安装路径
go build # 编译 运行是 exe 文件
go run # 编译并执行，开发阶段用，两步并作一步
go get # 下载并安装包和依赖等同于pip install
go version
go fmt # 进行格式化（go fmt ：自动将代码格式）
helloword
//go（所有编译型语言）项目要运行，必须有一个入口
//go的入口是main包下的main函数
// main包下只能有一个main函数
package main //声明包名，包名是main，每一个go文件都属于某个包
import "fmt" //导入包，内置包
func main() { //定义了一个main函数，大括号包裹是函数体的内容
fmt.Println("hello world") //打印函数等同与print()
}
// 编译
go build s1.go
// 执行
s1.exe
// 编译并执行
go run s1.go
// 在goland中，右键，运行即可
print // 不换行
printf // 格式化输出
println // 换行
注释
//单行注释
/*
多行注释
多行注释
*/
变量
package main
import "fmt"
func main() {
//1 定义变量的第一种方式：全定义
//var关键字 变量名 变量类型 = 变量值
//在go中，变量定义了就必须使用，如果不使用就报错
var age int =10
fmt.Println(age)
//2 定义变量的第二种方式：类型推导（类型不需要写了）
var age =10
age=100
var name ="lqz"
fmt.Println(age) //打印并换行
fmt.Print(name) //打印不换行
fmt.Printf("%T
",age) //查看变量类型
fmt.Printf("%T",name)
fmt.Printf("%p",&name)
//3 定义变量的第三种方式：简略声明（类型和var关键字都不写）这种用的多,冒号和等号是一家
a:=10
//var a int =100 //重复定义
//var a =99 //重复定义
a := 99 //重复定义
a=99
fmt.Println(a)
//4 其他变形方式
//4.1 只定义不赋值
var age int //定义变量 //如果是只定义，不赋值，只能用这种
var age //只定义，不赋值，不行
//4.2 声明多个变量
var width, height int = 100, 50 // 声明多个变量
var width,height =100,50 // 声明多个变量
var width,height =100,"lqz" // 声明多个变量
width,height :=100,";qz" // 声明多个变量
//4.3 声明多个变量,并赋初值
var (
name = "naveen"
age int = 29
height int
)
fmt.Println(name,age,height)
//4.4 小坑
var a int =10
//var b =99
b,a:=99,100 //这个不报错，我们觉得是重复定义，冒号左侧，只要有一个没有定义过的变量，就可以
fmt.Println(b)
fmt.Print(a)
/*
总结：
1 变量类型在定义阶段就确定了，一旦确定，不允许改变
2 变量不可以重复定义
3 变量要先定义再使用
*/
}
变量定义规范
/*
变量命名规范
-变量命令建议用驼峰，（大小写有特殊意义）
-go文件命名建议用 下划线
-一个名字必须以一个字母（Unicode字母）或下划线开头，后面可以跟任意数量的字母、数字或下划线，不能以数字开头
-区分大小写
-关键字和保留字都不能用作变量名
*/
/*
Go语言中关键字有25个
break default func interface select
case defer go map struct
chan else goto package switch
const fallthrough if range type
continue for import return var
go语言中有37个保留字，主要对应内建的常量、类型和函数
内建常量: true false iota nil
内建类型: int int8 int16 int32 int64
uint uint8 uint16 uint32 uint64 uintptr
float32 float64 complex128 complex64
bool byte rune string error
内建函数: make len cap new append copy close delete
complex real imag
panic recover
*/
数据类型
/*
基础数据类型
数字：
有符号整形
-int：在32位机器是int32，在64位机器是int64
-int8：表示整数范围是：8个比特位，8个bit是1byte ，负数和0， 2的7次方-1 的范围
-int16 2的15次方减一
-int32
-int64
无符号整型
-uint8 2的8次方减一 定义一个人的年龄
-uint16
-uint32
-uint64
浮点型（小数），表示小数点后长度多少位
-float32
-float64
复数
-complex64
-complex128
byte：是int8的别名 单引号包裹
rune：是int32的别名 单引号包裹
字符串
双引号包裹
反引号包裹 ` `
布尔
bool true 和 false
数据类型默认值：
数字类型是0
字符串类型是 空字符串
布尔类型 false
*/
Java中数据类型对应：
/*
byte:int8
short :int16
int:int32
long:int64
float:float32
double:float64
*/
常量
package main
import "fmt"
//常量
func main() {
//常量的定义，第一种
//const 变量名 变量类型 = 变量值
const age int8 = 99
//修改就报错
age=199
fmt.Println(age)
//第二种方式类型推导
const age = 99
age=88
fmt.Println(age)
//其他定义方式
const name,age = "zhangsan",99
const (
name string ="lqz"
age =99
)
const (
s1 = iota
s2 = iota
s3
s4 = 99
s5 = iota
)
fmt.Println(s1)
fmt.Println(s2)
fmt.Println(s3)
fmt.Println(s4)
fmt.Println(s5)
/* 结果
0
1
2
99
4
*/
// iota 相当于一个索引
const (
s1 = iota
s2 = iota
s3
s4 = 99
s5
s6
)
fmt.Println(s1)
fmt.Println(s2)
fmt.Println(s3)
fmt.Println(s4)
fmt.Println(s5)
/* 结果
0
1
2
99
99
99
*/
// iota 相当于一个索引，如果不重新把iota赋给后面的量，后面都重复自定义的量
}
//const 关键字定义，不允许改变
函数概念
package main
import "fmt"
//给类型命别名
type MyFunc func(a,b int)(int,string)
type Myint int
func main() {
var a int =10
var b Myint=9
fmt.Println(a+int(b))
//定义方式
/*
func 名字(参数名 类型，参数名 类型)(返回值类型，返回值类型){
函数体内容
return 返回值1，返回值2
}
*/
//1 调用函数
add(2,3,"xxx")
var a int =add(2,3)
a := add(2, 3)
fmt.Println(a)
//多返回值就需要用多变量接收
a,b:=add(3,4)
fmt.Println(a,b)
//多返回值，忽略一个返回值
a,_:=add(3,4)
fmt.Println(a)
fmt.Println(_)
//匿名函数(定义在函数内部的函数，不能是有名函数)，头等函数
var a func()
a = func (){
fmt.Println("我是匿名函数")
}
a()
//函数返回值是函数
a:=test()
fmt.Println(a) // 函数内存地址
a()
//8 函数返回值为函数,返回的函数带参数
a:=test()
a("xxx")
//9 函数返回值为函数,返回的函数带参数,带返回值
var a func(a,b int)int
a=test()
fmt.Println(a(2,3))
//10 函数参数为函数类型，返回值为带参数，带返回值的函数类型
a,b:=test(func() {
fmt.Println("我是函数参数")
})(3,4)
f:= func() {
fmt.Println("我是函数参数")
}
f1:=test(f)
a,b:=f1(3,4)
fmt.Println(a,b)
//闭包函数的使用
a:=test(19)
////a是闭包函数
a()
//装饰器是闭包函数的典型应用（go中没有装饰器的语法糖），通过闭包实现装饰器
//类型重命名
var a MyFunc =test()
c,d:=a(1,2)
fmt.Println(c,d)
}
//1 有参数无返回值(定义函数)
func add(a int,b int) {
fmt.Println(a+b)
}
//2 有参数无返回值,有多个相同类型参数
func add(a ,b int) {
fmt.Println(a+b)
}
//3 有参数无返回值,有多个相同类型参数，也有不同类型
func add(a ,b int,msg string) {
fmt.Println(a+b)
fmt.Print(msg)
}
//4 多个参数，一个返回值
func add(a, b int) int {
return a + b
}
//5 多个参数，多个返回值
func add(a, b int) (int,int) {
return a + b,a*b
}
//6 命名返回值
func add(a, b int) (c int,d int) {
c=a+b
d=a*b
//return时，不需要再写c,d了
return
}
//7 函数是一等公民，函数可以赋值给变量
//8 函数返回值为函数
func test() func() {
return func() {
fmt.Println("我是返回函数")
}
}
/9 函数返回值为函数,返回的函数带参数
// 类型只要有不一样的地方，就不是一个类型
func test() func(msg string) {
return func(msg string) {
fmt.Println(msg)
}
}
//10 函数返回值为函数,返回的函数带参数,带返回值
func test() func(a,b int) int{
return func(a,b int) int {
return a+b
}
}
//11 函数参数为函数类型，返回值为带参数，带返回值的函数类型
func test(f func()) func(a,b int) (int,int){
return func(a,b int) (int,int) {
f()
return a+b,a*b
}
}
//12 闭包函数：1 定义在函数内部 2对外部作用域有引用
// 闭包函数就是多了一种函数传参的方法，包进去了（内存逃逸）
func test(age int) func() {
a:= func() {
fmt.Println(age)
}
return a
}
//13 Myfunc 为类型别名
func test() MyFunc {
return func(a,b int)(int,string) {
fmt.Println("xxx")
return 10,"ok"
}
}
变量作用域范围
package main
import "fmt"
//在同一个包下，函数名不能重名
var a int //全局变量，全局有效，只要改了，就是改了
func main() {
fmt.Println(a) //0
a=19
fmt.Println(a) //19
test1() //99
fmt.Println(a) //99
}
func test1() {
a=99
fmt.Println(a)
}
//变量的作用域范围
var a int //全局变量，全局有效，只要改了，就是改了
func main() {
var a int
fmt.Println(a) //0
a=19
fmt.Println(a) //19
test1() // 0
fmt.Println(a) //19
}
func test1() {
fmt.Println(a)
}