Go语言基础学习笔记

go语言基础

go基本语法

package main

import "fmt"

func main() {
	fmt.Println("hello Go!")
}

变量声明方式

package main

import "fmt"

// 声明全局变量
var g1 int = 100

func main() {
	//常用方法:自动推导
	e := 100
	fmt.Println("e=", e)
	fmt.Printf("type of e=%T\n", e)

	fmt.Println("g1=", g1)
}

const与iota

package main

import (
	"fmt"
)

// const 来定义枚举类型
// iota只能配合const使用
const (
	A = iota
	B
	C
)

func main() {
	//常量
	const length int = 10
	fmt.Println("length=", length)

	fmt.Println("A=", A)
	fmt.Println("B=", B)
	fmt.Println("C=", C)
}

image-20230219234103028

函数多返回值三种写法

package main

import "fmt"

func foo1(a string, b int) int {
	return 666
}

// 返回多个值,匿名的
func foo2(a string, b int) (int, int) {
	return 666, 777
}

// 返回多个值,有形参名称
func foo3(a string, b int) (c int, d int) {
	c = 100
	d = 200
	return
}

func main() {
	c := foo1("111", 222)
	fmt.Println("c=", c)
	ret1, ret2 := foo2("abc", 333)
	fmt.Println("ret1=", ret1, "ret2=", ret2)
	ret3, ret4 := foo3("abc", 333)
	fmt.Println("ret3=", ret3, "ret4=", ret4)
}

方法调用流程

image-20230220002102353

image-20230220002237497

import匿名及别名导包方式

image-20230220002756426

image-20230220002822431

指针速通

image-20230220095712133

image-20230220095747585

package main

import "fmt"

func swap(a *int, b *int) {
	var temp int
	temp = *a
	*a = *b
	*b = temp
}

func main() {
	a := 20
	b := 10
	swap(&a, &b)
	fmt.Println("a=", a, "b=", b)
}

defer语句执行顺序

package main

import "fmt"

func main() {
	defer fmt.Println("1")
	defer fmt.Println("2")
	fmt.Println("3")
	fmt.Println("4")
}

image-20230220101148793

return比defer先执行

动态数组

package main

import "fmt"

func changeArr(myArr []int) {
	myArr[0] = 100
}

func main() {
	myArr := []int{1, 2, 3, 4}
	for _, val := range myArr {
		fmt.Println("val=", val)
	}
	fmt.Println("=========")
	changeArr(myArr)
	for _, val := range myArr {
		fmt.Println("val=", val)
	}
}

image-20230220103443215

slice声明定义方式

package main

import "fmt"

func main() {
	slice1 := make([]int, 3)
	fmt.Printf("slice=%v\n", slice1)
}

slice切片追加, 深拷贝与截取

package main

import "fmt"

func main() {
	number:=make([]int,3)
	fmt.Printf("len=%d,cap=%d,slice=%v\n",len(number),cap(number),number)
	number=append(number, 1)
	fmt.Printf("len=%d,cap=%d,slice=%v\n",len(number),cap(number),number)
}

image-20230220111203407

package main

import "fmt"

func main() {
	s:=[]int{1,2,3}
	s2:=make([]int,3)
	copy(s2,s)
	fmt.Println(s2)
}

image-20230220111527688

截取和python语法类似

map定义方式

package main

import "fmt"

func main() {
	myMap:=make(map[int]string)
	myMap[1]="java"
	myMap[2]="c++"
	fmt.Println(myMap)
}

image-20230220123808106

map使用

package main

import "fmt"

func main() {
	cityMap := make(map[string]string)
	//添加
	cityMap["china"] = "beijing"
	cityMap["japan"] = "tokyo"
	//遍历
	for key, val := range cityMap {
		fmt.Println(key, val)
	}
	//删除
	delete(cityMap,"china")
	//修改
	cityMap["japan"]="sb"
	fmt.Println("==============")
	//遍历
	for key, val := range cityMap {
		fmt.Println(key, val)
	}
}

结构体基本定义

package main

import "fmt"
type book struct{
	title string
	auth string
}

func main() {
	var book1 book
	book1.title="golang"
	book1.auth="zhangsan"
	fmt.Printf("%v\n",book1)
}

image-20230220140410840

面向对象的表示与封装

package main

import "fmt"

// 如果类名大写,表示其他包也能够访问
type Hero struct {
	//属性名首字母大写,表示该属性可以对外访问
	Name  string
	Ad    int
	level int
}

func (this *Hero) show() {
	fmt.Println("Name=", this.Name)
	//...
}

func (this *Hero) getName() string {
	return this.Name
}

func (this *Hero) setName(newName string) {
	this.Name = newName
}

func main() {
	//创建一个对象
	hero := Hero{Name: "zhang3", Ad: 100, level: 1}
	hero.show()
	hero.setName("li4")
	hero.show()
}

image-20230220143102304

面向对象继承

package main

import "fmt"

type Human struct{
	name string
	sex string
}
func(this *Human)Eat(){
	fmt.Println("Human.Eat()....")
}
func(this *Human)Walk(){
	fmt.Println("Human.Walk()....")
}
type SuperMan struct{
	Human//继承
	level int
}

//重写父类方法Eat()
func(this *SuperMan)Eat(){
	fmt.Println("SuperMan.Eat()...")
}
//子类新方法
func(this *SuperMan)Fly(){
	fmt.Println("SuperMan.Fly()...")
}

func(this *SuperMan)Print(){
	fmt.Println("name=",this.name)
	//...
}


func main() {
	h:=Human{"zhang3","female"}
	h.Eat()

	//定义一个子类对象
	var s SuperMan
	s.name="li4"
	s.sex="male"
	s.level=88

	s.Walk()
	s.Eat()
	s.Fly()
	s.Print()
	
}

