go自学笔记

最新推荐文章于 2024-06-16 00:31:58 发布

Emotiona狠淡定

最新推荐文章于 2024-06-16 00:31:58 发布

阅读量271

点赞数

文章标签： go

本文链接：https://blog.csdn.net/XSJlei/article/details/105694751

版权

Go语言

go项目结构图

在这里插入图片描述

导包

也就是import “fmt”

如果导入包就必须使用

变量

//定义一个变量输出出来
var a int
fmt.Println("a的值是",a)
a = 10
fmt.Println("a赋值之后是",a)

//还可以定义多个变量之间用逗号隔开
//定义的变量必须使用
var b,c int
b = 20
c = 30
fmt.Println("b是",b,"c是",c)

//变量的初始化
var d int = 100 //变量的初始化
d = 200  //变量的赋值
fmt.Println("d的值",d)

//变量自动推导类型  %T是获取变量的类型
//Printf是推导类型
f := 30
fmt.Printf("f 的类型是%T",f)

//声明一个变量a 并赋值
var a int = 10
fmt.Println("a的值",a)
a = 20
fmt.Println("a的值",a)
//变量的赋值可以给同名的n次
//但是声明的变量名是唯一的只能声明一次

//：=是自动推导类型  ：是先声明一个变量 =是赋值
b := 30
fmt.Println("b的值",b)
c := 40
fmt.Println("a的值",a,"b的值",b,"c的值",c)
fmt.Printf("a= %d,b = %d,c = %d\n",a,b,c)

//多重复值 数值的交换
//传统的方法
a := 10
b := 20
var temp int
temp = a
a = b
b = temp
fmt.Println(a, b)

//go语言的优势
a, b = 20, 10
fmt.Println(a, b)

/*匿名函数
声明三个变量的值
_表示丢弃
 */
var i, j, h int
i, _, h = 1,2,3
fmt.Println(i, j, h)

常量

//定义一个常量
const a = 10
fmt.Println("常量的值是",a)
fmt.Printf("a typr is %T",a)

常量变量组合

//定义多个变量
var (
   //可以初始化变量的值
   //可以不写类型 自动推导
   a int
   b float32
)
a = 10
b = 10.1
fmt.Println(a,b)


//定义多个常量
const(
   //必须初始化常量的值 因为不可以改变
   //也可以不写类型 自动推导
   c int = 20
   d float32 = 20.1
)
fmt.Println(c,d)

iota枚举

//iota 是常量的枚举计数生成器
const (
   a = iota
   b = iota
   c = iota
)
fmt.Println(a,b,c)
//iota在同一行的时候是相同的值
const(
   i = iota
   d,e,f = iota,iota,iota
)
fmt.Printf("i = %d,d= %d,e = %d,f = %d\n",i,d,e,f)

//可以只写一个iota
const (
   a1 = iota
   b1
   c1
)
fmt.Println(a1,b1,c1)

//iota遇到const值为0
const s = iota
fmt.Printf("s = %d\n",s)

数据类型

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rwFBSPXF-1587565143439)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200408181330901.png)]

bool布尔值

/*
定义一个布尔值
默认的初始化的是false
可以自动推导 使用 ：=
 */
var a bool
fmt.Println(a)
a = true
fmt.Println(a)
var b = true
fmt.Println(b)
c := false
fmt.Println(c)

int整形

var a int = 值

a = 赋值

a := 值

float浮点型

//定义一个浮点型的数据
var a float32
a = 10.1
fmt.Println(a)

//自动推导
b := 3.14
fmt.Printf("b type is %T\n",b)

byte字节

//字符 byte
//printf 是数据的格式化 %d 是格式化成数字  %c 是格式化成字母
var ch byte
ch = 97
fmt.Printf("%c,%d\n",ch,ch)

//大小写的转换 \n是转义字符

//这是小写的转换成大写的
fmt.Printf("%c\n",'a'-32)
fmt.Printf("%c",'A'+32)

