国内官网https://golang.google.cn/dl/
1.2 下载goland(ide)goland下载(ide)https://www.jetbrains.com/go/
1.3 环境搭建教程
#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文件都不要出现中文
# 3 go命令
# 必须记住的
go env # go的环境变量
-GO111MODULE=空的，现在没有使用MODULE模式
-GOPATH=C:Usersoldboygo #代码存放路径
-GOROOT=c:go # go sdk安装路径
go build # 编译型语言，需要先编译再执行，编译成可执行文件，执行可执行文件
go run # 编译并执行，开发阶段用，两步并作一步
# 其他不太需要记得
go get # 下载并安装包和依赖等同于pip install
go version
go fmt #运行gofmt进行格式化（go fmt ：自动将代码格式）
1.4 golang介绍
#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语言发展前景，为什么火 很新，生态不完善 完美契合当下高并发的互联网生态 语法简单，速度快 云计算和区块链的火，互联网企业高并发的需求2. HelloWord
package main
import "fmt"
func main() {
fmt.Println("hello word")
}
// 输出
// hello word
3. 变量
3.1 全定义
package main
import "fmt"
func main() {
//1 定义变量的第一种方式：全定义
//var关键字 变量名 变量类型 = 变量值
var name string = "xl" //在go中，变量定义了就必须使用，如果不使用就报错
fmt.Println(name)
}
3.2 类型推导
package main
import "fmt"
func main() {
//2 定义变量的第二种方式：类型推导（类型不需要写了）
//var关键字 变量名 = 变量值
var name = "xl" //在go中，变量定义了就必须使用，如果不使用就报错
fmt.Println(name) //打印并换行
fmt.Print(name) //打印不换行
fmt.Printf("%Tn", name) //查看变量类型
fmt.Printf("%p", &name) //查看变量内存地址
}
3.3 简略声明(最常用的)
package main
import "fmt"
func main() {
//定义变量的第三种方式：简略声明（类型和var关键字都不写）这种用的多,冒号和等号是一家
//var关键字 变量名 = 变量值
name := "xl" //在go中，变量定义了就必须使用，如果不使用就报错
//var a int = 100 //不能重复定义
fmt.Println(name) //打印并换行
}
3.4 其他变形方式
/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)3.5 总结 4. 变量定义规范
5. 类型
6. 常量 6.1 第一种
package main
import "fmt"
func main() {
const name string = "xl"
fmt.Println(name)
fmt.Printf("%T", name) // string
}
6.2 类型推导
package main
import "fmt"
func main() {
const name = "xl"
fmt.Println(name) // 常量可以不引用
fmt.Printf("%T", name) // string
}
6.3 其他定义方式
//const 关键字定义，不允许改变
# 1
package main
import "fmt"
func main() {
const name, age = "xl", 20
fmt.Println(name) // 常量可以不引用
fmt.Printf("%T", name) // string
}
# 2
package main
import "fmt"
func main() {
const (
name string = "xl"
age = 20
)
fmt.Println(name) // 常量可以不引用
fmt.Printf("%T", name) // string
}
# 3
package main
import "fmt"
func main() {
const (
s1 = iota
s2 = iota
s3
s4 = 99
s5 = iota
)
fmt.Println(s3) // 常量可以不引用
}
7. 函数基础
定义方式
//定义方式有参数无返回值(定义函数)
package main
import "fmt"
// 调用
func main() {
add(1, 1)
}
// 定义
//1 有参数无返回值(定义函数)
func add(a int, b int) {
fmt.Println(a + b)
}
有参数无返回值,有多个相同类型参数
package main
import "fmt"
// 调用
func main() {
add(1, 1)
}
// 定义
//2 有参数无返回值,有多个相同类型参数
func add(a, b int) {
fmt.Println(a + b)
}
有参数无返回值,有多个相同类型参数，也有不同类型
package main
import "fmt"
// 调用
func main() {
add(1, 1, "xl")
}
// 定义
//3 有参数无返回值,有多个相同类型参数，也有不同类型
func add(a, b int, msg string) {
fmt.Println(a + b)
fmt.Println(msg)
}
多个参数，一个返回值
package main
import "fmt"
// 调用
func main() {
add(1, 1)
}
// 定义
//4 多个参数，一个返回值
func add(a, b int) int {
fmt.Println(a + b)
return a + b
}
多个参数，多个返回值
package main
import "fmt"
// 调用
func main() {
a, b := add(1, 1)
fmt.Println(a, b)
}
// 定义
//4 多个参数，多个返回值
func add(a, b int) (int, int) {
return a + b, a
}
命名返回值
package main
import "fmt"
// 调用
func main() {
a, b := add(1, 1)
fmt.Println(a, b)
}
// 定义
//4 多个参数，多个返回值
func add(a, b int) (c int, d int) {
c = a + b
d = a * b
return
}
多返回值时，忽略一个返回值
a,_:=add(3,4)
fmt.Println(a)
fmt.Println(_)
//4 多个参数，多个返回值
func add(a, b int) (int,int) {
return a + b,a*b
}
匿名函数
package main
import "fmt"
// 调用
func main() {
text()
}
//匿名函数(定义在函数内部的函数，不能是有名函数)，头等函数
func text() {
var a func()
a = func() {
fmt.Println("我是匿名函数")
}
a()
}
函数返回值为函数
package main
import "fmt"
// 调用
func main() {
a := text()
fmt.Println(a)
}
// 定义
func text() func() {
return func() {
}
}
函数返回值为函数,返回的函数带参数
package main
import "fmt"
// 调用
func main() {
a := text("xl")
fmt.Println(a)
a("xxl")
}
// 定义
func text(name string) func(msg string) {
return func(msg string) {
msg = name
fmt.Println(msg)
}
}
函数返回值为函数,返回的函数带参数,带返回值
package main
import "fmt"
// 调用
func main() {
a := text()
fmt.Println(a)
}
// 定义
//函数返回值为函数,返回的函数带参数,带返回值
func text() func(a, b int) int {
return func(a, b int) int {
return a + b
}
}
函数参数为函数类型，返回值为带参数，带返回值的函数类型
package main
import "fmt"
// 调用
func main() {
a := text(func() {
})
fmt.Println(a)
c, b := a(1, 2)
fmt.Println(c, b)
}
// 定义
//函数参数为函数类型，返回值为带参数，带返回值的函数类型
func text(f func()) func(a, b int) (int, int) {
return func(a, b int) (int, int) {
f()
return a + b, a * b
}
}
类型重命名
//类型重命名
var a MyFunc =test()
c,d:=a(1,2)
fmt.Println(c,d)
func test()MyFunc {
return func(a,b int)(int,string) {
fmt.Println("xxx")
return 10,"ok"
}
}
8. 闭包函数
定义
1 定义在函数内部 2 对外部作用域有引用 3 闭包函数就是多了一种函数传参的方法，包进去了案例
package main
import "fmt"
// 调用
func main() {
text(18)()
}
// 定义
//函数参数为函数类型，返回值为带参数，带返回值的函数类型
func text(age int) func() {
a := func() {
fmt.Println(age)
}
return a
}
9. 变量作用域范围
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)
}
