Golang 基础：Go Module, for range, 切片, map, struct 等使用和实现

admin@C02ZL010LVCK hellomodule % go mod tidy
go: finding module for package go.uber.org/zap
go: finding module for package github.com/valyala/fasthttp
go: downloading github.com/valyala/fasthttp v1.34.0
go: found github.com/valyala/fasthttp in github.com/valyala/fasthttp v1.34.0
go: found go.uber.org/zap in go.uber.org/zap v1.21.0
go: downloading github.com/andybalholm/brotli v1.0.4
go: downloading github.com/klauspost/compress v1.15.0
admin@C02ZL010LVCK hellomodule % ls  
go.mod  go.sum  main.go
admin@C02ZL010LVCK hellomodule % cat go.mod 
module github.com/shixinzhang/hellomodule1

go 1.16

require (
	github.com/valyala/fasthttp v1.34.0
	go.uber.org/zap v1.21.0
)
admin@C02ZL010LVCK hellomodule % 

admin@C02ZL010LVCK ~ % go env GOPROXY
https://proxy.golang.org,direct
admin@C02ZL010LVCK ~ % go env GOMODCACHE
/Users/simon/go/pkg/mod

import github.com/user/repo/v2/xxx

import (
	"database/sql"
	_ "github.com/go-sql-driver/mysql"	//空导入
)

	db, err = sql.Open("mysql", "root:password@tcp(127.0.0.1:3306)/todo")

//mysql 的 driver.go
func init() {
	sql.Register("mysql", &MySQLDriver{})
}

package test

import "fmt"

//包级变量
var Age int
var (
	name string = "shixinzhang"
	address = "Shanghai"	//省略类型
	a, b, c = 1, 2.1, 'c'	//一行声明多个，省略类型
)

func TestVariable()  {
	var height int = 128
	var h = int32(128)	//显式类型转换 等同于下面这个
	var h32 int32 = 128

	var a, b, c int = 1,2,3	//一行声明多个变量，类型其实可以推导出来，逗号不能少！

	weight := 140	//短变量声明，省略 var 和类型
	d, e, f := 4,5, "hi"	//短变量也可以声明多个，不同类型也可以

	fmt.Println("height ", height, h, h32, weight, a,b,c, d,e,f)
}

var a int = 10

var (
	name string = "shixinzhang"
	address = "Shanghai"	//省略类型
	a, b, c = 1, 2.1, 'c'	//一行声明多个，省略类型
)

a := 12
a, b, c := 12, 'B', "CC"

var ErrShortWrite = errors.New("short write")

age := 28
name := "shixinzhang"

s := []byte("hello shixinzhang")

func test() {
	var {
		age int
		name string
	}
}

func bar() {
	if a := 1; false {
	} else if b := 2; false {
	} else if c := 3; false {	//在 if 条件里创建的临时变量，在 else 里也可以访问
	} else {
		println(a, b, c)
	}

	//在 if 条件里创建的临时变量，在 else 里也可以访问
	//因为这个创建等价于这样：
	{
		c := 3 // 变量c作用域始于此
		if false {

		} else {
			println(a, b, c)
		}
		// 变量c的作用域终止于此
	}
}

# command-line-arguments
test/variable.go:18:6: declaration of "a" shadows declaration at line 10

func TestVariable()  {
	ss := int32(12)
	int8_a := int8(127)
	int8_a += 1	//溢出！

	uint8_b := uint8(1)
	uint8_b -= 2 //溢出！
	fmt.Println("sizeof int:", unsafe.Sizeof(a))
	fmt.Println("sizeof int8:", unsafe.Sizeof(int8_a), int8_a)
	fmt.Println("sizeof uint8:", unsafe.Sizeof(uint8_b), uint8_b)
	fmt.Println("sizeof int32:", unsafe.Sizeof(ss))
}

sizeof int: 8
sizeof int8: 1 -128
sizeof uint8: 1 255
sizeof int32: 4

func TestDiffFormatPrint() {
	value := 127
	value8 := 010
	value16 := 0x10

	fmt.Printf("value8 十进制：%d \n", value8)
	fmt.Printf("value16 十进制：%d \n", value16)
	fmt.Printf("十进制：%d \n", value)
	fmt.Printf("二进制：%b \n ", value)
	fmt.Printf("八进制：%o  \n", value)
	fmt.Printf("八进制带前缀：%O  \n", value)
	fmt.Printf("十六进制：%x \n ", value)
	fmt.Printf("十六进制带前缀：%X  \n", value)
}