String 字符串

//声明一个字符串类型
var a string
a = "like"
fmt.Println("a=", a)

//自动推导类型
b := "mikes"
fmt.Println("b = ", b)

//string 字符串有一个操作就是len 可以获取字符串的长度
fmt.Println("b 的字符串的长度为",len(b))

string和byte的区别

/*
string 和 byte
string输出就是一个单独的字符串
byte字符的话就是自动转换成数字
 */
var str string
str = "a"
fmt.Println("str = ",str)

var by byte
by = 'a'
fmt.Println("a = ",by)

Complex复数

//定义一个复数
   var t complex128
   t = 1 + 2i
   //分为实部和虚部
   fmt.Println("t = ",t)

   //自动推导过程
   t1 := 2+2i
fmt.Println(real(t1),imag(t1))

   //分别拿出来函数的实部和虚部
   fmt.Println(real(t),imag(t))

格式化输出的类型

a := 10
b := "str"
c := 'a'
d := 3.14
fmt.Printf("%T,%T,%T,%T \n",a,b,c,d)

//格式化输出的类型
//%d 整形
//%s 字符串
//%c 字符
//%f 浮点型
//%T 类型
//%v 万能的
fmt.Printf("%d,%s,%c,%f\n",a,b,c,d)

变量的输入

（scan scanf）

var a int
fmt.Printf("请输入变量值a")
//阻塞等待用户的输入
fmt.Scanf("%d",&a)
//fmt.Scan(&a)
fmt.Println("a = ",a)

类型的转换

//bool布尔类型是不兼容类型不能进行转换
var a bool
a = false
fmt.Printf("%t",a)

var b byte
b = 'a'
var c int
c = int(b)//转换类型
fmt.Print(c)

流程控制语句

If语句

if语句 if-else if-else

//if语句
a := "王丽坤"
if a=="王丽坤"{
   fmt.Println("这个人是王丽坤")
}

//支持一个初始化语句和判断条件在同一行 使用分号隔开
if b:="赵丽颖";b=="王丽坤"{
   fmt.Println("这个人是赵丽颖")
}else{
   fmt.Println("这个人是王丽坤")
}

switch语句

var num int
fmt.Println("请输入楼层号")
fmt.Scan(&num)
switch num {
case 1:
   fmt.Println("这是第一层楼")
   //break 保留了break关键字
   fallthrough //这是匹配工程之后无条件的执行
case 2:
   fmt.Println("这是第二层楼")
   fallthrough
case 3:
   fmt.Println("这是第三层楼")
   fallthrough
case 4:
   fmt.Println("这是第四层楼")
   fallthrough
case 5:
   fmt.Println("这是第五层楼")
   fallthrough
default:
   fmt.Println("xxxxxx")
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bl53CzPf-1587565143441)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200408223528673.png)]

For循环（range）

sum := 0
for i:=1;i<=100;i++{
   sum = sum+i
}
fmt.Println(sum)

str := "hello"
for i:=0;i<len(str);i++{
   fmt.Printf("str[%d] = %c\n",i,str[i])
}

for i,data:=range str{
   fmt.Printf("str[%d] = %c\n",i,data)
}

for i := range str{
   fmt.Printf("str[%d] = %c\n",i,str[i])
}

死循环

package main
import "fmt"
import "time"
func main(){

   i := 0
   for{
      i++
      time.Sleep(time.Second)
      if i==5{
         break //跳出循环
         continue //结束本次循环
      }
      fmt.Println(i)
   }
}

GoTo

