八小时Golang学习笔记📒

from 【8小时转职Golang工程师(如果你想低成本学习Go语言)】

变量的声明

package main

import "fmt"

func main() {
	// 1. 使用 var 声明
	var a int
	fmt.Println(a)
	// 使用 b := 模式 (只能在函数体内使用)
	b :=1
	fmt.Println(b)
	
	// 3.指定默认值
	var c int = 10
	fmt.Println(c)
	
	// 4. var 推断模式 (全局变量通常)
	
	var d =4
	fmt.Println(d)
	
	// 5. 多个变量声明
	var aa ,bb,cc int 
	
	fmt.Println(aa,bb,cc)
	var (
		
    )
}

const 与 iota

package main

import "fmt"
const (
	Bj= 0
	Sh=1
)
const (
	City = iota // iota 默认为零
	Ah
	Js
	Sz
)

const (
	B = 1 << (10*iota)
	KB
	MB
	GB
)
// error code 错误码应用
const (
	UserAuthErrorCode = 20000+iota 
	UserPasswordErrorCode 
)
func main() {
	const length = 1
	fmt.Println(length)
}

Golang 中函数多返回值的三种模式

package main

func main() {

}

func HideName() (int, int) {
	return 1, 2
}

// HaveName 会初始化默认值
func HaveName() (a int, b int) {
	a = 1
	b = 2

	return
}

defer 语句调用顺序

函数结束前的执行的程序

栈模式 先进先出

package main

import "fmt"

func a() {
	fmt.Println(a)
}
func b()  {
    fmt.Println(b)
}
func c()  {
    fmt.Println(c)
}
func main() {

	defer a()
	defer b()
	defer c()
}

// c , b, a 

数组与动态数组

package main

import "fmt"

func main() {
	var myArray1 [10]int
	myArray2 := [10]int{1, 2, 3, 4}
	fmt.Println(myArray1)
	fmt.Println(myArray2)
}

slice

1. cap 容量(自动扩容)
2. len 长度
3. copy 复制

map 的三种声明定义方式

map 是并发不安全模式

package main

import "fmt"

func main() {
	//  声明是初始化 必须开辟空间 不然空指针
	var mp1 map[string]string

	fmt.Println(mp1) // nil
	
	// 开辟空间
	mp1 = make(map[string]string,10) //开辟初始 10个容量
	
	// make 直接生成
	mp2 := make(map[string]string)
	mp2["1"]="1"
	fmt.Println(mp2)
	
	// 初始赋值
	mp3 := map[string]string{
		"a":"1",
    }
	fmt.Println(mp3)
}

放射解析结构体标签

package main

import (
	"fmt"
	"reflect"
)

type Resume struct {
	Name string `info:"name"`
	Sex  string `info:"sex"`
}

func findTag(str interface{}) {
	t := reflect.TypeOf(str).Elem()
	for i := 0; i < t.NumField(); i++ {
		tagsString := t.Field(i).Tag.Get("info")
		fmt.Println(tagsString)
	}
}
func main() {
    var tags Resume
	findTag(tags)
}

channel的基本定义与使用

package main

import "fmt"

func main() {

	// 无缓冲管道
	c := make(chan int)
	go func() {
		defer fmt.Println("stop channel")
		// 写入通道
		c <- 666
	}()
	
	// 读取 阻塞
	num := <-c
	defer close(c)
	fmt.Println(num)
}

channel 有缓冲和无缓冲

package main

import (
	"fmt"
	"time"
)

func main() {
	c := make(chan int, 3)

	// 获取容量和长度
	fmt.Printf("%v %v", len(c), cap(c))
	go func() {
		for i := 0; i < 30; i++ {
			c <- i
			fmt.Printf("%d %d", len(c), cap(c))
		}
	}()
	time.Sleep(time.Second)
	
}