了解：https://www.runoob.com/go/go-concurrent.html

golang学习方向

区块链研发工程师

go服务器=>（特点：数据处理，处理大并发）/游戏软件工程师

golang分布式/云计算软件工程师（盛大云、cdn、京东）

统称golang核心编程

应用领域

区块链应用

后台服务器应用

云计算/云服务后台应用

学习方法

go语言吉祥动物：金花鼠

如何深入学习一个新技术或知识点

什么是程序

why is go语言

go的诞生

go语言特点

go语言开发工具

配置Go环境

$env:GO111MODULE = "on"
$env:GOPROXY = "http://goproxy.cn"

golang标识符、关键字、命名规则

标识符的组成

1.标识符由数字、字母和下划线( _)组成。123 abc _

2.只能以字母和下划线(_)开头。abc123 _sysVar 123abc

标识符区分大小写。 name Name NAME

// 标识符命名
package main
import "fmt"
func main() {// 正确写法var name stringvar age intvar _sys int// 错误写法var 1name stringvar &age intvar !email
}
// 语言关键字 举例
func main() {if  condition {}append()
}// 命名规范

golang变量

变量是计算机语言中能储存计算结果或能表示值的抽象概念不同的变量保存的数据类型可能会不一样

// 变量声明的语法
varidentifier type
var: 声明变量关键字
identifier：变量名
type: 变量类型
注意：变量一旦声明必须使用
package main
func main(){// 声明赋值 初始化var name string = "tom"var age int = 20 // 声明赋值类型推断自动判断类型 初始化var name = "tom"var age = 20 // 第一种var name stringvar age intvar m bool// 第二种var (name stringage intm bool)// 初始化多个变量及赋值var name,age,b = "tom",20,true//短变量声明 := 只能用在函数内部name := "tom"age := 10// 匿名变量 省略声明 函数调用的方式使用func a()(string, inta) {return "tom", 20}使用 name, age = a()
}

golang语言常量

常量，就是在程序编译阶段就确定下来的殖，而程序在运行时则无法改变该值。在Go程序中，常量可以是数值类型(包括整型、浮点型和复数类型) 、布尔类型、字符串类型等。

const constantName[type] = value
const PI float64 = 3.14
const PI2 = 3.145 // 可以省略
const (width = 100height = 200
)
const i,j = 1,2
const a,b,c = 1,2,"foo"

iota 类似于 i++

const (
a = iota
a1 = iota
_ // 跳过的意思 不过还是要+1
a2 = iota
)

golang数据类型

golang基于架构的类型，例如：int、uint、uintptr
输出类型
fmt.Printf("%T\n",name) // string 类型
数组类型
a := [2]int{1,2}

golang布尔类型

var a:bool = true
var b:bool = false
// 用法
// 注意 不能用0和非0表示bool类型
if age >= 18 {fmt/Println("ni")
}

golang数字类型MP4

func main {var i8 int8var i16 int16var ui8 uint8}

golang字符串

var html string = <html></html>
var str string = "1231223"
var dstr string = `
1
2
3
`
var pin = html + str
strings.Join([]string{html,str},",") // 字符串连接
var buffer bytes.Buffer // 缓存区
buffer.WriterString("tom")
// 切片
a := 2
b := 5
s[a:b] // 从a到b-1区间截取
s[:b] // 从0到b-1区间截取
s[a:] // 从0到最后区间截取
len(s) // 获取字符串长度
strings.Split(s, "") // 数组截取

golang格式化输出

fmt.Pringf()
// 结构图题
type WebSite struct {Name string
}
func main() {site := WebSite{Name:"docke360"}
}

golang运算符

+
-
*
/
++
--
%

golang中的流程控制

golang中的if语句

a := 1
b :=2
if a>b {fmt.Println(a)
} else {fmt.Println(b)
}b :=2
if a := 1; a>b {fmt.Println(a)
} else {fmt.Println(b)
}

golang中的嵌套if语句

golang中switch的用法

golang中for循环

golang中for range循环

// var a = [...]int{1,2,3}// for i,v := range a {//     fmt.Printf("%v:%v ",i,v)// }// for _,v := range a {//     fmt.Printf("%v,\n",v)// }// m := make(map[string]string, 0)// m["name"] = "lisi"// m["age"] = "23"// for key, value := range m {//     fmt.Printf("%v: %v\n",key, value)// }m := [2]string{"1","2"} for _, v := range m {fmt.Printf("%v: %v\n", v)}

golang中goto关键字

golang中数组

golang中访问数组元素

golang中切片

var names []string
var numbers []int
var s = make([]int, 2)
var s1 = []int{1,2,3}

golang中切片初始化

s := []int{1,2,3}
arr := [...]int{1,2,3}
s1 :=arr[:]

golang中切片的遍历

var s = [...]int{1,2,3}l := len(s)// arr := [...]int{1,2,3}// s1 :=arr[:]for _, v := range s {if v < l {fmt.Printf("%v\n", v)} else {fmt.Printf("结束执行")}}

golang中切片的添加删除

// add
var s1 = []int{}
s1 = append(s1,100)
s1 = append(s1,200)
s1 = append(s1,300)
fmt.Printf("%v", s1)
// delete
s1 = append(s1,s1[:2]...)
fmt.Printf("%v", s1)
s1 = append(s1,s1[2:]...)
// s1 = append(a[:index],a[index+1:]...)
fmt.Printf("%v", s1)
//update
s1[2] = 600
fmt.Printf("%v", s1)
// query
for _, v := range s1 {if v > 300 {fmt.Printf("key : %v\n" , v)}
}
// copy
var s2 = make([]int, 8)
copy(s2,s1)
// copy 不会修改原来数据
fmt.Printf("\n%v\n" , s2)

golang中map

//map
// var m1 map[string]string
// m1 = make(map[string]string)
// fmt.Printf("m1: %v\n" , m1)
// fmt.Printf("m1: %T\n" , m1)
var m1 = map[string]string{"name": "zhangshan", "age": "23", "email": "2732556589@qq.com"}
fmt.Printf("m1: %v\n" , m1)
m2 := make(map[string]string)
m2["name"] = "YB"
m2["age"] = "55"
m2["email"] = "2732556589@qq.com"
fmt.Printf("m2: %v\n" , m2)
var m3 = map[string]string{"name": "zhangshan", "age": "23", "email": "2732556589@qq.com"}
var key = "name"
var value, ok = m3[key]
if ok {fmt.Printf("m3: %v\n" , value)
}

golang中map遍历

// 遍历
m1 := map[string]string{"name": "zhangshan", "age": "23", "email": "2732556589@qq.com"}
for k, v := range m1 {fmt.Printf("%v: %v\n",k , v)
}

golang中函数

func main() {var sums = sum(1, 2)fmt.Printf("sums:%v\n", sums)comps := comp(1,2)fmt.Printf("comps:%v\n", comps)
}
// 函数 求和
func sum(a int, b int)(ret int)  {ret = a+breturn ret
}
// 最大值
func comp(a int, b int)(max int) {if a > b {max = a} else {max = b}return max
}

