Golang 笔记
1. hello Golang
- 新建项目，推荐GoLand工具
GOPATH目录：D:\go\awesomeProject
三个标准目录：bin，pkg，src
MAIN目录：D:\go\awesomeProject\src\GolangStudy\firstGolang\main
GLAND设置GOPATH 必须重启，否则不生效
- hello.go
package main
/*
import "fmt"
import "time"
*/
import (
"fmt"
"time"
)
// man函数
func main() { //花裤服 必须和main在同一行
// 分号; 加不加不影响
fmt.Println("hell0 Go")
time.Sleep(1 * time.Second)
}
-
直接运行：
- D:\go\awesomeProject\src\GolangStudy\firstGolang\main> go run .\hello.go
-
编译后运行：
- D:\go\awesomeProject\src\GolangStudy\firstGolang\main> go build .\hello.go
- D:\go\awesomeProject\src\GolangStudy\firstGolang\main> .\hello.exe
2. 变量
- main入口
package main
import "fmt"
func main() {
// 代码
}
- 局部变量
// 方法1：申明一个变量，默认值 0，且申明变量必须使用
var a int
fmt.Println("a = ", a)
fmt.Printf("type of a = %T\n", a)
// 方法2：申明一个变量，初始化一个值
var b int = 1
fmt.Println("b = ", b)
fmt.Printf("type of b = %T\n", b)
var bb string = "bb"
fmt.Println("bb = ", bb)
fmt.Printf("type of bb = %T\n", bb)
// 方法3：申明一个变量，类型自动推断，这很python化
var c = 2
fmt.Println("c = ", c)
fmt.Printf("type of c = %T\n", c)
var cc = "cc"
fmt.Println("cc = ", cc)
fmt.Printf("type of cc = %T\n", cc)
// 方法4：申明一个变量，不要哇 var , 只能在函数体内使用！！！！！！！！！！！！！！！
e := 100
fmt.Println("e = ", e)
fmt.Printf("type of e = %T\n", e)
f := 3.14
fmt.Println("f = ", f)
fmt.Printf("type of f = %T\n", f)
-
全局变量：不支持 :=
-
多行变量
// 申明多个变量, 变量类型不要求统一
var xx, yy = 100, "元"
fmt.Println("xx = ", xx, "yy = ", yy)
// 申明多个变量，多行写
var (
aaa = 50
bbb = "元"
ccc = true
)
fmt.Println("aaa = ", aaa, "bbb = ", bbb, "ccc = ", ccc)
3. 常量
- const_iota
package main
import "fmt"
// const 定义枚举类型
// const 内部使用 iota 实现累加， 第一行默认为0
// iota 只能在 const 内使用
const (
BEIJING = 10 * iota // iota = 0
SHANGHAI // iota = 1
SHENZHEN // iota = 2
)
const (
a, b = iota + 1, iota + 2 // a=1, b=2
c, d // c=2, d=3
e, f // e=3, f=4
g, h = iota * 2, iota * 3 // g=6, h=9
i, j // i=8, j =12
)
func main() {
// 常量：const类似scala的val（只读）
const length int = 10
fmt.Println("length = ", length)
fmt.Println("BEIJING = ", BEIJING, "SHANGHAI = ", SHANGHAI, "SHENZHEN = ", SHENZHEN)
fmt.Println("a,b = ", a, b)
fmt.Println("c,d = ", c, d)
fmt.Println("e,f = ", e, f)
fmt.Println("g,h = ", g, h)
fmt.Println("i,j = ", i, j)
}
4. 函数多返回值
package main
import "fmt"
// 单反回值
func fool(a string, b int) int {
fmt.Println("a = ", a)
fmt.Println("b = ", b)
c := 100
return c
}
// 多返回值 匿名返回
func fool2(a string, b int) (int, int) {
fmt.Println("a = ", a)
fmt.Println("b = ", b)
return 666, 777
}
// 多返回值 实名返回 (r1 int, r2 int)\
// r1 r2 默认值 0
func fool3(a string, b int) (r1 int, r2 int) {
fmt.Println("a = ", a)
fmt.Println("b = ", b)
// 此处没有 冒号
r1 = 666
r2 = 777
return
}
// 多返回值 实名返回 (r1, r2 int)
func fool4(a string, b int) (r1, r2 int) {
fmt.Println("a = ", a)
fmt.Println("b = ", b)
// 此处没有 冒号
r1 = 666
r2 = 777
return
}
func main() {
ret1 := fool("abc", 555)
fmt.Println("ret1 = ", ret1)
res1, res2 := fool2("abc", 555)
fmt.Println("res1 = ", res1, "res2 = ", res2)
res3, res4 := fool3("abc", 555)
fmt.Println("res3 = ", res3, "res4 = ", res4)
}
5. init函数
-
导包时：
- 优先调用每个包的init方法，
- 然后在执行main()方法
-
确定GOPATH位置
// lib1 位置 D:\go\awesomeProject\src\GolangStudy\5-init\lib1\lib1.go
package lib1
import "fmt"
func init() {
fmt.Println("lib1.init() ...")
}
func Lib1Test() {
// 函数名大写表示对外公开
fmt.Println("Lib1Test")
}
// lib1 位置 D:\go\awesomeProject\src\GolangStudy\5-init\lib2\lib2.go
package lib2
import "fmt"
func init() {
fmt.Println("lib2.init() ...")
}
func Lib2Test() {
// 函数名大写表示对外公开
fmt.Println("Lib2Test")
}
// main()位置： D:\go\awesomeProject\src\GolangStudy\5-init\main.go
package main
import (
"GolangStudy/5-init/lib1"
"GolangStudy/5-init/lib2"
)
func main() {
lib1.Lib1Test()
lib2.Lib2Test()
}
- 返回信息
PS D:\go\awesomeProject\src\GolangStudy\5-init> go run .\main.go
lib1.init() ...
lib2.init() ...
Lib1Test
Lib2Test
6. import导包
- 匿名导入
- 别名导入
- 直接导入(方法)
package main
import (
// 1.匿名导入： 只需要包的init方法，不执行其他函数时
_ "GolangStudy/5-init/lib1"
// 2.别名导入：import pandas as pd
mylib2 "GolangStudy/5-init/lib2"
// 3.直接导入：from pandas import *
// . "GolangStudy/5-init/lib2"
)
func main() {
//lib1.Lib1Test() //导入lib1，但不使用非init方法，使用匿名
mylib2.Lib2Test() //别名
}
7.指针(李姐)
- 互换（值传递模式）: 重新赋值
package main
import "fmt"
// 值传递
func swap1(a int, b int) (int, int) {
var tmp int // tmp 初始为 0
tmp = a // 此时 a的值改变的是tmp内存对应的值： 把0改为10
a = b // 此处 这个a在函数内开辟一个新内存地址，默认为0，然后被赋值b=20
b = tmp // 此处 这个b在函数开辟新一个内存地址，然后被赋值tmp=10
return a, b
}
func main() {
// a，b 的内存地址没变
var a = 10
var b = 20
// 交换 a b == 》 这里需要重新赋值才能改变，否则是不会改变a,b的值
aa, bb := swap1(a, b)
fmt.Println("a=", a, "b=", b)
fmt.Println("aa=", aa, "bb=", bb)
}
- res
PS D:\go\awesomeProject\src\GolangStudy\6-point> go run .\pointer1.go
a= 10 b= 20
aa= 20 bb= 10
- 互换（指针传递）
package main
import "fmt"
// 指针传递 == 》 不需要重新赋值，李姐起来稍微头痛！
// pa *int 表示 pa 这个参数类型是指针(内存地址) --》 a的内存地址指向的值
// pb *int 同理 --》 b的内存地址指向的值
func swap2(pa *int, pb *int) {
var tmp int // tmp 初始为 0 ，产生了个新内存地址
tmp = *pa // 此时 tmp 丢弃源内存地址，霸占a的内存地址及值 tmp = 10
*pa = *pb // 此处 a 并未产生新的内存地址，而是把霸占了b的内存地址和值 a = 20
*pb = tmp // 此处 因为第二步 tmp霸占了a的内存地址，所以此时tmp所对应的就是a的内存地址
}
func main() {
var a = 10
var b = 20
// 直接传内存地址 -- 》 元神出窍？？？
swap2(&a, &b)
fmt.Println("a=", a, "b=", b)
//fmt.Println("aa=", aa, "bb=", bb)
}
- res
PS D:\go\awesomeProject\src\GolangStudy\6-point> go run .\pointer2.go
a= 20 b= 10