value8 十进制：8 
value16 十进制：16 
十进制：127 
二进制：1111111 
 八进制：177  
八进制带前缀：0o177  
十六进制：7f 
 十六进制带前缀：7F  

func TestFloatNumber() {
	value := float64(1.2)

	fmt.Println("value: %d", value)

	var fl1 float32 = 16777216.0
	var fl2 float32 = 16777217.0
	fmt.Println("16777216.0 == 16777217.0? ", fl1 == fl2);

	bits := math.Float32bits(fl1)
	bits_fl2 := math.Float32bits(fl2)
	fmt.Printf("fl1 bits:%b \n", bits)
	fmt.Printf("fl2 bits:%b \n", bits_fl2)

	value3 := 6456.43e-2	//e-2 = 10^-2
	value4 := .12345e4	//10^4
	fmt.Printf("6456.43e-2 %f, .12345e4:%0.2f \n", value3, value4)

	//输出为科学计数法的形式
	fmt.Printf("%e \n", 6543.21)  //十进制的科学计数法
	fmt.Printf("%x \n", 6543.21)	//十六进制的科学计数法		//p/P 代表的幂运算的底数为 2
}

value: %d 1.2
16777216.0 == 16777217.0?  true
fl1 bits:1001011100000000000000000000000 
fl2 bits:1001011100000000000000000000000 
6456.43e-2 64.564300, .12345e4:1234.50 
6.543210e+03 
0x1.98f35c28f5c29p+12 

func TestComplex() {
	//声明一个复数
	c := 5 + 6i

	fmt.Println(reflect.TypeOf(c))

	//real 获取复数实部
	//imag 获取复数虚部
	fmt.Printf("实部: %f, 虚部: %f \n", real(c), imag(c))

	var _complex = complex(7.7, 8.8)
	fmt.Printf("实部: %f, 虚部: %f \n", real(_complex), imag(_complex))
}

complex128
实部: 5.000000, 虚部: 6.000000 
实部: 7.700000, 虚部: 8.800000 

type MyInt int32	//类型定义
type MyInt = int32	//类型别名

type MyInt int32
type MyIntAlias = int32

func TestTypeDef()  {
	age := int32(29)

	height := MyInt(199)
	weight := MyIntAlias(150)

	//cannot use height (type MyInt) as type int32 in assignment
	age = height	//编译器报错：Cannot use 'height' (type MyInt) as type int32
	age = weight	//不报错

}

func TestString()  {

	location := "中国人"

	//1.按字节输出
	fmt.Printf("the length of location is:%d\n", len(location))	//len: 字节大小

	for i:= 0; i < len(location); i++ {
		fmt.Printf("0x%x,", location[i])
	}
	fmt.Print("\n")

	//2.按字符输出
	fmt.Println("the length of rune/character:", utf8.RuneCountInString(location))

	for _, c := range location {
		fmt.Printf("%c | 0x%x , ", c, c)
	}
	fmt.Print("\n")
}

the length of location is:9
0xe4,0xb8,0xad,0xe5,0x9b,0xbd,0xe4,0xba,0xba,
the length of rune/character: 3
中 | 0x4e2d , 国 | 0x56fd , 人 | 0x4eba , 

// The len built-in function returns the length of v, according to its type:
//	Array: the number of elements in v.
//	Pointer to array: the number of elements in *v (even if v is nil).
//	Slice, or map: the number of elements in v; if v is nil, len(v) is zero.
//	String: the number of bytes in v.
//	Channel: the number of elements queued (unread) in the channel buffer;
//	         if v is nil, len(v) is zero.
// For some arguments, such as a string literal or a simple array expression, the
// result can be a constant. See the Go language specification's "Length and
// capacity" section for details.
func len(v Type) int

// $GOROOT/src/builtin.go
type rune = int32