golang中函数返回值

func main() {text1() sum()name, age := text3()fmt.Printf("%v", name)fmt.Printf("%v", age)
}
func text1() {fmt.Printf("我没参数也没有返回值")
}
func  sum(a int, b int) (int)  {return a + b
}
func text3()(name string, age int)  {name = "zhangshan"age = 23return name, age
}

golang中函数参数

sums(1,2)
x := 300
f1(x)
// 形参
func sums(a int, b int) int {return a + b
}
// copy
func f1(a int)  {a = 100
}

golang中函数类型和函数变量

type f1 func(int, int) int
var ff f1
ff = sum
ff(1,2)
ff = max
r := ff(1,2)
fmt.Printf("%v", r)
func sum(a int, b int) int  {return a + b
}
func max(a int, b int) int  {if a>b {return a} else {return b}
}

golang中高阶函数

test("tom", say)
ff := cal("+")
r := ff(1,2)
fmt.Printf("%v", r)
// 高阶函数
func say(name string)  {fmt.Printf("%v", name)
}func test(name string, f func(string)) {f(name)
}func add(a int, b int) int  {return a + b
}
func sub(a int, b int) int  {return a - b
}
func cal(operator string)func(int, int) int{switch operator {case "+":return addcase "-":    return subdefault:return nil}
}

golang中匿名函数

max := func (a int, b int) int  {if a>b {return a} else {return b}
}
r := max(1,2)fmt.Printf("%v", r)
//
r := func (a int, b int) int  {if a>b {return a} else {return b}
}(1,2)
fmt.Printf("%v", r)

golang中闭包

f := add()
r := f(10)
fmt.Printf("%v\n", r)
r = f(20)
fmt.Printf("%v\n", r)
r = f(30)
fmt.Printf("%v\n", r)
// 闭包
func add()func(y int) int  {var x intreturn func(y int) int {x += yreturn x}
}

golang中递归

func a(n int) int {if n == 1 {return 1} else {return n* a(n-1)}
}
// 计算公式
f(n) = f(n-1)+f(n-2) 且f(2)=f(1)=1

golang中defer语句

// 默认顺序执行 加上defer 会延迟执行 //先定义的后执行
fmt.Printf("start....")
defer fmt.Printf("1....")
fmt.Printf("end....")

golang中init函数

// 允许调用多个init 顺序执行
func init() {
// 注意 init函数没有返回值 不允许被调用
}
func init() {
// 注意 init函数没有返回值 不允许被调用
}
func main() {}

golang中指针

golang中指向数组的指针

//指针
var ip *int
fmt.Printf("ip:%v\n",ip)
fmt.Printf("ip:%T\n",ip)
var i int = 100
ip = &i
fmt.Printf("ip:%v\n",ip)
fmt.Printf("ip:%v\n",*ip)
// 数组指针
a := [3]int{1,2,3}
var pro [3]*int
for i := 0; i<len(a); i++ {pro[i] = &a[i]
}
fmt.Printf("pro:%v\n",pro)
for i := 0; i<len(pro); i++ {fmt.Printf("pro:%v\n",*pro[i])
}

golang中类型定义和类型别名

type myInt int
var i myInt
i = 100
fmt.Printf("i:%v\n",i)
fmt.Printf("i:%T\n",i)

golang中结构体

type strAll struct {id, age intname,email stringchecked bool
}
var tom strAll
tom.id = 1
fmt.Printf("i:%v\n : %T",tom, tom)

golang中结构体初始化

type strAll struct {id, age intname,email stringchecked bool
}
var tom strAlltom = strAll{id: 101,age: 4,name: "tom",email: "2732556589@qq.com",checked: true,
}
fmt.Printf("i:%v\n : %T",tom, tom)

golang中结构体指针

type strAll struct {id, age intname,email stringchecked bool
}
tom := strAll{id: 101,age: 4,name: "tom",email: "2732556589@qq.com",checked: true,
}
var p_strAll *strAll
p_strAll = &tom
fmt.Printf("p_strAll:%v\n : %T",*p_strAll, p_strAll)
// new写法
type strAll struct {id, age intname,email stringchecked bool
}
var tom = new(strAll)
tom.name = "tom"
fmt.Printf("p_strAll:%v\n : %T",*tom, tom)

golang中结构体作为函数参数

golang中结构体的嵌套

type Dog struct {name string
}
type Person struct {dog Dogname string
}
dog := Dog {name: "zzahf",
}
per := Person{dog: dog,name: "zhang",
}
fmt.Println("%v",dog)
fmt.Println("%v",per)

golang中方法

golang中方法接收者类型

golang中接口

// 接口
c := Computer{name: "联想",
}
c.read()
c.write()d := Mobile{model: "老刘666",
}
d.write()
d.read()
// 接口
type USB interface {read()write()
}type Computer struct {name string
}type Mobile struct {model string
}func (c Computer) read()  {// c.name.Printf()fmt.Println("c.name: %v\n",c.name)fmt.Println("read...")
}func (c Computer) write()  {fmt.Println("c.name: %v\n",c.name)fmt.Println("write...")
}func (c Mobile) read()  {fmt.Println("c.name: %v\n",c.model)fmt.Println("read...")
}func (c Mobile) write()  {fmt.Println("c.name: %v\n",c.model)fmt.Println("write...")
}

golang中接口值类型接收者和指针类型接收者

// 方法接收者
e := &Dog{name: "peiqi",
}
s := e.eat("火鸡")
fmt.Println("%v\n", s)
// 方法接收者
type Pet interface {eat(string) string
}type Dog struct {name string
}// func (dog Dog) eat(name string) string {
//     dog.name = "huahua..."
//     fmt.Println("%v\n", name)
//     return "吃的很多"
// }
// 指针类型
func (dog *Dog) eat(name string) string {dog.name = "huahua..."fmt.Println("%v\n", name)return "吃的很多"
}

golang中接口和类型的关系

var m = Mobile{}
m.playMusic()
m.playVideo()var e = Dog{}
var f = Cat{}
e.eat()
f.eat()
type Player interface {playMusic()
}type Video interface {playVideo()
}type Mobile struct {}
type Pet interface {eat()
}
type Dog struct {}
type Cat struct {}
func (m Mobile) playMusic() {fmt.Println("playMusic")
}
func (m Mobile) playVideo() {fmt.Println("playVideo")
}
func (dog Dog) eat() {fmt.Println("dog")
}
func (Cat Cat) eat() {fmt.Println("Cat")
}

golang中接口嵌套

var fl FlyFish
fl = Fish{}
fl.fly()
fl.swim()
// 接口嵌套
type Flyer interface {fly()
}
type Swimmer interface {swim()
}
// 接口的组合
type FlyFish interface {FlyerSwimmer
}
type Fish struct {}func (fish Fish) fly() {fmt.Println("fly")
}func (swim Fish) swim() {fmt.Println("swim")
}

golang中接口实现ocp设计原则