fmt.Println("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
fmt.Println("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb")
goto End  //五条件的跳转 End是自己取得名字
fmt.Println("cccccccccccccccccccccccccccccccccccccccccc")
End:
   fmt.Println("dddddddddddddddddddddddddddddddddddddd")

函数

//定义一个不定参数
func Myfunc(args ...int){
   //使用迭代带引出来
   for i,data:=range args{
      fmt.Printf("args[%d] =%d \n",i,data)
   }
   //for循环
   for i:=0;i<len(args);i++{
      fmt.Printf("args[%d] =%d \n",i,args[i])
   }

}
func Myfunc1(a int,args ...int){
   //使用迭代带引出来
   for i,data:=range args{
      fmt.Printf("args[%d] =%d \n",i,data)
   }
   //for循环
   for i:=0;i<len(args);i++{
      fmt.Printf("args[%d] =%d \n",i,args[i])
   }

}

 func main(){
   Myfunc(12,1,3,4)
    Myfunc1(12,1,3,4)
 }

//定义一个不定参数的函数
func myfunc(temp...int){
   //使用迭代的方式输出
   for i,data:=range temp{
      fmt.Printf("temp[%d]=%d\n",i,data)
   }
   //传递到另一个函数中
   //myfunc1(temp...)  //全部参数传给myfunc1的函数
   //myfunc1(temp[:2]...) //传递前两个参数
   myfunc1(temp[2:]...) //传递后两个参数
}

//需要传递的函数
func myfunc1(args...int){
   for i,data:=range args{
      fmt.Printf("args[%d]=%d\n",i,data)
   }
}

func main(){
   myfunc(1,2,3,4)
}

package main

import "fmt"

//定义一个有参数有返回值的函数
func MaxAndMin(a,b int)(max,min int){
   if a>b {
      max = a
      min = b
   }else {
      max = b
      min = a
   }
   return max,min
}


func main(){
   a,b := MaxAndMin(1,3)
   fmt.Printf("a = %d,b = %d\n",a,b)
}

func MyFunc01() (result int) {
   result = 10
   return result
}

//无参多个返回值的函数
func MyFunc02() (a, b, c int) {
   a = 1
   b = 2
   c = 3
   return a, b, c
}

func main() {
   var a int
   a = MyFunc()
   fmt.Println("a=", a)

   b := MyFunc01()
   fmt.Println("b=", b)

   d, e, f := MyFunc02()
   fmt.Printf("d =%d,e=%d,f = %d\n", d, e, f)

}

递归函数

//递归函数
func myfunc(a int){
   if a ==1{
      fmt.Println("a = ",a)
      return
   }
   myfunc(a-1)
   fmt.Println(a)
}

func main(){
   myfunc(3)
}

func Funcsum(a int) int {
   for i := 1; i < 100; i++ {
      a += i
   }
   return a
}

//使用递归的方法实现累加
func funcsum1(b int) int {
   if b == 1 {
      return 1
   }
   return b + funcsum1(b-1)
}

func main() {
   var sum int
   sum = Funcsum(100)
   fmt.Println(sum)

   var sum1 int
   sum1 = funcsum1(100)
   fmt.Println(sum1)

}

//定义一个加法的方法函数
func Add(a,b int)(res int){
   res = a+b
   return res
}

//定义一个减法的法则函数
func JanFa(a,b int)(res int){
   res = a-b
   return res
}
//给函数类型起一个名字 必须是相同的参数还有相同的返回值的函数才能一起
type Fuc func(int,int) int

func main(){
   var result Fuc
   result = Add
   res := result(1,2)
   fmt.Println("a+b=",res)

   result = JanFa
   res1:=result(10,6)
   fmt.Println(res1)
}

指针

//定义一个变量a 并且赋值为10  然后打印变量a的地址值
var a int = 10
fmt.Println(a)//打印a的内存值
fmt.Println(&a) //打印a的地址值

//定义一个变量p来接收a的地址值
var p *int
p = &a
fmt.Println(p)

*p = 999
fmt.Printf("p = %p,a = %p\n",*p,a)

值传递

func swap(a,b int){
   a,b = b,a
   fmt.Println(a,b)
}
//值传递
func main(){
   a,b := 10,20
   swap(a,b)
   fmt.Println(a,b)

地址传递

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

func main(){
   a,b := 10,20
   swap(&a,&b)//地址传递
   fmt.Println(a,b)
}

Array

func main(){
   var a [10]int
   //for i:=0;i<len(a);i++  {
   // a[i] = i+1
   // fmt.Println(i,a[i])
   //}

   for i,data:= range a{
      fmt.Printf("a[%d] = %d\n",i,data+(i+1))
   }
}

数组定义

func main(){
   var a [5]int = [5]int{1,2,3,4,5}
   fmt.Println(a)

   b := [5]int{1,2,3,4,5}
   fmt.Println(b)

   c:= [5]int{1,2,3}
   fmt.Println(c)

   d := [5]int{1:10,2:10}
   fmt.Println(d)

import(
   "fmt"
   "math/rand"
   "time"
)


func main(){
   //产生一个随机数
   var arr [10]int
   rand.Seed(time.Now().UnixNano())
   for i:=0;i<len(arr);i++{
      arr[i] = rand.Intn(100)
   }
   fmt.Println(arr)
   n:=len(arr)
   for i:=0;i<n-1;i++{
      for j:=0;j<n-1-i;j++{
         if arr[j]>arr[j+1] {
            arr[j],arr[j+1] = arr[j+1],arr[j]
         }
      }
   }
   fmt.Println(arr)
}

切片

    //创建一个切片
   s :=[]int{1,2,3,4,5}
   fmt.Println(s)
   fmt.Println(len(s))//切片的长度
   fmt.Println(cap(s))//切片的容量

   s1 := make([]int,5,9)
 fmt.Println(len(s1))//切片的长度
 fmt.Println(cap(s1))//切片的容量
 s3:=append(s, 111)
 fmt.Println(s3)
}

MAP

//定义一个map函数
mp := map[int]string {1:"js",2:"java",3:"go"}
mp[1] = "java1"
fmt.Println(mp)
//map的遍历

for key,value:=range mp{
   fmt.Println(key)
   fmt.Println(value)
}

//如何判断一个key值是否存在

value,ok :=mp[1]
if ok==true{
   fmt.Println(value)
}else{
   fmt.Println("不存在")
}

//初始化一个map函数
a :=map[int] string {1:"java",2:"js"}
fmt.Println(a)
//键值是唯一的

b := make(map[int]string,10)
b[0]= "js"
b[1]= "go"
b[2]= "java"
fmt.Println(len(b))
fmt.Println(b)

删除

func main() {
   //定义一个map函数
   mp := map[int]string{1: "js", 2: "java", 3: "go"}
   delete(mp,1)
   fmt.Println(mp)
}

继承（匿名字段）

//结构体
type Person struct {
   name string
   sex  byte
   age  int
}

//继承人类的结构体
type Student struct {
   Person //只有类型 没有名字 继承人类 匿名字段
   id   int
   addr string
}

func main() {
   //初始化结构体
   var s1 Student = Student{Person{"lei", 'a', 18}, 1, "bj"}
   fmt.Println(s1)

   //使用自动推导类型初始化结构体 没有被赋值的都转换为0
   s2 := Student{id: 1, addr: "bj"}
   fmt.Println(s2)

   s3 :=Student{Person:Person{name:"leilei"},id:2}
   fmt.Println(s3)
   fmt.Printf("s3 = %+v",s3)

}

对成员的操作

s3 :=Student{Person:Person{name:"leilei"},id:2}
//对成员的操作
s3.sex= 's'
s3.age = 99
fmt.Println(s3)
fmt.Printf("s3 = %+v",s3)

方法

//传统的方法
func Add(a,b int) int{
       return a+b
    }

    //面向对象的方法
    //先是给类型变化一个名称
    type long int
    func (a long) Add1(b long) long{
       return a+b
    }

    func main(){
       res := Add(2,3)
       fmt.Println(res)

       var r long
       r = 2
       res1:=r.Add1(2)
       fmt.Println(res1)

结构体的

值传递（方法）

引用传递（方法）

package main

import "fmt"

//定义一个结构体
type Person struct{
   id int
   name string
   age int
}

//定义一个方法 值传递
func (a Person) SetVaule(id int,name string,age int){
   a.id = id
   a.name= name
   a.age = age
   fmt.Println(id,name,age)
}
//定义一个方法 引用传递
func (a *Person) SetVaule1(id int,name string,age int){
   a.id = id
   a.name= name
   a.age = age
   fmt.Println(id,name,age)
}
func main(){
   var p Person = Person{1,"lei",18}
   fmt.Println(p)

   //值传递的调用方式
   p.SetVaule(2,"lei1",20)
   fmt.Println(p)

   //引用传递的调用方式
   (&p).SetVaule1(2,"lei1",20)
   fmt.Println(p)

接口

package main

import "fmt"
//定义一个接口
type Hurmaner interface{
   sayhi()
}
//有一个结构体
type Person struct{
   name string
   age int
   sex byte
}
type Student struct{
   Person
   id int
   addr string
}
type Teather struct{
   tid int
}

func (temp *Person) sayhi(){
      fmt.Println(temp)
}

func (temp *Student) sayhi(){
   fmt.Println(temp)
}
func (temp *Teather) sayhi(){
   fmt.Println(temp)
}

func Whosayhi(i Hurmaner){
   i.sayhi()
}

func main(){
   //1
   var i Hurmaner
   p :=&Person{"lei",18,'n'}
   i = p
   i.sayhi()

   p1 := &Student{Person{"lei",18,'n'},18,"bj"}
   i = p1
   i.sayhi()

   p2 := &Teather{12}
   i = p2
   i.sayhi()
   //2
   s := make([]Hurmaner,3)
   s[0] = p
   s[1] = p1
   s[2] = p2
   for _,k:=range s{
      k.sayhi()
   }
   //3
   Whosayhi(p)
   Whosayhi(p1)
   Whosayhi(p2)

}

1.9+1.8+1.6+1 =6.3

0.7+1.8+1.5+0.6 = 4.6

0.7+0.9+0.8+0.7=3.1

异常处理

error

package main

import(
   "fmt"
   "errors"
)

func Myfuc (a,b int)(res int,err error){
   err = nil
   if b==0 {
      err = errors.New("分母不能为0")
   }else{
      res = a/b
   }
   return
}


func main(){
    r,e:= Myfuc(10,2)
   if e!=nil {
      fmt.Println(e)
   }else{
      fmt.Println(r)
   }
}

panic

package main

import "fmt"

func text() {
   fmt.Println("aaaaaaaaaa")
}
func text1() {
   //fmt.Println("bbbbbbbbbbb")
   panic("这是一个致命的错误")
}
func text2() {
   fmt.Println("cccccccccccc")
}

func main() {
   text()
   text1()
   text2()
}

func text() {
   fmt.Println("aaaaaaaaaa")
}
func text1(a int) {
   //数组越界 定义一个数组
   var arr [10]int//errnot enough arguments in call to text1
   arr[a] = 111
}
func text2() {
   fmt.Println("cccccccccccc")
}

func main() {
   text()
   text1()
   text2()
}

recover

package main

import "fmt"

func text() {
   fmt.Println("aaaaaaaaaa")
}
func text1(a int) {

   defer func(){
      if err:= recover();err != nil {
         fmt.Println(err)
      }
   }()
   //数组越界 定义一个数组
   var arr [10]int//errnot enough arguments in call to text1
   arr[a] = 111
}
func text2() {
   fmt.Println("cccccccccccc")
}

func main() {
   text()
   text1(1)
   text2()
}

String操作

//使用container判断单词是不是在这个字符串中存在
str := "hello world"
fmt.Println(strings.Contains(str,"hello")) //true
fmt.Println(strings.Contains(str,"this")) //false

//使用join实现字符串的组合
/*str1:=make([]string,3,3)
str1[0] = "hello"
str1[1] = "world"
str1[2] = "go"*/
str1:= []string{"hello world go"}
fmt.Println(strings.Join(str1,","))

//使用index知道单词所在的索引
fmt.Println(strings.Index(str,"world"))

//repeat平铺个数
str2:="go"
fmt.Println(strings.Repeat(str2,3))

//使用split实现字符串的拆分
fmt.Println(strings.Split(str,"l"))

//使用trim去掉两头的空格
str2 = "      are you ok     "
fmt.Println(strings.Trim(str2," "))

//去掉空格 吧元素放进切片中
fmt.Println(strings.Fields(str2))
for i,data:= range str2{
   fmt.Println(i,data)
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-N29kw2AT-1587565143444)(C:\Users\Administrator\Desktop\后端相关\pic\微信截图_20200406085802.png)]

结构体转化成json

package main
import(
   "fmt"
   "encoding/json"
)
type Itcast struct{
   Company string
   Subjects []string//切片类型
   Isok bool
   Price float64
}

func main(){
   s:= Itcast{"bj",[]string{"Go","Java","Js"},true,33.33}
   jsonres,err:=json.Marshal(s)
   if err!=nil{
      fmt.Println(err)
      return
   }
   fmt.Println(string(jsonres))
}

Company string `json:"company"`
Subjects []string  `json:"subjects"`
Isok bool  `json:",string"`
Price float64 `json:",string"` //二次编码

import(
   "fmt"
   "encoding/json"
)
func main(){
   //创建一个map对象
   m:=make(map[string]interface{},4)
   m["company"] = "itecast"
   m["subject"] = []string{"Go","Java","Js"}
   m["isok"] = true
   m["price"] =66.6

   //res,err := json.Marshal(m)
   res,err:= json.MarshalIndent(m,"","    ")
   if err!=nil {
      fmt.Println(err)
      return
   }
   fmt.Println(string(res))
}

package main

import(
   "fmt"
   "encoding/json"
)
type Itcast struct{
   Company string `json:"company"`
   Subjects []string  `json:"subjects"`
   Isok bool  `json:"isok"`
   Price float64 `json:"price"` //二次编码
}
func main(){
   jsonbuf:=`{
      "company": "itecast",
         "isok": true,
         "price": 66.6,
         "subject": [
      "Go",
         "Java",
         "Js"
      ]
   }`
   var a Itcast
   err:=json.Unmarshal([]byte(jsonbuf),&a)
   if err!= nil{
      fmt.Println(err)
      return
   }
   fmt.Println(a)
}

并发

package main

import(
   "fmt"
   "sync"
)
var wg sync.WaitGroup
func Hello(){
   fmt.Println("hello 王丽坤")
   wg.Done()//完成之后的通知
}
func main(){
   wg.Add(1)//计数牌+1
   go Hello() //开启协程
   //主协程
   fmt.Println("hello world")
   wg.Wait() //阻塞 等待

}

package main

import(
   "fmt"
   "time"
)

func main(){
   //主协成退出了 别的也跟着退出了
   
   go func() {
      i:=0
      for{
         i++
         fmt.Println("func=",i)
         time.Sleep(time.Second)
      }
   }()
   i:=0
   for{
      i++
      fmt.Println(i)
      time.Sleep(time.Second)
      if i==5 {
         break
      }
   }
}

gosched

当主协程已经完了但是还没有开始协程 runtime.Gosched() 可以使用gosched函数让步

runtime.goexit()是终止协程

runtime.GOMAXPROCS()可以设置以多少核运算

return是终止本次的函数

import (
   "fmt"
   //"runtime"
   "runtime"
)

func main(){
   go func() {
      for i:=0;i<5;i++{
         fmt.Println("bbbbbbbbb")
      }
   }()


   for i:=0;i<5;i++{
      runtime.Gosched()
      fmt.Println("aaaaaaa")
   }
}

channel缓存

//定义一个管道
var n = make(chan int)

package main

import (
   "fmt"
   "time"
)

//打印机
func Print(str string) {
   for _, data := range str {
      fmt.Printf("%c",data)
      time.Sleep(time.Second)
   }
   fmt.Printf("\n")
}

//定义一个管道
var n = make(chan int)

func Person1() {
   Print("hello")
   n <- 888 //输出
}

func Person2() {
   <-n //接收的
   Print("world")
}

func main() {
   go Person1()
   go Person2()

   //主协程
   for {
      i := 0
      i++
      if i == 20 {
         break
      }
   }

}

TCP

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Uki3VXTa-1587565143446)(C:\Users\Administrator\Desktop\后端相关\pic\Tcp.png)]

Mysql数据库

//声明一个全局的db 创建数据库的连接池
var db *sql.DB

数据库中的所有增删改查都是通过db连接池操作的

打开数据库

db, err = sql.Open("mysql", dsn)

db, err = sql.Open("mysql", dsn)
if err != nil {
   return
}
//验证用户名和密码  ping一下数据库
err = db.Ping()
if err != nil {
   return
}

查询数据

单条

row := db.QueryRow(sqlstr, id)

多条

rows,err:=db.Query(sqlstr,id)

多条需要关闭 rows.close() 单条不用

增删改查都是通过

ret,err:=db.Exec(insertsql)

//批量的插入多条数据
func prepareInsert(){
   //sql语句
   insertsql:=`insert into text(text_name,text_age) values (?,?)`
   //预处理吧sql保存起来
   stmt,err:=db.Prepare(insertsql)
   if err!=nil {
      fmt.Printf("stmt err is %v\n",err)
      return
   }
   defer stmt.Close()
   //事后拿stmt做处理
   s:=make(map[string]int,5)
   s["张强"] = 18
   s["小明"] = 89
   s["小李"] = 23
   for key,value:=range s{
      stmt.Exec(key,value)
   }
}

//设置最大的连接数
db.SetMaxOpenConns(10)
//设置最大的空闲连接数
db.SetMaxIdleConns(5)

go mod init 项目名字

开启事务实现过个事务操作

//定义一个管道
var n = make(chan int)

func Person1() {
Print(“hello”)
n <- 888 //输出
}

func Person2() {
<-n //接收的
Print(“world”)
}

func main() {
go Person1()
go Person2()

//主协程
for {
i := 0
i++
if i == 20 {
break
}
}

}


## TCP

[外链图片转存中...(img-Uki3VXTa-1587565143446)]

## Mysql数据库

//声明一个全局的db 创建数据库的连接池
var db *sql.DB


数据库中的所有增删改查都是通过db连接池操作的

打开数据库

db, err = sql.Open(“mysql”, dsn)

db, err = sql.Open(“mysql”, dsn)
if err != nil {
return
}
//验证用户名和密码 ping一下数据库
err = db.Ping()
if err != nil {
return
}


查询数据

单条

row := db.QueryRow(sqlstr, id)


多条

rows,err:=db.Query(sqlstr,id)


多条需要关闭 rows.close() 单条不用

增删改查都是通过

ret,err:=db.Exec(insertsql)

//批量的插入多条数据
func prepareInsert(){
//sql语句
insertsql:=insert into text(text_name,text_age) values (?,?)
//预处理吧sql保存起来
stmt,err:=db.Prepare(insertsql)
if err!=nil {
fmt.Printf(“stmt err is %v\n”,err)
return
}
defer stmt.Close()
//事后拿stmt做处理
s:=make(map[string]int,5)
s[“张强”] = 18
s[“小明”] = 89
s[“小李”] = 23
for key,value:=range s{
stmt.Exec(key,value)
}
}

//设置最大的连接数
db.SetMaxOpenConns(10)
//设置最大的空闲连接数
db.SetMaxIdleConns(5)


## go mod init 项目名字

开启事务 实现过个事务操作

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IePanfAs-1587565143448)(C:\Users\Administrator\Desktop\后端相关\pic\数据库开启事务.png)]