func TestRune() {
	//定义一个字符
	var r rune = 0x4E2D
	fmt.Printf("The unicode character is: %c", r)
	fmt.Print("\n")

	//encode
	p := make([]byte, 3)	//创建一个数组
	_ = utf8.EncodeRune(p, r)	//编码为二进制
	fmt.Printf("encode result: 0x%X", p)
	fmt.Print("\n")

	//decode 0xE4B8AD
	buf := []byte {0xE4, 0xB8, 0xAD}
	r2, size := utf8.DecodeRune(buf)
	fmt.Printf("decode result: %c, size:%d", r2, size)
	fmt.Print("\n")
}

The unicode character is: 中
encode result: 0xE4B8AD
decode result: 中, size:3

// StringHeader is the runtime representation of a string.
// It cannot be used safely or portably and its representation may
// change in a later release.
// Moreover, the Data field is not sufficient to guarantee the data
// it references will not be garbage collected, so programs must keep
// a separate, correctly typed pointer to the underlying data.
type StringHeader struct {
	Data uintptr
	Len  int
}

func TestDumpBytes() {
	s := "hello"
	//1.获取这个字符串的地址，转换为一个 StringHeader
	header := (*reflect.StringHeader)(unsafe.Pointer(&s))
	fmt.Printf("0x%X\n", header.Data);	//输出底层数组的地址

	//2.通过 StringHeader 的数据指针获取到真实的字符串数据
	originString := (*[5]byte)(unsafe.Pointer(header.Data))	//StringHeader.Data 就是一个指针
	fmt.Printf("originString :%s\n", *originString)	//通过 * 获取指针指向的内容

	//3.遍历每个字符，打印
	for _, c := range *originString {
		fmt.Printf("%c_", c)
	}
	fmt.Print("\n")
}

0x10C9622
originString :hello
h_e_l_l_o_

const (
	_ = iota
	APPLE
	WATERMELON
	_
	BINANA = iota + 1000
	_
	ORANGE
)
func TestConstValue() {
	fmt.Printf("test enum %d \n", APPLE)
	fmt.Printf("test enum %d \n", WATERMELON)
	fmt.Printf("test enum %d \n", BINANA)
	fmt.Printf("test enum %d \n", ORANGE)
}

test enum 1 
test enum 2 
test enum 1004 
test enum 1006 

//参数的类型，如果是数组，个数也必须一致
func printArray(a [5]int) {
	fmt.Printf("length of arr: %d \n", len(a))	//元素个数
	fmt.Printf("size of arr: %d \n", unsafe.Sizeof(a))	//所有元素占用的字节数

	for i := 0; i < len(a); i++ {
		fmt.Printf("index: %d , value: %d, addr: 0x%x \n", i, a[i], &a[i])	//也可以取地址
	}
}

func (Array) test() {
	var arr [5]int
	printArray(arr)		
	arr[0] = 1

	//var arr2 []int	//不声明默认长度为 0
	//printArray(arr2)	//编译报错：Cannot use 'arr' (type [5]int) as type []int

	//var arr3 = [5]int {1,2,3,4,5}	//直接初始化，类型在等号右边，花括号包围初始值
	//var arr3 = [...]int {1,2,3,4,5}	//也可以省略长度，编译时推导
	var arr3 = [5]int { 2: 3 }	//也可以指定下标赋值，只设置某个值
	printArray(arr3)
}

length of arr: 5 
size of arr: 40 
index: 0 , value: 0, addr: 0xc00001e2d0 
index: 1 , value: 0, addr: 0xc00001e2d8 
index: 2 , value: 0, addr: 0xc00001e2e0 
index: 3 , value: 0, addr: 0xc00001e2e8 
index: 4 , value: 0, addr: 0xc00001e2f0 

//go/src/runtime/slice.go
type slice struct {
	array unsafe.Pointer	//指向底层数组的指针
	len   int
	cap   int
}

type MySlice struct {}

func printSlice(sl []int) {
	fmt.Printf("length: %d, capcity: %d \n", len(sl), cap(sl))
	for i, i2 := range sl {
		fmt.Printf("(%d, %d )  ", i, i2)
	}
	fmt.Printf("\n")
}