//ocp设计
dog:=Dog{}
cat:=Cat{}
person:=Person{}
person.care(dog)
person.care(cat)type Pet interface {eat()sleep()
}type Dog struct {}
type Cat struct {}func (dog Dog) eat() {fmt.Println("dog eat")
}func (dog Dog) sleep() {fmt.Println("dog sleep")
}func (cat Cat) eat() {fmt.Println("cat eat")
}func (cat Cat) sleep() {fmt.Println("cat sleep")
}type Person struct {}// pet 即可以传递Dog也可以传递Cat 向上类型转换
func (person Person) care(pet Pet) {pet.eat()pet.sleep()
}

golang中使用oop思想的实现和方法

// oop 属性和方法
per:= Person{name: "tom",age: 23,
}
per.eat()
per.sleep()
per.work()
// oop 属性和方法
type Person struct {name stringage int
}
func (per Person) eat()  {fmt.Println("eat")
}
func (per Person) sleep()  {fmt.Println("sleep")
}func (per Person) work()  {fmt.Println("work")
}

golang中继承

// 继承
dog := Dog{a: Animal{name: "huahua", age: 2,},color:"黑色",
}
dog.a.sleep()
dog.a.eat()
fmt.Println("%v\n",dog.color)
// fmt.Println("%v\n",dog.bbb)
cat:= Cat{Animal{name: "huahua", age: 2},"6666",
}
cat.eat()
cat.sleep()type Animal struct {name stringage int
}func (a Animal) eat()  {fmt.Println("a eat")
}
func (a Animal) sleep()  {fmt.Println("sleep")
}
type Dog struct {a Animal // 可以理解为继承color string
}
type Cat struct {a Animalbbb string
}

golang中构造函数

// 构造方法
per,err := NewPerson("tom", 20)
if err == nil {fmt.Println("%v",per)
} else {fmt.Println("%v",err)
}type Person struct {name stringage int
}func NewPerson(name string, age int) (*Person, error)  {if name == "" {return nil, fmt.Errorf("name不能为空")}if age < 0 {return nil, fmt.Errorf("age不小于0")}return &Person{name: "tom",age:20},nil
}

golang中包

golang中包管理工具go mod

golang中并发编程之协程

go showMsg("java") //go 启动一个携程 1
go showMsg("golang") //2
fmt.Println("mainend...") //主函数退出 程序就结束了func showMsg(msg string)  {for i:=0;i<5;i++ {fmt.Println("msg:%v\n",msg)}time.Sleep(time.Millisecond * 100)
}

golang中并发编程之通道channel

// 创建int类型通道，只能传入int类型值
var values = make(chan int)func send()  {// 从通道接收值rand.Seed(time.Now().UnixNano())value := rand.Intn(10)fmt.Println("send:", value)time.Sleep(time.Second * 5)values <-value
}defer close(values)
go send()
fmt.Println("wait...")
value := values
fmt.Println("receive:", value)
fmt.Println("end...")

golang中并发编程之WaitGroup实现同步

var wp sync.WaitGroupfor i:=0; i<5; i++ {go showMsg(i)wp.Add(1)
}
wp.Wait()
// 主线程fmt.Println("end...")func showMsg(i int)  {defer wp.Done() // 等待fmt.Println("i: $v\n",i)
}

golang中并发编程之runtime包

go show("java")
for i := 0; i < 2; i++ {runtime.Gosched() // 我有权力执行任务了，让给你（其他字写成过来执行）fmt.Println("golang")
}
fmt.Println("end...")func show(msg string)  {for i := 0; i < 2; i++ {fmt.Println("msg:%v\n",msg)}
}
-----------------------------------
go show()
time.Sleep(time.Second)func show()  {for i := 0; i < 10; i++ {fmt.Println("i:",i)if i >= 5 {runtime.Goexit()}}
}
------------------------
fmt.Printf("runtime.NumCPU():%v\n",runtime.NumCPU())
runtime.GOMAXPROCS(2)
go a()
go b()
time.Sleep(time.Second)
func a()  {for i := 0; i < 10; i++ {fmt.Println("a:",i)}
}
func b()  {for i := 0; i < 10; i++ {fmt.Println("b:",i)}
}

golang中并发编程之Mutext互斥锁实现同步

var wp sync.WaitGroup
lock sync.Mutex
for i := 0; i < 100; i++ {wp.Add(1)go add()wp.Add(1)go sub()
}
wp.Wait()
fmt.Println("end i:",i)
var i int = 100
func add()  {defer wp.Done()lock.lock()i += 1fmt.Printf("i++:%v\n", i)time.Sleep(time.Millisecond * 10)lock.Unlock()
}func sub()  {defer wp.Done()lock.lock()i-=1fmt.Printf("i--:%v\n", i)time.Sleep(time.Millisecond * 2)lock.Unlock()
}

golang中并发编程之channel的遍历

var c = make(chan int)
go func ()  {for i := 0; i < 2; i++ {c<-i}defer close(c)
}()
for i := 0; i < 3; i++ {r:=<-cfmt.Println("end r:",r)
}

golang中并发编程之select

var chanInt = make(chan int, 0)var chanStr = make(chan string, 0)go func ()  {chanInt <- 100chanStr <- "hello"defer close(chanInt)defer close(chanStr)
}()
for{select {case r:= <- chanInt:fmt.Println("chanInt r:",r)case r:= <- chanStr:fmt.Println("chanStr r:",r)default:fmt.Println("default")}time.Sleep(time.Second)
}

golang中并发编程之Timer

// timer := time.NewTimer(time.Second * 2)
// fmt.Printf("time.now(): %v\n", time.Now())
// t1 := <- timer.C // 阻塞的直到时间到了
// fmt.Printf("t1: %v\n", t1)
// timer := time.NewTimer(time.Second * 2)
// fmt.Printf("time.now(): %v\n", time.Now())
// <-timer.C
// fmt.Printf("t1: %v\n", time.Now())
// time.Sleep(time.Second * 2)
// <-timer.After(time.Second * 2)
timer := time.NewTimer(time.Second)
go func ()  {<-timer.Cfmt.Printf("time.now(): %v\n", time.Now())
}()
// time.sleep(time.Second*3)
s:= timer.Stop()
if s{fmt.Println("main end...")
}

golang中并发编程之Ticker

ticker := time.NewTicker(time.Second)
chanInt := make(chan int)
go func ()  {for _= range ticker.C {select {case chanInt <-1:case chanInt <-2:case chanInt <-3:}}}()
sum := 0
for v := range chanInt {fmt.Println("收到v:",v)sum += vif sum >= 10 {break}
}

golang中并发编程之原子变量的引入

var Lock sync.Mutex
func main() {for i := 0; i < 100; i++ {go add()go sub()}time.Sleep(time.Second * 2)fmt.Println("i:", i)
}
var i = 100
func add()  {Lock.lock()i++Lock.Unlock()
}
func sub()  {Lock.lock()i--Lock.Unlock()
}
--------
import "sync/atomic"
var  i int32 = 100func add()  {atomic.AddInt32(&i,1)
}func sub()  {atomic.AddInt32(&i,-1)
}func main()  {for i := 0; i < 100; i++ {go add()go sub()}time.Sleep(time.Second * 2)fmt.Println("i:", i)
}