image-20230220145802909

面向对象多态

package main

import "fmt"

// 本质是一个指针
type Animal interface {
	Sleep()
	GetColor() string
	GetType() string
}

// 具体的类
type Cat struct {
	color string
}

func (this *Cat) Sleep() {
	fmt.Print("Cat is Sleep")
}

func (this *Cat) GetColor() string {
	return this.color
}

func (this *Cat) GetType() string {
	return "Cat"
}

func main() {
	var animal Animal
	animal = &Cat{"green"}
	animal.Sleep()
	fmt.Println("color=", animal.GetColor())
	fmt.Println("kind=", animal.GetType())
	//狗也类似
}

image-20230220152212401

空接口万能类型

package main

import "fmt"

func myFunc(arg interface{}){
	fmt.Println(arg)
}
type Book struct{
	auth string
}
func main() {
	book:=Book{"golang"}
	myFunc(book)
	myFunc(100)
	myFunc("abc")
}

image-20230220154345169

反射

package main

import (
	"fmt"
	"reflect"
)

func relectNum(arg interface{}){
	fmt.Println("type:",reflect.TypeOf(arg))
	fmt.Println("type:",reflect.ValueOf(arg))

}

func main() {
	var num float64=1.2344
	relectNum(num)
}

image-20230220161914253

go反射解析结构体标签tag

package main

import (
	"fmt"
	"reflect"
)

type resume struct {
	Name string `info:"name" doc:"我的名字"`
	Sex  string `info:"sex"`
}

func findTag(str interface{}) {
	t := reflect.TypeOf(str).Elem()
	for i := 0; i < t.NumField(); i++ {
		taginfo := t.Field(i).Tag.Get("info")
		tagdoc := t.Field(i).Tag.Get("doc")
		fmt.Println("info:", taginfo, "doc", tagdoc)
	}
}

func main() {
	var re resume
	findTag(&re)
}

image-20230220163749367

结构体标签在结构体中的应用

package main

import (
	"encoding/json"
	"fmt"
)

type Movie struct{
	Title string `json:"title"`
	Year int `json:"year"`
}

func main() {
	movie:=Movie{"喜剧之王",10}
	//结构体->json
	jsonStr,err:=json.Marshal(movie)
	if err!=nil{
		fmt.Println(err)
		return
	}
	fmt.Printf("jsonStr=%s\n",jsonStr)

	//jsonStr->结构体
	MyMovie:=Movie{}
	err=json.Unmarshal(jsonStr,&MyMovie)
	if err!=nil{
		fmt.Println(err)
		return
	}
	fmt.Println(MyMovie)
}

image-20230220170342199

创建goroutine

package main

import (
	"fmt"
	"time"
)

func newTask(){
	i:=0
	for{
		i++
		fmt.Printf("new Goroutine:i=%d\n",i)
		time.Sleep(1*time.Second)
	}
}

func main() {
	//创建一个go程,去执行newTask()流程
	go newTask()
	i:=0
	for{
		i++
		fmt.Printf("main Goroutine:i=%d\n",i)
		time.Sleep(1*time.Second)
	}
}

image-20230220195440316

package main

import (
	"fmt"
	"runtime"
	"time"
)

func main() {
	go func ()  {
		defer fmt.Println("a.defer")
		func(){
			defer fmt.Println("b.defer")
			//退出当前goroutine
			runtime.Goexit()
			fmt.Println("b")
		}()
		fmt.Println("a")
	}()
	for{
		time.Sleep(1*time.Second)
	}
}

image-20230220200115537

channel基本定义与使用

package main

import "fmt"

func main() {
	//定义一个channel
	c := make(chan int)
	go func() {
		defer fmt.Println("go程结束")
		fmt.Println("go程正在运行")
		c <- 666
	}()
	num := <-c
	fmt.Println("num=", num)
	fmt.Println("main go程结束")
}

image-20230220202512747

channel缓冲问题

package main

import (
	"fmt"
	"time"
)

func main() {
	c := make(chan int, 3)
	fmt.Println("len(c=)", len(c), "cap(c)=", cap(c))

	go func() {
		defer fmt.Println("子go程结束")
		for i := 0; i < 4; i++ {
			c <- i
			fmt.Println("子go程正在运行,发送的元素=", i, "len(c)=", len(c), "cap(c)=", cap(c))
		}
	}()
	time.Sleep(2 * time.Second)

	for i := 0; i < 4; i++ {
		num := <-c
		fmt.Println("num=", num)
	}
	fmt.Println("main 结束")
}
image-20230220211434024

channel关闭的特点

package main

import "fmt"

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

	go func() {
		for i := 0; i < 5; i++ {
			c <- i
		}
		close(c)
	}()
	for {
		if data, ok := <-c; ok {
			fmt.Println(data)
		} else {
			break
		}
	}
	fmt.Println("main finished...")
}

image-20230220223733164

channel与range

package main

import "fmt"

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

	go func() {
		for i := 0; i < 5; i++ {
			c <- i
		}
		close(c)
	}()

	for data:=range c{
		fmt.Println(data)
	}
	fmt.Println("main finished...")
}

image-20230220224117702

channel与select

package main

import "fmt"

func fib(c, quit chan int) {
	x, y := 1, 1
	for {
		select {
		case c <- x:
			x = y
			y = x + y
		case <-quit:
			fmt.Println("quit")
			return
		}
	}
}

func main() {
	c := make(chan int)
	quit := make(chan int)

	go func() {
		for i := 0; i < 6; i++ {
			fmt.Println(<-c)
		}
		quit <- 0
	}()

	fib(c, quit)
}

image-20230220230041643

posted @ 2023-02-20 23:09  weiqi1009  阅读(39)  评论(0)    收藏  举报