func (MySlice) test() {
	//1.创建切片
	sl := make([]int , 5, 7)	//创建了一个切片，长度为 5，有 5 个元素为 0 的值
	printSlice(sl)
	sl = append(sl, 1,2,3,4,5,6)	//添加 6 个，超出容量，翻倍，元素个数为 5 + 6
	printSlice(sl)

	//数组与切片类型不兼容：Cannot use '[5]int {1,2,3,4,5}' (type [5]int) as type []int
	//printSlice([5]int {1,2,3,4,5})

	//2.数组的切片化
	var arr = [...]int {1,2,3,4,5}
	//从索引 1 （第二个）开始，长度到 2，容量到 5
	sl2 := arr[1:3:5]	//长度是第二个值减去第一个，容量是第三个值减去第一个
	printSlice(sl2)

	sl2[0] = 444	//修改切片，会影响原始数组
	fmt.Printf("origin array first value: %d\n", arr[1])

	sl2 = append(sl2, 2, 3, 4, 5)
	printSlice(sl2)
	sl2[0] = 555	//扩容后会创建新数组，再修改不会影响原始数组
	fmt.Printf("origin array first value: %d\n", arr[1])
}

type MyMap struct {}

type Position struct {
	x float64
	y float64
}

func updateMap(m map[string]int) {
	m["hihi"] = 1024
}

func (MyMap) test() {
	//var m map[int]string	//不赋值，默认为 nil。这时操作的话会报错：panic: assignment to entry in nil map
	//m := map[int]string{}	//1.短变量的方式，加上 {}，就是初始化了
	m := make(map[int]string, 6)	//2.通过 make 创建
	m[1] = "haha"
	m[1024] = "bytes"
	fmt.Println(m[1], len(m))	//len(map): 获取 map 中已存储的键值对

	for k, v := range m {
		fmt.Printf("(%d, %s) ", k, v)
	}
	fmt.Printf("\n")

	//第一种初始化方式：字面值初始化
	//m1 := map[Position]string {	//较为复杂的初始化，写全类型
	//	Position{1,2}: "home",
	//	Position{3,4 }: "company",
	//}
	m1 := map[Position]string {
		{1,2}: "home",	//初始化赋值时，可以省略掉类型，直接以内容作为 key
		{3,4 }: "company",
	}

	fmt.Println(m1)

	p := Position{1,2}
	m1[p] = "shop"
	fmt.Println(m1)

	delete(m1, p)	//通过内置函数 delete 删除 map 的值，参数为 map 和 key
	fmt.Println("after delete: ", m1)

	//通过下标访问不存在的值，会返回这个类型的零值
	emptyMap := make(map[string]int)
	fmt.Printf("try key that is not inside map: %s , %d\n", m[1024], emptyMap["hihi"])

	//map 作为参数是引用传递，内部修改，外部也有影响！
	updateMap(emptyMap)
	value, ok := emptyMap["hihi"]	//通过 _value, ok（逗号 + ok） 的方式判断是否存在于 map
	if !ok {
		fmt.Println("hihi not in map")
	} else {
		fmt.Println("hihi in the map! ", value)
	}
}

haha 2
(1, haha) (1024, bytes) 
map[{1 2}:home {3 4}:company]
map[{1 2}:shop {3 4}:company]
after delete:  map[{3 4}:company]
try key that is not inside map: bytes , 0
hihi in the map!  1024

// $GOROOT/src/runtime/map.go
const (
	// Maximum number of key/elem pairs a bucket can hold.
	bucketCntBits = 3
	bucketCnt     = 1 << bucketCntBits

	// Maximum average load of a bucket that triggers growth is 6.5.
	// Represent as loadFactorNum/loadFactorDen, to allow integer math.
	loadFactorNum = 13
	loadFactorDen = 2

	// Maximum key or elem size to keep inline (instead of mallocing per element).
	// Must fit in a uint8.
	// Fast versions cannot handle big elems - the cutoff size for
	// fast versions in cmd/compile/internal/gc/walk.go must be at most this elem.
	maxKeySize  = 128
	maxElemSize = 128
)

// Like mapaccess, but allocates a slot for the key if it is not present in the map.
func mapassign(t *maptype, h *hmap, key unsafe.Pointer) unsafe.Pointer {
	// If we hit the max load factor or we have too many overflow buckets,
	// and we're not already in the middle of growing, start growing.
	if !h.growing() && (overLoadFactor(h.count+1, h.B) || tooManyOverflowBuckets(h.noverflow, h.B)) {
		hashGrow(t, h)
		goto again // Growing the table invalidates everything, so try again
	}
}

// overLoadFactor reports whether count items placed in 1<<B buckets is over loadFactor.
func overLoadFactor(count int, B uint8) bool {
	return count > bucketCnt && uintptr(count) > loadFactorNum*(bucketShift(B)/loadFactorDen)
}