golang中并发编程之原子操作详解

var i int32 = 100
atomic.AddInt32(&i,1)
fmt.Println("i: %v\n",i)
atomic.AddInt32(&i,-1)
fmt.Println("i: %v\n",i)
var j int64 = 200
atomic.AddInt64(&j,1)
fmt.Println("j: %v\n",j)
------------
var i int32 = 100
atomic.LoadInt32(&i) // 读
fmt.Println("i: %v\n",i)
atomic.StoreInt32(&i,200) // 写
fmt.Println("i: %v\n",i)
-------
var i int32 = 100
b := atomic.CompareAndSwapInt32(&i, 100, 200) // 修改
fmt.Printf("b:%v\n",b)
fmt.Printf("i:%v\n",i)

golang中标准库os模块-文件目录相关

// 创建单个目录
err := os.Mkdir("a", os.ModePerm)
if err != nil {fmt.Printf("err:%v\n", err)
}
// 创建多个层级目录
err2 := os.MkdirAll("aa/bb/cc", os.ModePerm)
if err2 != nil {fmt.Printf("err:%v\n", err2)
}
// 删除目录或者文件
err := os.Remove("a.text")
if err != nil {fmt.Printf("err:%v\n", err)
}
err := os.RemoveAll("aa")
if err != nil {fmt.Printf("err:%v\n", err)
}
// 获得工作目录
dir,_ := os.Getwd()
fmt.Printf("dir:%v\n", dir)
// 修改工作根目录
os.Chdir("e:/")
dir,_ = os.Getwd()
fmt.Printf("dir:%v\n", dir)
// 获得临时目录
s := os.TempDir()
fmt.Printf("s:%v\n", s)
// 重命名
err := os.Rename("test.txt", "test2.txt")
if err !=nil {fmt.Printf("err: %v\n", err)
}
// 文件读取
b, _ := os.ReadFile("test2.txt")
fmt.Printf("b: %v\n", string(b[:]))
// 文件书写
err := os.WriteFile("text2.txt", []byte("hello"), os.ModePerm)
if err != nil {fmt.Printf("err: %v\n", err)
}

golang中标准库os模块-File文件读操作

// 打开 和关闭文件
f, err := os.Open("a.txt")
if err == nil {fmt.Printf("为查询错误\n", err)return
}
fmt.Printf("f.Name():%v\n", f.Name())
f.Close()
OpenFile 创建并读取
f, err := os.OpenFile("a1.txt", os.O_RDWR | os.O_CREATE, 755)
if     err != nil {fmt.Printf("err:%v\n", err)
} else {fmt.Printf("f.Name():%v\n", f.Name())f.Close()
}
// read
// 循环读取
f,_ := os.Open("a.txt")
for {buf := make([]byte, 10)n,err := f.Read(buf)if err == io.EOF {break}fmt.Printf("n:%v\n", n)fmt.Printf("string(buf):%v\n", string(buf))
}
f.Close()
------
f,_ := os.Open("a.txt")
buf := make([]byte, 4)
n, _ := f.ReadAt(buf,3)
fmt.Printf("n:%v\n", n)
fmt.Printf("string(buf):%v\n", string(buf))
// 目录读取
// de, _ := os.ReadDir("a/")
// for _, v := range de {
//     fmt.Printf("v.IsDir():%v\n", v.IsDir())
//     fmt.Printf("v.Name():%v\n", v.Name())
// }
// 从指定位置读取
f,_ := os.Open("a.txt")
f.Seek(3,0)
buf := make([]byte, 4)
n, _ := f.ReadAt(buf,3)
fmt.Printf("n:%v\n", n)
fmt.Printf("string(buf):%v\n", string(buf))

golang中标准库os模块-File文件写操作

// 文件写入操作
f,_ := os.OpenFile("a.txt",os.O_RDWR|os.O_APPEND,0755)
f.Write([]byte("hello word"))
f.Close()
-------
// 从某个位置开始替换
f,_ := os.OpenFile("a.txt",os.O_RDWR,0755)
f.WriteAt([]byte("hello word"), 5)
f.Close()

golang中标准库os包进程相关操作

// 获得正在运行的进程id

golang中标准库os包和环境相关的方法

fmt.Printf("os.Environ():%v\n", os.Envion())
// 获得某个环境变量
s := os.getenv("GOPATH")
fmt.Printf("s:%v\n", s)
fmt.Printf("s:%v\n", os.getenv('JAVA_HOME'))
------
s,b := os.LockupEnv("GOPATH")
if b {fmt.Printf("s:%v\n", s)
}
---
// 设置环境变量os.Setenv("GOPATH")os.Setenv("BURROW", "/USER/GOPHER")fmt.Printf(os.ExpandEnv("$NAME lives in ${BURROW}"))
// 清除所有环境变量
os.Clearenv()

golang中标准库io包input output

r := strings.NewReader("hello word")written, err := io.Copy(os.Stdout, r)
if err != nil {log.Fatal(err)
}

golang中标准库ioutil包

// r:= strings.NewReader("hellow world")
f, _ := os.Open("a.txt") // File实现了reader
b, err := ioutil.ReadAll(r)
if err != nil {fmt.Printf("err: %v\n", err)
}
fmt.Printf("string(b): %v\n", string(b))
------------------------------------
// 读目录
fi, _ := ioutil.ReadDir(".")
for _, v := range fi {fmt.Printf("v.name():%v\n", v.Name())
}
// 读文件
fi, _ := ioutil.ReadFile("a.txt")
fmt.Printf("string(fi):%v\n", string(fi))
// 写文件ioutil.WriteFile("a.txt",[]byte("hello word"),0664)
-----
// 创建临时文件
content := []byte("temporary files content")
tmpfile, err := ioutil.TempFile("","example")
if err != nil {log.Fatal(err)
}
fmt.Printf("tmpfile:%v\n", tmpfile)
defer os.Remove(tmpfile.Name())
if _, err := tmpfile.Write(content); err != nil {log.Fatal(err)
}
if err := tmpfile.Close(); err != nil {log.Fatal(err)
}

golang中标准库bufio读相关操作

f, _ := os.Open("a.txt")
defer f.Close()
r2 := bufio.NewReader(f)s,_ := r2.ReadString('\n')
fmt.Printf("s:%v\n", s)
----------

golang中标准库bufio写相关操作

f, _ := os.OpenFile("a.txt",os.O_RDWR, 0777)
defer f.Close()
w:= bufio.NewWriter(f)
w.WriteString("hello word123")
w.Flush()

golang中标准库bufio Scanner相关方法

s:= strings.NewReader("ABC DEF GHI JKL")
bs := bufio.NewScanner(s)bs.Split(bufio.ScanWords)
for bs.Scan() {fmt.Printf("%v\n", bs.Text())
}
--------------------
s:= strings.NewReader("ABC DEF GHI JKL")
bs := bufio.NewScanner(s)bs.Split(bufio.ScanRunes)
for bs.Scan() {fmt.Printf("%v\n", bs.Text())
}

