Golang 记录

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