// tooManyOverflowBuckets reports whether noverflow buckets is too many for a map with 1<<B buckets.
// Note that most of these overflow buckets must be in sparse use;
// if use was dense, then we'd have already triggered regular map growth.
func tooManyOverflowBuckets(noverflow uint16, B uint8) bool {
	// If the threshold is too low, we do extraneous work.
	// If the threshold is too high, maps that grow and shrink can hold on to lots of unused memory.
	// "too many" means (approximately) as many overflow buckets as regular buckets.
	// See incrnoverflow for more details.
	if B > 15 {
		B = 15
	}
	// The compiler doesn't see here that B < 16; mask B to generate shorter shift code.
	return noverflow >= uint16(1)<<(B&15)
}

type (
	T1 int
	T2 T1
)

type T struct { 
	my T // compile error: Invalid recursive type 'MyStruct'
	t *T // ok
	st []T // ok 
	m map[string]T // ok
}

	var em EmptyStruct
	fmt.Println("size of empty struct: ", unsafe.Sizeof(em))	//size of empty struct:  0

func NewT(field1, field2, ...) *T {
    ... ...
}

func NewPosition(center float64) *Position {
	return &Position{
		x: center - 10,
		y: center + 10,
	}
}

func main() {
    a, b := false,true
    if a && b != true {
        println("(a && b) != true")
        return
    }
    println("a && (b != true) == false")
}

	//if 的自用变量，在 if 的 else 代码块里也可以访问
	if tempA := 1; tempA > 0 {
		//...
	} else {
		fmt.Println(tempA)	//仍然可以访问
	}

	fmt.Println(tempA)	//Unresolved reference 'tempA'

	var i int
	for ; i< 10; {	//1.省略前置和后置
		i++
	}
	
	for i< 10 {		//2.连冒号也省略
		i++
	}
	
	for {			//3.没条件（类似 while(true)）
		if i < 10 {
			 
		} else {
			break
		}
	}

	s := []int{}
	for range s {	//4.不关心下标和值，可以省略
		//...
	}

	outer:
	for i := 0; i < 3; i++ {
		fmt.Println("outer loop: ", i)
		for j := 0; j < 6; j++ {
			if j == 2 {
				//break outer	//结束 outer 冒号后的最外层循环
				continue outer	//继续执行外层循环
				//continue	//跳过 2
			}
			fmt.Println("inner loop: ", i, j)
		}
	}

for i, v := range m {
	//...
}

i, v := 0, 0	//只创建一次
for i, v = range m {	//每次修改这个值
	//...	//如果有延迟执行的代码，可能访问到的是 i, v 的最终结果
}

	var arr = [...]int {1,2,3,4,5}
	var copy [5]int

	fmt.Println("origin arr ", arr)

	for i, v := range arr {	
		if i == 0 {
			arr[1] = 100	//这里修改的是原始的
			arr[2] = 200
		}
		fmt.Println("in for-range ", i, v)
		copy[i] = v
	}

	fmt.Println("after loop, arr ", arr)
	fmt.Println("after loop, copy ", copy)

origin arr  [1 2 3 4 5]
in for-range  0 1
in for-range  1 2
in for-range  2 3
in for-range  3 4
in for-range  4 5
after loop, arr  [1 100 200 4 5]
after loop, copy  [1 2 3 4 5]

	var m = map[string]int {
		"shixin": 1,
		"hm" : 2,
		"laotang" : 3,
		"leizi" : 4,
	}

	counter := 0
	for i, v := range m {
//		if counter == 0 {
//			delete(m, "laotang")
//		}
		counter++
		fmt.Println("item ", i, v)
	}

	switch counter {
	case 4:
		fmt.Println("counter is 4")
		fallthrough	//仍然可以执行下一个 case
	case 77:
		fmt.Println("counter is 77")
	case 770:
		fmt.Println("counter is 770")
	default:
		fmt.Println("switch default")
	}

	var i interface{} = 13
	switch i.(type) {	//变量.(type)，判断类型
	case nil:
		fmt.Println("type is nil", i)
	case int:
		fmt.Println("type is int", i)
	case interface{}:
		fmt.Println("type is interface", i)
	}

type is int 13