golang中标准库log

log.Print("my log")
log.Printf("my log%d",123)
log.Println(1231243)
log.Panic("my panic")
log.Fatal("my Fatal")

golang中标准库builtin

s:=[]int{1,2,3}
i := append(s,100)
fmt.Printf("i:%v\n", i)
s2:=[]int{4,5,6}
i2 := append(s2,s...)
fmt.Printf("i2:%v\n", i2)
---------------
// s := "hellow word"
s:=[]int{1,2,3}
fmt.Printf("", len(s))
---------
name:= "“tom"
age := 20
print(name, age)
println(name, age)
---------
defer fmt.Println("panic 后 我还会执行")
panic("完了")
-----------------
b := new(bool)
fmt.Printf("b: %T\n", b)
fmt.Printf("b: %v\n", *b)
i := new(int)
fmt.Printf("b: %T\n", i)
fmt.Printf("b: %v\n", *i)
s := new(string)
fmt.Printf("b: %T\n", s)
fmt.Printf("b: %v\n", *s)
--------------
var p *[]int = new([]int)
fmt.Println("p: %v\n",p)
v := make([]int, 100)
fmt.Println("v : %v\n",v)
---------

golang中标准库bytes常用函数

var i int = 100
var b byte = 10
b = byte(i)
i = int(b)
var s string = "hellowword"
b1 := []byte{1,2,3}
s = string(b1)
b1 = []byte(s)
-------------
Contains// 包含 返回bool
s:= "duoke360.com"
b:=[]byte(s)
b1 := []byte("duoke360")
b2 := []byte("Duoke360")
b3 := bytes.Contains(b,b1)
fmt.Printf("b3%v\n", b3)
b3 = bytes.Contains(b,b2)
fmt.Printf("b3%v\n", b3)
---------
Count// 重复次数
s := []byte("hell00000000oo")
sp1 := []byte("h")
sp2 := []byte("l")
sp3 := []byte("o")
fmt.Println(bytes.Count(s, sp1))
fmt.Println(bytes.Count(s, sp2))
fmt.Println(bytes.Count(s, sp3))
-----------
// repeat 重复输出
b:= []byte("hi")
fmt.Println(string(bytes.Repeat(b,1)))
fmt.Println(string(bytes.Repeat(b,3)))
---------
替换 Replace
s:= []byte("hello,word")
old := []byte("o")
news := []byte("ee")
fmt.Println(string(bytes.Replace(s,old, news,0)))
fmt.Println(string(bytes.Replace(s,old, news,1)))
fmt.Println(string(bytes.Replace(s,old, news,2)))
fmt.Println(string(bytes.Replace(s,old, news,-1)))
-----------
字节长度转换Runes
s:= []byte("你好世界")
r := bytes.Runes(s)
fmt.Println("转换前字符长度", len(s))
fmt.Println("转换后字符长度", len(r))
-----------
join切片链接
s2 := [][]byte{[]byte("你好"),[]byte("世界")}
sp := []byte(",")
fmt.Println(string(bytes.Join(s2, sp)))

golang中标准库bytes Reader类型

data:= "123456789"
// 通过byte创建reader
re := bytes.NewReader([]byte(data))
// 返回未读取部分的长度
fmt.Println("re len :",re.Len())
// 返回底层数据长度
fmt.Println("re len :",re.Size())
fmt.Println("------")
buf := make([]byte, 2)
for {// 读取数据n, err := re.Read(buf)if err != nil {break}fmt.Println(string(buf[:n]))
}
fmt.Println("------")// 设置偏移量， 因为上面的操作已经修复了读取位置等信息
re.Seek(0,0)
for {// 一个字节一个字节的读b, err := re.ReadByte()if err != nil {break}fmt.Println(string(b))
}
fmt.Println("------")
re.Seek(0,0)
off := int64(0)
for {// 指定偏移量n, err := re.ReadAt(buf,off)if err != nil {break}off += int64(n)fmt.Println(off, string(buf[:n]))
}

golang中标准库bytes Buffer类型

var b bytes.Buffer
fmt.Printf("b: %v\n", b)
var b1 = bytes.NewBufferString("heool")
fmt.Printf("b1: %v\n", b1)
var b2 = bytes.NewBuffer([]byte("hello"))
fmt.Printf("b2: %v\n", b2)
------
var b bytes.Buffer
n,_ := b.WriteString("hello")
fmt.Printf("b: %v\n",b.Bytes()[0:n])
fmt.Printf("b: %v\n",string(b.Bytes()[0:n]))
fmt.Printf("n: %v\n", n)
---------
var b = bytes.NewBufferString("heool")
b1 := make([]byte, 2)
for{n, err := b.Read(b1)if err == io.EOF {break}fmt.Printf("n: %v\n",n)fmt.Printf("b1: %v\n",string(b1[0:n]))
}

golang中标准库errors

errors.New("错误信息")
// 自定义错误
type MyError struct {when time.Timewhat string
}

golang中标准库sort包

s := [] int{1,4,2,6,8,3,4,6,1}
sort.Ints(s)
fmt.Printf("s: %v\n",s)

golang中标准库time

golang中标准库json

golang中标准库xml

type Person struct {XMLName xml.Name `xml: "person"`Name string `xml: "name"`Age int `xml: "age"`Email string `xml: "email"`
}
person := Person {Name: "tom",Age: 20,Email:"2732556589@qq.com",
}
b, _ := xml.MarshalIndent(person, " ", " ")
fmt.Printf("%v\n", string(b))
-------------
b:= `<Person><Name>tom</Name><Age>20</Age><Email>2732556589@qq.com</Email></Person>`
s := []byte(b)
var per Person
xml.Unmarshal(s, &per)
fmt.Printf("%v\n", per)
----------
b,_:= ioutil.ReadFile("a.xml")
var per Person
xml.Unmarshal(b, &per)
fmt.Printf("%v\n", per)
----------
person := Person {Name: "tom",Age: 20,Email:"2732556589@qq.com",
}
f,_ := os.OpenFile("a.xml",os.O_WRONLY,0777) // Write
defer f.Close()
e:=xml.NewEncode(f)
e.Encode(p)

golang中标准库math

golang中操作mysql数据库-准备数据库和表

mysql -uroot -p // 登录
create database go_db; // 创建数据库表 go_db
use go_db // 使用go_db表
create table user_tbl(id integer primary key auto_increment, username varchar(20), password varchar(20)) // 创建数据字段
desc user_tbl; // 查看user_tbl表
insert into user_tbl(username,password) values("tom","123"); // 插入表数据select *from user_tbl; // 查询表数据

golang中操作mysql数据库-安装配置mysql驱动

// 安装驱动
go get -u github.com/go-sql-driver/mysql
// 驱动安装失败原因是 网络问题可以先执行下面代码解决
go env -w GOPROXY=https://goproxy.cn,direct
// 导包连接
import ("database/sql""time"_ "github.com/go-sql-driver/mysql"
)// ...db, err := sql.Open("mysql", "user:password@/dbname")
if err != nil {panic(err)
}
// See "Important settings" section.
db.SetConnMaxLifetime(time.Minute * 3)
db.SetMaxOpenConns(10)
db.SetMaxIdleConns(10)

