前端转golang从小白到实战自学笔记(2023/3/1)

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

gitee:https://gitee.com/xuyabing/go-connect.git

golang学习方向


  1. 区块链研发工程师

  1. go服务器=>(特点:数据处理,处理大并发)/游戏软件工程师

  1. 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

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

// 标识符命名
package main
import "fmt"
func main() {
    // 正确写法
    var name string
    var age int
    var _sys int
    // 错误写法
    var 1name string
    var &age int
    var !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 string
    var age int
    var m bool
    // 第二种
    var (
        name string
        age int
        m 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 = 100
    height = 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 int8
 var i16 int16
 var 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+b
    return 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 = 23
    return 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 add
        case "-":    
            return sub
        default:
            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 int
    return func(y int) int {
        x += y
        return 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 int
    name,email string
    checked bool
}
var tom strAll
tom.id = 1
fmt.Printf("i:%v\n : %T",tom, tom)

golang中结构体初始化


type strAll struct {
    id, age int
    name,email string
    checked bool
}
var tom strAll

tom = 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 int
    name,email string
    checked 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 int
    name,email string
    checked 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 Dog
    name 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 {
    Flyer
    Swimmer
}
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 string
    age 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 string
        age 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 Animal
    bbb string
}

golang中构造函数


// 构造方法
per,err := NewPerson("tom", 20)
if err == nil {
    fmt.Println("%v",per)
} else {
    fmt.Println("%v",err)
}

type Person struct {
    name string
    age 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.WaitGroup

for 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 += 1
    fmt.Printf("i++:%v\n", i)
    time.Sleep(time.Millisecond * 10)
    lock.Unlock()
}

func sub()  {
    defer wp.Done()
    lock.lock()
    i-=1
    fmt.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:=<-c
    fmt.Println("end r:",r)
}

golang中并发编程之select


var chanInt = make(chan int, 0)

var chanStr = make(chan string, 0)

go func ()  {
    chanInt <- 100
    chanStr <- "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.C
    fmt.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 += v
    if 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 = 100

func 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.Time
    what 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.DB

func initDB() (err error) {
    dsn := "root:asd123.0@tcp(127.0.0.1:3306)/go_db?charset=utf8mb4&parseTime=True"
    // 不会校验账号密码是否正确
    // 注意这里不要使用:= ,我们是给全局变量赋值,然后在main函数中使用全局变量db
    print(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.DB

func initDB() (err error) {
    dsn := "root:asd123.0@tcp(127.0.0.1:3306)/go_db?charset=utf8mb4&parseTime=True"
    // 不会校验账号密码是否正确
    // 注意这里不要使用:= ,我们是给全局变量赋值,然后在main函数中使用全局变量db
    print(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.DB

func initDB() (err error) {
    dsn := "root:asd123.0@tcp(127.0.0.1:3306)/go_db?charset=utf8mb4&parseTime=True"
    // 不会校验账号密码是否正确
    // 注意这里不要使用:= ,我们是给全局变量赋值,然后在main函数中使用全局变量db
    print(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 int
    username string
    password string
}
// 查询单行
func queryOneRow()  {
    s:= "select * from user_tbl where id = ?"
    var u User
    err := 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 User
    defer 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.DB

func initDB() (err error) {
    dsn := "root:asd123.0@tcp(127.0.0.1:3306)/go_db?charset=utf8mb4&parseTime=True"
    // 不会校验账号密码是否正确
    // 注意这里不要使用:= ,我们是给全局变量赋值,然后在main函数中使用全局变量db
    print(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.DB

func initDB() (err error) {
    dsn := "root:asd123.0@tcp(127.0.0.1:3306)/go_db?charset=utf8mb4&parseTime=True"
    // 不会校验账号密码是否正确
    // 注意这里不要使用:= ,我们是给全局变量赋值,然后在main函数中使用全局变量db
    print(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.Client

func mogodb()  {
    fmt.Printf("-------\n")
    // 设置用户连接配置
    co := options.Client().ApplyURI("mongodb://localhost:27017")
    // 连接到mongodb
    fmt.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 main

import "go.mongodb.org/mongo-driver/bson"
import "fmt"
func main()  {
    // filter 过滤器 sql where
    d:= 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.Client


func 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 string
    Age 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.Client


func 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 string
    Age 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.D
        c2.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.Client


func 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.Client


func 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 main

import (
    "gorm.io/gorm"
    "gorm.io/driver/mysql"
)

type Product struct {
    gorm.Model
    Code string
    Price 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 main

import (
    "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 main

import (
    "gorm.io/gorm"
    "gorm.io/driver/mysql"
)

type Product struct {
    gorm.Model
    Code string
    Price 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 main

import (
    "gorm.io/gorm"
    "gorm.io/driver/mysql"
)

type Product struct {
    gorm.Model
    Code string
    Price 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 main

import (
    "gorm.io/gorm"
    "gorm.io/driver/mysql"
)

type Product struct {
    gorm.Model
    Code string
    Price 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 main

import (
    "gorm.io/gorm"
    "gorm.io/driver/mysql"
)

type Product struct {
    gorm.Model
    Code string
    Price 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构建器


package main

import (
    "database/sql"
    "fmt"
    "time"

    "gorm.io/driver/mysql"
    "gorm.io/gorm"
)

func main() {
    // testRaw1()
    // testRaw2()
    // testRaw3()
    testRaw4()
    // db.AutoMigrate(&User{})
    // user := User{
    //     Name:     "kite",
    //     Age:      20,
    //     Birthday: time.Now(),
    //     Active:   false,
    // }
    // db.Create(&user)
    fmt.Println("", 13122)
}

type User struct {
    gorm.Model
    Name     string
    Age      int
    Birthday time.Time
    Active   bool
}

var db *gorm.DB

func init() {
    dsn := "root:asd123.0@tcp(127.0.0.1:3306)/go_db?charset=utf8mb4&parseTime=True&loc=Local"
    d, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
    if err != nil {
        panic("failed to connect dataabase")
    }
    db = d
}

func testRaw1() {
    type Result struct {
        ID   int
        Name string
        Age  int
    }
    var result Result
    db.Raw("select id, name, age from users where name=?", "tom").Scan(&result)
    fmt.Printf("result:%v\n", result)
    var age int
    db.Raw("select sum(age) from users").Scan(&age)
    fmt.Printf("age:%v\n", age)
}

func testRaw2() {
    db.Exec("update users set age=? where name=?", 100, "tom")
}

func testRaw3() {
    var user User
    db.Where("name=@myname", sql.Named("myname", "tom")).Find(&user)
    fmt.Printf("user: %v\n", user)
}

func testRaw4() {
    var name string
    var age int
    row := db.Table("users").Where("name = ?", "tom").Select("name", "age").Row()
    row.Scan(&name, &age)
    fmt.Printf("name: %v\n", name)
    fmt.Printf("age: %v\n", age)
    rows, _ := db.Model(&User{}).Where("age > ?", 18).Select("name", "age").Rows()
    for rows.Next() {
        rows.Scan(&name, &age)
        fmt.Printf("name: %v\n", name)
        fmt.Printf("age: %v\n", age)
    }
}

gorm关联关系Belongs To(属于)


package main

import (
    "fmt"

    "gorm.io/driver/mysql"
    "gorm.io/gorm"
)

func main() {
    // testRaw1()
    // testRaw2()
    // testRaw3()
    // testRaw4()
    // db.AutoMigrate(&User{})
    // user := User{
    //     Name:     "kite",
    //     Age:      20,
    //     Birthday: time.Now(),
    //     Active:   false,
    // }
    // db.Create(&user)
    // 多对一
    fmt.Println("", 13122)
    // test1()
    test2()
}
func test1() {
    type Company struct {
        ID   int
        Name string
    }
    type User struct {
        gorm.Model
        Name      string
        CompanyID int
        Company   Company
    }
    db.AutoMigrate(&Company{}, &User{})
}
func test2() {
    //重写外键
    type Company struct {
        ID   int
        Name string
    }
    type User struct {
        gorm.Model
        Name      string
        CompanyID int
        Company   Company `gorm:"foreignKey:CompanyRefer"`
    }
    db.AutoMigrate(&Company{}, &User{})
}

var db *gorm.DB

func init() {
    dsn := "root:asd123.0@tcp(127.0.0.1:3306)/go_db?charset=utf8mb4&parseTime=True&loc=Local"
    d, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
    if err != nil {
        panic("failed to connect dataabase")
    }
    db = d
}

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


package main

import (
    "gorm.io/driver/mysql"
    "gorm.io/gorm"
)

var db *gorm.DB

func init() {
    dsn := "root:asd123.0@tcp(127.0.0.1:3306)/go_db?charset=utf8mb4&parseTime=True&loc=Local"
    d, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
    if err != nil {
        panic("failed to connect dataabase")
    }
    db = d
}
func main() {
    tesst1()
}

func tesst1() {
    type CreditCard struct {
        gorm.Model
        Number string
        UserID uint
    }

    type User struct {
        gorm.Model
        CreditCard CreditCard
    }
    db.AutoMigrate(&User{}, &CreditCard{})
}

gorm关联关系之Has Many


gorm关联关系之Many To Many


gorm关联关系之实体关联


gorm session配置


package main

import (
    "gorm.io/driver/mysql"
    "gorm.io/gorm"
)

var db *gorm.DB

func init() {
    dsn := "root:asd123.0@tcp(127.0.0.1:3306)/go_db?charset=utf8mb4&parseTime=True&loc=Local"
    // 全局配置
    d, err := gorm.Open(mysql.Open(dsn), &gorm.Config{DryRun: true})
    if err != nil {
        panic("failed to connect dataabase")
    }
    db = d
}
func main() {
    tesst1()
}

func tesst1() {
    // 会话配置
    db.Session(&gorm.Session{DryRun: true})
}

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管理镜像和容器


  • 1
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

李宏伟~

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值