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

已于 2023-05-09 15:07:25 修改
阅读量1k 收藏 2
点赞数 1
文章标签： golang
于 2023-03-01 20:37:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52901235/article/details/129280752
版权
本文详细介绍了Go语言的基础知识，包括变量、类型、函数、流程控制、面向对象编程、错误处理等。接着深入探讨了Go的并发特性，如goroutine、channel、互斥锁和条件变量。此外，还讲解了如何使用标准库操作MySQL和MongoDB数据库，以及GORMORM框架的应用。最后，提到了Docker和DockerCompose在部署应用程序中的作用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

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

Go语言在前端开发中的崛起
KwyxLibrary的博客
10-04 406
Go语言具有简洁的语法、垃圾回收机制、强大的标准库和并发原语等特点，使得它成为一种理想的选择，尤其是在构建高性能、可伸缩的应用程序时。它的并发模型和轻量级的线程（goroutine）机制使得它能够处理大量的并发请求，而无需过多的资源开销。工具可以将前端资源文件（如HTML、CSS、JavaScript文件等）嵌入到Go语言的可执行文件中，从而方便地将应用程序和所需的前端资源打包在一起。希望读者能够通过本文对Go语言在前端开发中的崛起有一个初步的了解，并能够在实际项目中应用这些技术。在上述示例中，通过调用。
写给前端工程师的Golang入门教程 —— Hello World
weixin_43738802的博客
08-26 230
Go is an open source programming language that makes it easy to build simple, reliable, and efficient software. 环境搭建 我们在前端搭建环境时会先安装Node.js[1]，安装 Node.js 有几种方法 下载安装包或二进制文件 使用系统包管理工具安装 使用版本管理工具安装 对应我们也有这几种方法可以安装 Golang 下载安装包或二进制文件 我们可以在Golang 下载页[2]找到不同系统对.
一份前端工程师快速接入GO语言语法指南(中)
前端攻城狮Dannis
11-21 487
一份前端工程师快速接入GO语言语法直男指南(中) long time no see, 又过了一周, 笔者这周为大家带来的是咱们这个指南的中篇(目测指南大概会存在: 上,中, 下, 进阶四篇), 而有了上篇的铺垫, 笔者相信你对go语言也有了一些基本的认识, 这一篇我们来继续讲讲go语言的其他特性: 指针 复合数据类型 函数 go语言中一些常用的包 指针 如果你大学里上过C语言的话, 我相信你对指针这个东西不太陌生, 如果你没上过, 那笔者就用自己对指针的理解来跟同学聊聊指针 指针到底是什么？ 跟in
前端工程师学习go语言第二弹
wang_yu_shun的博客
10-17 547
这是学习go语言的第二篇，思维导图太大了，为了保证其清晰度，只能放出来一部分，其余部分只能以文字方式进行叙述，喜欢的朋友可以点赞收藏，(关注我回复“go"领取本篇及上篇go思维导图）Go....
前端微前端是从Golang开始
qq_39613856的博客
09-21 484
确认一遍 对你没看错，微前端是从Golang开始 核心观点：所有脱离业务场景的技术讨论都是耍流氓 微前端实践过程中的感悟：https://juejin.im/post/6860823404447006734 关键词：样式，事件，缓存的相互冲突，特性代码的规则方案，通信机制的建立 需求背景 新旧多系统集成 日均上xx的独立用户访问 跨多个业务部门合作方式 主要问题 前端系统多技术栈，新旧项目错综复杂，有维护了6年的jq项目，也有新加入的react项目 后端完全失控，虽然前端页面是多个后端系统集合体.
一份前端工程师快速接入GO语言语法指南(上)
前端攻城狮Dannis
11-14 1655
一份前端工程师快速接入GO语言语法直男指南 如果你对行业风向比较关注的话, 我相信你对go一定是不陌生的, 作为近几年频频露脸大放异彩的21世纪C语言, go华服加身（熹妃回宫~）, 当然, 作为一名前端, 不论是为了让自己的职业道路更加宽广(搞更多的钱), 还是为了要让自己的技术栈更加丰富, KOA node这种级别的语言已经不足以让我们停下脚步, 如果想要成为全栈或者架构, 一门或多门服务端语言的学习与掌握不可避免, 而go这两年又这么红, 所以笔者这里提供一本葵花宝典(不正经前端学习go基本语法指南)
小白怎么入门Golang开发实战？看这篇就够啦！（白嫖60G资料）
weixin_70257503的博客
09-26 4216
Golang不难，入门更简单！可不要被它神秘的外衣给唬住了。 只要你接下来认真听完我的讲解，虽然保证不了你能成为大神，但就算你学习能力再差那也能达到入门级别。
golang游戏开发学习笔记-开发一个简单的2D游戏(基础篇）
2401_83817392的博客
04-20 605
班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！**
【网络安全】零基础小白自学Web安全需要掌握哪些知识？（附系统路线+工具笔记）
abao6690的博客
06-04 1120
【网络安全】零基础小白自学Web安全需要掌握哪些知识？（附系统路线+工具笔记）
联合战队大佬带你入门CTF-web(2)，Golang之内存泄漏调试学习与总结
2401_84254196的博客
04-20 925
针对以上技术内容，博主会陆续创作技术分享。敬请期待~以上就是F12师傅总结的web入门技巧，在这里贴一下师傅的博客地址感兴趣的师傅可以多多关注，跟着大佬走，flag拿到饱！！！黑客&网络安全如何学习1.学习路线图攻击和防守要学的东西也不少，具体要学的东西我都写在了上面的路线图，如果你能学完它们，你去就业和接私活完全没有问题。2.视频教程网上虽然也有很多的学习资源，但基本上都残缺不全的，这是我自己录的网安视频教程，上面路线图的每一个知识点，我都有配套的视频讲解。
LangChain 的 Go 语言实现_golang langchain
2401_84008965的博客
04-20 654
LangChain 是大模型应用的明星项目，但是其使用的是 Python 进行开发的，可能很多的公司并不是正在使用 Python，这样就很难融入到已有的基础设施之上，比如现在有不少公司使用 Go 语言开发，那如果也要使用 LangChain 这样的项目。今天要给大家推荐一个 GitHub 开源项目 tmc/langchaingo，该项目在 GitHub 有超过 1k Star，用一句话介绍该项目就是：“LangChain for Go”。
Go-为Go程序自动生成前端界面
08-14
为Go程序自动生成前端界面
前端视角下的Go语法学习：创建 Go 项目
最新发布
weixin_45368328的博客
06-30 2644
3、这种方式创建的项目 默认会用电脑的sdk，使用编辑器的话可以自己选择 sdk ，当然其实这些都是可以直接在 go.mod 文件中进行调整的。go.mod 文件是 go 项目依赖管理文件，相当于前端的 package.json，也是Java项目中Maven的pom.xml。在上面演示中，选择了 go.1.22.0 创建的项目，好奇是否会下载 go.1.22.0 SDK在本地呢？6、点击创建，会得到一个 go.mod 文件，到这里 go 项目就算创建完毕。使用 GoLand 创建 Go 项目。
Go模板库text/template
Jary
03-27 1025
所有方法 Name() string // 返回模板的名称 New(name string) *Template // 创建一个模板 Clone() (*Template, error) // 返回一个副本 AddParseTree(name string, tree *parse.Tree) (*Template, error) // 添加一个节点 Templates() []*Template // 返回与之相关联的模板切片 Funcs(funcMap FuncMap) *Template // 向
Gin-使用golang写前端
weixin_44846765的博客
06-23 1163
gin，一个直接能够操作网页的golang框架，更优雅的写前端，它具有类似 martini 的 API，性能要好得多，多亏了 httprouter，速度提高了 40 倍。 如果您需要性能和良好的生产力，一定要试试
Golang开发入门（一）
360技术
07-13 2612
点击蓝字关注我们本文转载自开测GO语言简介Go（又称 Golang）是 Google 的 Robert Griesemer，Rob Pike 及 Ken Thompson 开发的一种静态...
Golang和HTTPS在网站前端接入里的作用
cpongo5
01-03 178
网站前端架构技术一直在不断的优化，而要做到全栈优化，就必须要运维、后端架构研发、前端模板渲染研发、系统和网络等各个部门的协作。同时，安全又是网站建设话题中避不开的梗，从2015年年初开始，HTTPS安全协议就已经遍布各大网站的网址里了，而百度是国内第一家推行全站HTTPS的大型网站，这其中就有很多关于站内优化和站内安全的经验分享。以下内容是对第61期百度技术沙龙的三位资深运维工程师的采访。\\陶春...
将 Node.js 换成 Go
weixin_33937499的博客
06-06 1297
回顾过去的一年，我们在技术栈上的最大改变就是从 Node.js 切换到 Go 。我们的联合创始人，Steve Kaliski， 在 Poptip 把 Node.js 切换成了 Go，可惜他没有学习到当时的教训。在用 Node.js 建立了 Bowery 的第一个迭代版本后，我们在2014年2月切换到了 Go，我们的开发和部署速度也因此得到提升。 从那以后...
前端开发者的Go语言之路(8) —— 初识并发编程
u012925833的博客
09-17 461
1. 并发编程 1.1 goroutine 示例： func main() { for i := 0; i < 10; i++ { go func(i int) { // 开启的这个多任务可以一直输出打印 for { fmt.Printf("hello from goroutine %d \n", i) } }(i) } // ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

李宏伟~

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

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

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

打赏作者

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

抵扣说明：

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

余额充值