golang中操作mysql数据库获得数据库连接

package main
import ("database/sql"// "time""fmt"_ "github.com/go-sql-driver/mysql"
)var db *sql.DBfunc initDB() (err error) {dsn := "root:asd123.0@tcp(127.0.0.1:3306)/go_db?charset=utf8mb4&parseTime=True"// 不会校验账号密码是否正确// 注意这里不要使用:= ,我们是给全局变量赋值，然后在main函数中使用全局变量dbprint(dsn,"-----")db, err = sql.Open("mysql",dsn)if err != nil {return err}// 尝试数据库建立连接校验dsn是否正确 Ping()err = db.Ping()if err != nil {return err}return nil
}func main()  {print("进入进程-----")err := initDB()if err != nil {fmt.Printf("err: %v\n", err)} else {fmt.Println("连接成功！")}
}

golang中操作mysql数据库-插入数据

package main
import ("database/sql"// "time""fmt"_ "github.com/go-sql-driver/mysql"
)var db *sql.DBfunc initDB() (err error) {dsn := "root:asd123.0@tcp(127.0.0.1:3306)/go_db?charset=utf8mb4&parseTime=True"// 不会校验账号密码是否正确// 注意这里不要使用:= ,我们是给全局变量赋值，然后在main函数中使用全局变量dbprint(dsn,"-----")db, err = sql.Open("mysql",dsn)if err != nil {return err}// 尝试数据库建立连接校验dsn是否正确 Ping()err = db.Ping()if err != nil {return err}return nil
}
// 执行插入
func insert()  {s := "insert into user_tbl(username,password) values(?,?)"r, err := db.Exec(s, "zhangshan","zs123")if err != nil {fmt.Printf("err: %v\n", err)} else {i, _ := r.LastInsertId()fmt.Printf("i: %v\n", i)}
}func main()  {print("进入进程-----")err := initDB()if err != nil {fmt.Printf("err: %v\n", err)} else {fmt.Println("连接成功！")}insert()
}

golang中操作mysql数据库-查询操作

package main
import ("database/sql"// "time""fmt"_ "github.com/go-sql-driver/mysql"
)var db *sql.DBfunc initDB() (err error) {dsn := "root:asd123.0@tcp(127.0.0.1:3306)/go_db?charset=utf8mb4&parseTime=True"// 不会校验账号密码是否正确// 注意这里不要使用:= ,我们是给全局变量赋值，然后在main函数中使用全局变量dbprint(dsn,"-----")db, err = sql.Open("mysql",dsn)if err != nil {return err}// 尝试数据库建立连接校验dsn是否正确 Ping()err = db.Ping()if err != nil {return err}return nil
}type User struct {id intusername stringpassword string
}
// 查询单行
func queryOneRow()  {s:= "select * from user_tbl where id = ?"var u Usererr := db.QueryRow(s, 2).Scan(&u.id, &u.username, &u.password)if err != nil {fmt.Printf("err: %v\n", err)} else {fmt.Printf("u: %v\n", u)}
}
// 查询多行
func queryManyRow()  {s := "select * from user_tbl"r, err := db.Query(s)var u Userdefer r.Close()if err != nil {fmt.Printf("err: %v\n", err)} else {for r.Next() {r.Scan(&u.id, &u.username, &u.password)fmt.Printf("u: %v\n", u)}}
}
func main()  {print("进入进程-----")err := initDB()if err != nil {fmt.Printf("err: %v\n", err)} else {fmt.Println("连接成功！")}queryOneRow()queryManyRow()
}

golang中操作mysql数据库-更新数据

package main
import ("database/sql"// "time""fmt"_ "github.com/go-sql-driver/mysql"
)var db *sql.DBfunc initDB() (err error) {dsn := "root:asd123.0@tcp(127.0.0.1:3306)/go_db?charset=utf8mb4&parseTime=True"// 不会校验账号密码是否正确// 注意这里不要使用:= ,我们是给全局变量赋值，然后在main函数中使用全局变量dbprint(dsn,"-----")db, err = sql.Open("mysql",dsn)if err != nil {return err}// 尝试数据库建立连接校验dsn是否正确 Ping()err = db.Ping()if err != nil {return err}return nil
}func update()  {s:="update user_tbl set username=?, password=? where id=?"r, err := db.Exec(s,"big Kite", "456789", 2)if err != nil {fmt.Printf("err: %v\n", err)} else {i, _ := r.RowsAffected()fmt.Printf("i:%v\n",i)}
}func main()  {print("进入进程-----")err := initDB()if err != nil {fmt.Printf("err: %v\n", err)} else {fmt.Println("连接成功！")}update()
}

golang中操作mysql数据库-删除数据

package main
import ("database/sql"// "time""fmt"_ "github.com/go-sql-driver/mysql"
)var db *sql.DBfunc initDB() (err error) {dsn := "root:asd123.0@tcp(127.0.0.1:3306)/go_db?charset=utf8mb4&parseTime=True"// 不会校验账号密码是否正确// 注意这里不要使用:= ,我们是给全局变量赋值，然后在main函数中使用全局变量dbprint(dsn,"-----")db, err = sql.Open("mysql",dsn)if err != nil {return err}// 尝试数据库建立连接校验dsn是否正确 Ping()err = db.Ping()if err != nil {return err}return nil
}func delete()  {s:="delete from user_tbl where id=?"r, err := db.Exec(s, 1)if err != nil {fmt.Printf("err: %v\n", err)} else {i, _ := r.RowsAffected()fmt.Printf("i:%v\n",i)}
}func main()  {print("进入进程-----")err := initDB()if err != nil {fmt.Printf("err: %v\n", err)} else {fmt.Println("连接成功！")}delete()
}

golang中操作MongoDB-BSON简介

下载：https://www.mongodb.com/try/download/community-kubernetes-operator
// use golang_db; 使用数据库 没有就自动创建
// db.createCollection("student"); 创建表集合
下载驱动： https://pkg.go.dev/go.mongodb.org/mongo-driver#readme-installation
----------------
package main
import ("context""fmt"// "time""go.mongodb.org/mongo-driver/mongo""go.mongodb.org/mongo-driver/mongo/options""log"
)var client *mongo.Clientfunc mogodb()  {fmt.Printf("-------\n")// 设置用户连接配置co := options.Client().ApplyURI("mongodb://localhost:27017")// 连接到mongodbfmt.Printf("-------\n",co)c, err := mongo.Connect(context.TODO(),co)if err != nil {log.Fatal(err,"123")} else {fmt.Printf("c:%v\n", c)}// 检查连接err2 := c.Ping(context.TODO(), nil)if err2 != nil {log.Fatal(err2)} else {fmt.Printf("success")}client = c
}func main()  {fmt.Printf("-------\n")mogodb()
}
---------------bson
package mainimport "go.mongodb.org/mongo-driver/bson"
import "fmt"
func main()  {// filter 过滤器 sql whered:= bson.D{{"name","tom",}}fmt.Printf("d: %v\n", d)
}

golang中操作MongoDB-添加文档

package main
import ("context""fmt"// "time""go.mongodb.org/mongo-driver/mongo""go.mongodb.org/mongo-driver/mongo/options""log"
)var client *mongo.Clientfunc initDb()  {co := options.Client().ApplyURI("mongodb://localhost:27017")c, err := mongo.Connect(context.TODO(),co)if err != nil {log.Fatal(err,"123")} else {fmt.Printf("c:%v\n", c)}// 检查连接err2 := c.Ping(context.TODO(), nil)if err2 != nil {log.Fatal(err2)} else {fmt.Printf("success")}client = c
}type Student struct {Name stringAge int
}func insert()  {initDb()// 添加一条记录s1 := Student{Name: "tom",Age: 20,}c := client.Database("go_db").Collection("Student")// defer collection.Close()ior, err := c.InsertOne(context.TODO(),s1)if err!= nil {fmt.Printf("err: %v\n", err)} else {fmt.Printf("ior.InsertedID: %v\n", ior.InsertedID)}
}func insertMany()  {initDb()c := client.Database("go_db").Collection("Student")// 添加一条记录s1 := Student{Name: "凯特",Age: 20,}s2 := Student{Name: "rose",Age: 20,}stus := []interface{}{s1,s2}// defer collection.Close()imr, err := c.InsertMany(context.TODO(),stus)if err!= nil {fmt.Printf("err: %v\n", err)} else {fmt.Printf("imr.InsertedID: %v\n", imr.InsertedIDs)}
}func main() {insertMany()
}

golang中操作MongoDB-查找文档

package main
import ("context""fmt"// "time""go.mongodb.org/mongo-driver/mongo""go.mongodb.org/mongo-driver/mongo/options""log""go.mongodb.org/mongo-driver/bson"
)var client *mongo.Clientfunc initDb()  {co := options.Client().ApplyURI("mongodb://localhost:27017")c, err := mongo.Connect(context.TODO(),co)if err != nil {log.Fatal(err,"123")} else {fmt.Printf("c:%v\n", c)}// 检查连接err2 := c.Ping(context.TODO(), nil)if err2 != nil {log.Fatal(err2)} else {fmt.Printf("success")}client = c
}type Student struct {Name stringAge int
}func find()  {initDb()ctx := context.TODO()defer client.Disconnect(ctx)c := client.Database("go_db").Collection("Student")c2, err := c.Find(ctx, bson.D{})if err != nil {log.Fatal(err)}defer c2.Close(ctx)for c2.Next(ctx) {var result bson.Dc2.Decode(&result)fmt.Printf("result: %v\n",result)fmt.Printf("result: %v\n", result.Map())}
}func main() {find()
}

golang中操作MongoDB-更新文档

package main
import ("context""fmt"// "time""go.mongodb.org/mongo-driver/mongo""go.mongodb.org/mongo-driver/mongo/options""log""go.mongodb.org/mongo-driver/bson"
)var client *mongo.Clientfunc initDb()  {co := options.Client().ApplyURI("mongodb://localhost:27017")c, err := mongo.Connect(context.TODO(),co)if err != nil {log.Fatal(err,"123")} else {fmt.Printf("c:%v\n", c)}// 检查连接err2 := c.Ping(context.TODO(), nil)if err2 != nil {log.Fatal(err2)} else {fmt.Printf("success")}client = c
}func update()  {initDb()c := client.Database("go_db").Collection("Student")ctx := context.TODO()update := bson.D{{"$set",bson.D{{"Name", "big kite"},{"Age",22}}}}ur, err := c.Update.Many(ctx,bson.D{{"Name","kite"}},update)if err!= nil {fmt.Printf("err: %v\n", err)} else {fmt.Printf("ur: %v\n", ur)}fmt.Printf("ur.ModifiedCount: %v\n", ur.ModifiedCount)
}func main() {update()
}

golang中操作MongoDB-删除文档

package main
import ("context""fmt"// "time""go.mongodb.org/mongo-driver/mongo""go.mongodb.org/mongo-driver/mongo/options""log""go.mongodb.org/mongo-driver/bson"
)var client *mongo.Clientfunc initDb()  {co := options.Client().ApplyURI("mongodb://localhost:27017")c, err := mongo.Connect(context.TODO(),co)if err != nil {log.Fatal(err,"123")} else {fmt.Printf("c:%v\n", c)}// 检查连接err2 := c.Ping(context.TODO(), nil)if err2 != nil {log.Fatal(err2)} else {fmt.Printf("success")}client = c
}func delete()  {initDb()c := client.Database("go_db").Collection("Student")ctx := context.TODO()dr, err := c.DeleteMany(ctx, bson.D{{"age",20}})if err != nil {log.Fatal(err)}fmt.Printf("dr.DeletedCount: %v\n", dr.DeletedCount)
}func main() {delete()
}

gorm概述

package mainimport ("gorm.io/gorm""gorm.io/driver/mysql"
)type Product struct {gorm.ModelCode stringPrice uint
}// 创建表
func create(db *gorm.Db)  {// 创建表db.AutoMigrate(&Product{})
}// 添加数据表
func insert(db *gorm.Db)  {// 插入数据p := Product{code: "1001",price: 100,}db.Create(&p)
}// 查询数据表
func find(db *gorm.Db)  {// 插入数据var p Product// 查询单个db.First(&p,1)fmt.Printf("p", p)// 查询多个db.First(&p,"code = ?","1001") //查找字段为1001记录fmt.Printf("p", p)
}// 更新数据表
func update(db *gorm.Db)  {// 插入数据var p Product// 查询单个db.First(&p,1)fmt.Printf("p", p)db.Model(&p).Update("price",1000)
}// 删除数据表
func delete(db *gorm.Db)  {// 插入数据db.Delete(&prodect,1)
}func main() {dsn := "root:asd123.0@tcp(127.0.0.1:3306)/golang_db?charset=utf8mb4&parseTime=True&loc=Local"db,err := gorm.Open(mysql.Open("dsn",&gorm.Config{}))if err != nil {panic("failed to connect database")}create(db)insert(db)find(db)update(db)delete(db)// 查询
}

gorm声明模型

gorm连接到数据库

package mainimport ("gorm.io/gorm""gorm.io/driver/mysql"
)func main() {dsn := "root:asd123.0@tcp(127.0.0.1:3306)/golang_db?charset=utf8mb4&parseTime=True&loc=Local"db,err := gorm.Open(mysql.Open("dsn",&gorm.Config{}))if err != nil {panic("failed to connect database")}}

gorm创建记录

package mainimport ("gorm.io/gorm""gorm.io/driver/mysql"
)type Product struct {gorm.ModelCode stringPrice uint
}// 创建表
func create(db *gorm.Db)  {// 创建表db.AutoMigrate(&Product{})
}// 添加数据表
func insert(db *gorm.Db)  {// 插入数据p := Product{code: "1001",price: 100,}db.Create(&p)
}func main() {dsn := "root:asd123.0@tcp(127.0.0.1:3306)/golang_db?charset=utf8mb4&parseTime=True&loc=Local"db,err := gorm.Open(mysql.Open("dsn",&gorm.Config{}))if err != nil {panic("failed to connect database")}create(db)
}

gorm查询记录

package mainimport ("gorm.io/gorm""gorm.io/driver/mysql"
)type Product struct {gorm.ModelCode stringPrice uint
}// 查询数据表
func find(db *gorm.Db)  {// 插入数据var p Product// 查询单个db.First(&p,1)fmt.Printf("p", p)// 查询多个db.First(&p,"code = ?","1001") //查找字段为1001记录fmt.Printf("p", p)
}func main() {dsn := "root:asd123.0@tcp(127.0.0.1:3306)/golang_db?charset=utf8mb4&parseTime=True&loc=Local"db,err := gorm.Open(mysql.Open("dsn",&gorm.Config{}))if err != nil {panic("failed to connect database")}find(db)
}

gorm更新

package mainimport ("gorm.io/gorm""gorm.io/driver/mysql"
)type Product struct {gorm.ModelCode stringPrice uint
}// 更新数据表
func update(db *gorm.Db)  {// 插入数据var p Product// 查询单个db.First(&p,1)fmt.Printf("p", p)db.Model(&p).Update("price",1000)
}func main() {dsn := "root:asd123.0@tcp(127.0.0.1:3306)/golang_db?charset=utf8mb4&parseTime=True&loc=Local"db,err := gorm.Open(mysql.Open("dsn",&gorm.Config{}))if err != nil {panic("failed to connect database")}update(db)}

gorm删除

package mainimport ("gorm.io/gorm""gorm.io/driver/mysql"
)type Product struct {gorm.ModelCode stringPrice uint
}// 删除数据表
func delete(db *gorm.Db)  {// 插入数据db.Delete(&prodect,1)
}func main() {dsn := "root:asd123.0@tcp(127.0.0.1:3306)/golang_db?charset=utf8mb4&parseTime=True&loc=Local"db,err := gorm.Open(mysql.Open("dsn",&gorm.Config{}))if err != nil {panic("failed to connect database")}delete(db)
}

gorm原生SQL和SQL构建器

gorm关联关系Belongs To（属于）

gorm关联关系值Has One(有一个)

gorm关联关系之Has Many

gorm关联关系之Many To Many

gorm关联关系之实体关联

gorm session配置

gorm事务控制

git简介

git的安装和配置

git的四个工作区

git文件的四种状态

git常用命令

git配置用户签名

git初始化本地仓库

git查看状态

git将代码添加到暂存区

git提交代码

git修改并提交代码

git项目版本切换

git分支简介

git分支常用命令

git合并分支

git合并解决冲突

git团队协作

gitHub创建远程仓库

gitHub推送本地仓库

gitHub拉取远程仓库

gitHub克隆远程仓库

gitHub团队内协作

gitHub跨团队协作

gitHub免密登录

配置git忽略文件

IDEA集成git初始化本地仓库

IDEA集成git切换版本

IDEA集成git创建和切换分支

IDEA集成git合并分支

IDEA集成git合并分支并解决冲突

IDEA中配置GitHub

IDEA中推送项目到github

IDEA中配置从github拉取项目

克隆gitHub中的项目

gitee码云简介

IDEA集成码云Gitee

gitlab简介

gitlab的安装与初始化

IDEA集成gitlab

为什么使用Docker

Docker简介

安装Docker

Docker中央仓库

Docker镜像操作

Docker容器

准备一个web项目

创建MySQL容器

创建Tomcat容器

将项目部署到tomcat

Docker数据卷

Dockerfile

Docker自定义镜像

下载安装Docker-compose

Docker-compose管理mysql和tomcat容器

使用Docker-compose命令管理容器

使用Docker-compose和Dockerfile管理镜像和容器

前端转golang从小白到实战自学笔记（2023/3/1）相关推荐

html+css+js适合前端小白的实战全解（超详细）——2048小游戏（三）
续上一小节,我们回到newgame()这个函数,我们之前只做了init()内函数,相当于一个初始化操作现在,我们需要再随机两个两个生成数字. 随机生成数字在这个游戏里会经常出现,用户移动一步,也会产 ...
html+css+js适合前端小白的实战全解（超详细）——2048小游戏（二）
续上一小节,我们可以发现每一个grid-cell上的数字初始时并不在格子里. 这些数字可以随着玩家的操作而移动我们可以想象:初始时每一个格子上的数为0,他们并不显示 ↓ 只有当grid-cell ...
视频教程-桫哥-GOlang基础-Go语言实战：并发爬虫-Go语言
桫哥-GOlang基础-Go语言实战:并发爬虫多年互联网从业经验: 有丰富的的企业网站.手游.APP开发经验: 曾担任上海益盟软件技术股份有限公司项目经理及产品经理: 参与项目有益盟私募工厂.睿妙影 ...
视频教程- 桫哥-GOlang基础-Go语言实战：成语查询-Go语言
桫哥-GOlang基础-Go语言实战:成语查询多年互联网从业经验: 有丰富的的企业网站.手游.APP开发经验: 曾担任上海益盟软件技术股份有限公司项目经理及产品经理: 参与项目有益盟私募工厂.睿妙影 ...
CaSS中lisp命令不可用_小白想要自学南方cass?又苦于不会修改比例尺，这里有一份小白快速上手的测绘神器...
小白想要自学南方cass?又苦于不会修改比例尺,这里有一份小白快速上手的测绘神器自CASS软件推出以来,市场占有率遥遥领先,已经成为业内应用最广.使用最方便快捷的软件品牌.也是用户量最大.升级最快. ...
深入理解弹性盒布局（fiex-box）——Web前端系列自学笔记
文章目录弹性盒布局弹性盒布局概述弹性盒布局属性 display flex-flow justify-content align-items order flex align-self 总结弹性 ...
Docker小白到实战之Docker网络简单了解一下
前言现在对于Docker容器的隔离性都有所了解了,但对容器IP地址的分配.容器间的访问等还是有点小疑问,如果容器的IP由于新启动导致变动,那又怎么才能保证原有业务不会被影响,这就和网络有挂钩了,接下 ...
Docker小白到实战之Dockerfile解析及实战演示，果然顺手
前言使用第三方镜像肯定不是学习Docker的最终目的,最想要的还是自己构建镜像:将自己的程序.文件.环境等构建成自己想要的应用镜像,方便后续部署.启动和维护:而Dockerfile就是专门做这个事的 ...
Docker小白到实战之容器数据卷，整理的明明白白
前言上一篇把常用命令演示了一遍,其中也提到容器的隔离性,默认情况下,容器内应用产生的数据都是由容器本身独有,如果容器被删除,对应的数据文件就会跟着消失.从隔离性的角度来看,数据就应该和容器共存亡:但 ...