Go语言入坑

2019-10-03 本文已影响0人进击的大东

GO语言基础

认识并安装GO语言开发环境

Go语言简介

Go语言是谷歌2009年发布的第二款开源编程语言
go语言专门针对多处理器系统应用程序的编程进行了优化,使用Go编译的程序可以媲美C或C++代码的速度,而且更加安全,支持并行进程

Go语言特点

简洁、快速、安全
并行、有趣、开源
内存管理，数组安全，编译迅速

Go语言开发的应用

docker
Codis(豆瓣开发的大部分使用go语言)
Glow类似于hadoop
cockroach

一些见解

Java语言的份额继续下滑，并最终被C和Go语言超越；
C语言将长居编程榜第二的位置，并有望在Go取代java前重获语言榜第一的宝座
Go语言最终会取代java，居于编程榜之首

Go语言环境搭建

go源码安装
go标准包安装
第三方工具安装比如GVM
go语言开发工具
- LiteIDE
- IDE
- eclipese、sublime

GO语言基础知识

第一个Go应用HelloWord

<pre spellcheck="false" class="md-fences md-end-block ty-contain-cm modeLoaded" lang="" cid="n57" mdtype="fences" style="box-sizing: border-box; overflow: visible; font-family: Menlo, Monaco, "Courier New", monospace; font-size: 1.125rem; display: block; break-inside: avoid; text-align: left; white-space: normal; background: inherit; position: relative !important; color: rgb(122, 122, 122); padding: 0.5rem 1.125em; margin-bottom: 0.88em; border: 1px solid rgb(122, 122, 122); margin-top: 0px; line-height: 1.5rem; width: inherit;">package main
import "fmt"
func main(){
//go语言不强制加分号
fmt.Print("Hello word")
}
//cmd输入 go run hello.go输出结果</pre>

配置

go语言依赖一个重要得环境变量：$GOPATH(不是安装目录)
- 使用go get github.com/astaxie/beego命令下载框架失败，是因为未配置gopath
- set GOPATH=e:/go_path:设置gopath路径
- echo %GOPATH%:查看gopath路径
- gopath得作用
  - 下载第三方代码
  - 包管理与引用
  - gopath多个包调用代码练习

Go语言常用关键字

break default func interface select case defer go map struct chan else goto package switch const fallthrough if range type continue for import return var
- package main下得main()函数是go语言得入口
- var：关键字是go最基本得定义变量的方式，与C语言不同的是Go把变量类型放在变量名后面
  - 例:var x int

Go语言开发工具liteide

创建应用编译
y:="hello" //简短声明的使用，可定义多个
代码：
- <pre spellcheck="false" class="md-fences md-end-block ty-contain-cm modeLoaded" lang="" cid="n100" mdtype="fences" style="box-sizing: border-box; overflow: visible; font-family: Menlo, Monaco, "Courier New", monospace; font-size: 1.125rem; display: block; break-inside: avoid; text-align: left; white-space: normal; background: inherit; position: relative !important; color: rgb(122, 122, 122); padding: 0.5rem 1.125em; margin-bottom: 0.88em; border: 1px solid rgb(122, 122, 122); margin-top: 0px; line-height: 1.5rem; width: inherit;">package main
  
  import "fmt"
  
  func main() {
  var x int
  x = 1
  //这种用法须在函数体内
  y, z := "go demo", 2
  fmt.Printf("%d %s %d", x, y, z)
  }
  </pre>

go语言数据类型

bool
runne
int8、int16、int32、int64
byte
unit8、unit16、unit32、unit64
flot32、float64
complex64、complex128
string
array slice
map

其它基础

数组的定义
其它数据类型的使用
s:=make([]int,10,20)//slice动态数组对象
map:student:=make(map[string]int)
- make用于内建类型(map、slice、channel)的内存分配
流程控制语句
- if语句
- for
  - <pre spellcheck="false" class="md-fences md-end-block ty-contain-cm modeLoaded" lang="" cid="n145" mdtype="fences" style="box-sizing: border-box; overflow: visible; font-family: Menlo, Monaco, "Courier New", monospace; font-size: 1.125rem; display: block; break-inside: avoid; text-align: left; white-space: normal; background: inherit; position: relative !important; color: rgb(122, 122, 122); padding: 0.5rem 1.125em; margin-bottom: 0.88em; border: 1px solid rgb(122, 122, 122); margin-top: 0px; line-height: 1.5rem; width: inherit;">func main() {
    sum := 0
    x := 1
    for x <= 100 {
    sum += x
    x++
    }
    fmt.Print(sum)
    }</pre>
- switch
  - <pre spellcheck="false" class="md-fences md-end-block ty-contain-cm modeLoaded" lang="" cid="n150" mdtype="fences" style="box-sizing: border-box; overflow: visible; font-family: Menlo, Monaco, "Courier New", monospace; font-size: 1.125rem; display: block; break-inside: avoid; text-align: left; white-space: normal; background: inherit; position: relative !important; color: rgb(122, 122, 122); padding: 0.5rem 1.125em; margin-bottom: 0.88em; border: 1px solid rgb(122, 122, 122); margin-top: 0px; line-height: 1.5rem; width: inherit;">x:=1
    switch x{
    case 1:
    fmt.Print("demo1")
    //GO默认添加了break
    break
    case 2:
    //继续需要添加
    fallthrough
    case 3:
    fmt.Print("demo2")
    break
    default 3:
    fmt.Print("demo3")
    }</pre>
- for循环
  - <pre spellcheck="false" class="md-fences md-end-block ty-contain-cm modeLoaded" lang="" cid="n155" mdtype="fences" style="box-sizing: border-box; overflow: visible; font-family: Menlo, Monaco, "Courier New", monospace; font-size: 1.125rem; display: block; break-inside: avoid; text-align: left; white-space: normal; background: inherit; position: relative !important; color: rgb(122, 122, 122); padding: 0.5rem 1.125em; margin-bottom: 0.88em; border: 1px solid rgb(122, 122, 122); margin-top: 0px; line-height: 1.5rem; width: inherit;">x := [5]int{1, 2, 3, 4, 5}
    for i, v := range x {
    fmt.Println(i, v)
    }
    x := make(map[string]int)
    x["zhangsan"] = 78
    x["lisi"] = 90
    x["wangwu"] = 100
    for i, v := range x {
    fmt.Println(i, v)
    }
    x := "zhangsan"
    for _, v := range x {
    fmt.Printf("%c\n", v)
    }</pre>
Go语言函数
- <pre spellcheck="false" class="md-fences md-end-block ty-contain-cm modeLoaded" lang="" cid="n160" mdtype="fences" style="box-sizing: border-box; overflow: visible; font-family: Menlo, Monaco, "Courier New", monospace; font-size: 1.125rem; display: block; break-inside: avoid; text-align: left; white-space: normal; background: inherit; position: relative !important; color: rgb(122, 122, 122); padding: 0.5rem 1.125em; margin-bottom: 0.88em; border: 1px solid rgb(122, 122, 122); margin-top: 0px; line-height: 1.5rem; width: inherit;">func funcName(input1 type1,input2 type2)(output1 type1,output2 type2){
  //逻辑处理代码
  //返回多个值
  return value1,value2
  }
  package main
  
  import "fmt"
  
  func swap(a int, b int) (int, n int) {
  return b, a
  }
  func main() {
  a := 1
  b := 2
  a, b = swap(a, b)
  fmt.Printf("%d %d", a, b)
  }
  //匿名函数
  f:=func(x,y int)int{
  return x+y
  }
  fmt.Println(f(2,3))</pre>
- go语言中指针的概念
- defer关键词使执行顺序倒着走，退出或资源关闭时使用
  - <pre spellcheck="false" class="md-fences md-end-block ty-contain-cm modeLoaded" lang="" cid="n167" mdtype="fences" style="box-sizing: border-box; overflow: visible; font-family: Menlo, Monaco, "Courier New", monospace; font-size: 1.125rem; display: block; break-inside: avoid; text-align: left; white-space: normal; background: inherit; position: relative !important; color: rgb(122, 122, 122); padding: 0.5rem 1.125em; margin-bottom: 0.88em; border: 1px solid rgb(122, 122, 122); margin-top: 0px; line-height: 1.5rem; width: inherit;">defer func() {
    fmt.Println("After defer")
    }()
    fmt.Println("befor defer")
    //defer语句遇到异常继续执行</pre>
Go语言结构struct
- <pre spellcheck="false" class="md-fences md-end-block ty-contain-cm modeLoaded" lang="" cid="n172" mdtype="fences" style="box-sizing: border-box; overflow: visible; font-family: Menlo, Monaco, "Courier New", monospace; font-size: 1.125rem; display: block; break-inside: avoid; text-align: left; white-space: normal; background: inherit; position: relative !important; color: rgb(122, 122, 122); padding: 0.5rem 1.125em; margin-bottom: 0.88em; border: 1px solid rgb(122, 122, 122); margin-top: 0px; line-height: 1.5rem; width: inherit;">package main
  import "fmt"
  type Person struct {
  name string
  age int
  }
  type Student struct{
  Person//匿名字段，使用和类包含类似
  speciality string
  }
  func main() {
  person := Person{"zhangsan", 25}
  // person2 :=Person{age:25,name:"wangwu"}//指定字段赋值
  fmt.Printf("%v", person)
  }</pre>

GO语言面向对象

类的定义与使用

简单定义使用
- <pre spellcheck="false" class="md-fences md-end-block ty-contain-cm modeLoaded" lang="" cid="n180" mdtype="fences" style="box-sizing: border-box; overflow: visible; font-family: Menlo, Monaco, "Courier New", monospace; font-size: 1.125rem; display: block; break-inside: avoid; text-align: left; white-space: normal; background: inherit; position: relative !important; color: rgb(122, 122, 122); padding: 0.5rem 1.125em; margin-bottom: 0.88em; border: 1px solid rgb(122, 122, 122); margin-top: 0px; line-height: 1.5rem; width: inherit;">package main
  
  import "fmt"
  
  type Integer struct {
  value int
  }
  
  func (a Integer) compare(b Integer) bool {
  return a.value < b.value
  }
  func main() {
  // var a int =1
  // var b int =2
  a := Integer{1}
  b := Integer{2}
  fmt.Printf("%v", a.compare(b))
  }
  </pre>
go中类的初始化
- <pre spellcheck="false" class="md-fences md-end-block ty-contain-cm modeLoaded" lang="" cid="n185" mdtype="fences" style="box-sizing: border-box; overflow: visible; font-family: Menlo, Monaco, "Courier New", monospace; font-size: 1.125rem; display: block; break-inside: avoid; text-align: left; white-space: normal; background: inherit; position: relative !important; color: rgb(122, 122, 122); padding: 0.5rem 1.125em; margin-bottom: 0.88em; border: 1px solid rgb(122, 122, 122); margin-top: 0px; line-height: 1.5rem; width: inherit;">point:=new(Point)
  point:=&Point{}
  point:=&Point{x:100,y:100}
  point:=Point{}</pre>
- 定义与使用示例
  - <pre spellcheck="false" class="md-fences md-end-block ty-contain-cm modeLoaded" lang="" cid="n190" mdtype="fences" style="box-sizing: border-box; overflow: visible; font-family: Menlo, Monaco, "Courier New", monospace; font-size: 1.125rem; display: block; break-inside: avoid; text-align: left; white-space: normal; background: inherit; position: relative !important; color: rgb(122, 122, 122); padding: 0.5rem 1.125em; margin-bottom: 0.88em; border: 1px solid rgb(122, 122, 122); margin-top: 0px; line-height: 1.5rem; width: inherit;">package main
    import "fmt"
    type Point struct {
    px float32
    py float32
    }
    func (point *Point) setxy(px, py float32) {
    point.px = px
    point.py = py
    }
    func (point *Point) getxy() (float32, float32) {
    return point.px, point.py
    }
    func main() {
    point := new(Point)
    point.setxy(1.24, 4.25)
    px, py := point.getxy()
    fmt.Print(px, py)
    }</pre>

类的继承与使用

<pre spellcheck="false" class="md-fences md-end-block ty-contain-cm modeLoaded" lang="" cid="n194" mdtype="fences" style="box-sizing: border-box; overflow: visible; font-family: Menlo, Monaco, "Courier New", monospace; font-size: 1.125rem; display: block; break-inside: avoid; text-align: left; white-space: normal; background: inherit; position: relative !important; color: rgb(122, 122, 122); padding: 0.5rem 1.125em; margin-bottom: 0.88em; border: 1px solid rgb(122, 122, 122); margin-top: 0px; line-height: 1.5rem; width: inherit;">package main

import "fmt"

type Person struct {
name string
age int
}

func (person Person) getNameAndAge() (string, int) {
return person.name, person.age
}

type Student struct {
Person
speciality string
}

func (student Student) getSpeciality() string {
return student.speciality
}
func main() {
student := new(Student)
student.name = "zhangsan"
student.age = 26
name, age := student.getNameAndAge()
fmt.Println(name, age)
}</pre>
Go语言接口
- 在go语言中，一个类只需要实现了接口要求的所有函数，我们就说这个类实现了该接口
  - <pre spellcheck="false" class="md-fences md-end-block ty-contain-cm modeLoaded" lang="" cid="n202" mdtype="fences" style="box-sizing: border-box; overflow: visible; font-family: Menlo, Monaco, "Courier New", monospace; font-size: 1.125rem; display: block; break-inside: avoid; text-align: left; white-space: normal; background: inherit; position: relative !important; color: rgb(122, 122, 122); padding: 0.5rem 1.125em; margin-bottom: 0.88em; border: 1px solid rgb(122, 122, 122); margin-top: 0px; line-height: 1.5rem; width: inherit;">package main
    
    import "fmt"
    //非侵入式接口
    type Animal interface {
    Fly()
    Run()
    }
    type Animal2 interface {
    Fly()
    }
    type Bird struct {
    }
    func (bird Bird) Fly() {
    fmt.Println("bird is flying")
    }
    func (bird Bird) Run() {
    fmt.Println("bird is Run")
    }
    func main() {
    var animal Animal
    var animal2 Animal2
    bird := new(Bird)
    animal = bird
    animal2=bird
    animal2.FLy()
    animal2=animal//在GO中可以接口赋值
    animal.Fly()
    animal.Run()
    }</pre>
- 在Go语言中空间口类似泛型
  - <pre spellcheck="false" class="md-fences md-end-block ty-contain-cm modeLoaded" lang="" cid="n207" mdtype="fences" style="box-sizing: border-box; overflow: visible; font-family: Menlo, Monaco, "Courier New", monospace; font-size: 1.125rem; display: block; break-inside: avoid; text-align: left; white-space: normal; background: inherit; position: relative !important; color: rgb(122, 122, 122); padding: 0.5rem 1.125em; margin-bottom: 0.88em; border: 1px solid rgb(122, 122, 122); margin-top: 0px; line-height: 1.5rem; width: inherit;">var v1=interface{}
    v1=6.78
    fmt.Print(v1)
    //类型查询,看接口接收的什么类型
    if v, ok := v1.(float64); ok {
    fmt.Println(v, ok)
    }</pre>

GO语言进阶

GO语言并发编程

Go语言并发编程之协程

与传统的系统级线程相比,协程的大优势在于其"轻量级",可以轻松创建上百万个而不会导致系统资源衰竭,而线程和进程通常多也不能超过1万个,这也是协程也叫轻量级线程的原因.
go对协程的实现:go+函数名:启动一个协程执行函数体
- <pre spellcheck="false" class="md-fences md-end-block ty-contain-cm modeLoaded" lang="" cid="n218" mdtype="fences" style="box-sizing: border-box; overflow: visible; font-family: Menlo, Monaco, "Courier New", monospace; font-size: 1.125rem; display: block; break-inside: avoid; text-align: left; white-space: normal; background: inherit; position: relative !important; color: rgb(122, 122, 122); padding: 0.5rem 1.125em; margin-bottom: 0.88em; border: 1px solid rgb(122, 122, 122); margin-top: 0px; line-height: 1.5rem; width: inherit;">package main
  import (
  "fmt"
  "time"
  )
  func test_Routine() {
  fmt.Println("This is one routine!")
  }
  func main() {
  go test_Routine()
  time.Sleep(1)
  }</pre>
Go并发编程之channel
- Channel:Go语言在语言级别提供的goroutine间的通讯方式
  - 声明方式:var chanName chan ElementType
    - <pre spellcheck="false" class="md-fences md-end-block ty-contain-cm modeLoaded" lang="" cid="n229" mdtype="fences" style="box-sizing: border-box; overflow: visible; font-family: Menlo, Monaco, "Courier New", monospace; font-size: 1.125rem; display: block; break-inside: avoid; text-align: left; white-space: normal; background: inherit; position: relative !important; color: rgb(122, 122, 122); padding: 0.5rem 1.125em; margin-bottom: 0.88em; border: 1px solid rgb(122, 122, 122); margin-top: 0px; line-height: 1.5rem; width: inherit;">package main
      
      import (
      "fmt"
      "strconv"
      )
      
      func Add(x, y int, quit chan int) {
      z := x + y
      fmt.Println(z)
      quit <- 1
      }
      func Read(ch chan int) {
      value := <-ch
      fmt.Println("value:" + strconv.Itoa(value))
      }
      func Write(ch chan int) {
      // ch < -10
      }
      func main() {
      chs := make([]chan int, 10)
      for i := 0; i < 10; i++ {
      chs[i] = make(chan int)
      go Add(i, i, chs[i])
      }
      for _, v := range chs {
      <-v
      }
      }</pre>
- 缓存channel
  - <pre spellcheck="false" class="md-fences mock-cm md-end-block" lang="" cid="n235" mdtype="fences" style="box-sizing: border-box; overflow: visible; font-family: Menlo, Monaco, "Courier New", monospace; font-size: 1.125rem; display: block; break-inside: avoid; text-align: left; white-space: pre-wrap; background: inherit; position: relative !important; color: rgb(122, 122, 122); padding: 0.5rem 1.125em; margin-bottom: 0.88em; border: 1px solid rgb(122, 122, 122); margin-top: 0px; line-height: 1.5rem; width: inherit;">package main
    
    import (
    "fmt"
    "time"
    )
    
    var ch chan int
    
    func test_channel() {
    // ch := make(chan int)
    ch <- 1
    fmt.Println("come to end goroutline 1")
    }
    func main() {
    ch = make(chan int, 2) //值是1和值是0的适合输出执行顺序不同
    go test_channel()
    time.Sleep(2 * time.Second)
    fmt.Println("running end!")
    <-ch
    time.Sleep(time.Second)
    }
    </pre>
- select
  - 是linux很早就引入的函数,用来实现非阻塞的一种方式
  - go语言提供语言级别支持slelect关键字,用于处理异步IO问题
    - <pre spellcheck="false" class="md-fences mock-cm md-end-block" lang="" cid="n245" mdtype="fences" style="box-sizing: border-box; overflow: visible; font-family: Menlo, Monaco, "Courier New", monospace; font-size: 1.125rem; display: block; break-inside: avoid; text-align: left; white-space: pre-wrap; background: inherit; position: relative !important; color: rgb(122, 122, 122); padding: 0.5rem 1.125em; margin-bottom: 0.88em; border: 1px solid rgb(122, 122, 122); margin-top: 0px; line-height: 1.5rem; width: inherit;">select{
      case <-chan1://如果chan1成功读取到数据,则进行该case处理语句
      case chan2 <-1://如果成功向chan2写入数据,则进行该case处理
      default: //如果上面都没有成功,则进入default处理流程
      }
      </pre>
  - select 三个代码示例
    - 示例1
      
      <pre spellcheck="false" class="md-fences mock-cm md-end-block" lang="" cid="n251" mdtype="fences" style="box-sizing: border-box; overflow: visible; font-family: Menlo, Monaco, "Courier New", monospace; font-size: 1.125rem; display: block; break-inside: avoid; text-align: left; white-space: pre-wrap; background: inherit; position: relative !important; color: rgb(122, 122, 122); padding: 0.5rem 1.125em; margin-bottom: 0.88em; border: 1px solid rgb(122, 122, 122); line-height: 1.5rem; width: inherit;">package main
      
      import (
      "fmt"
      "time"
      )
      
      func main() {
      ch := make(chan int)
      go func(ch chan int) {
      ch <- 1
      }(ch)
      // time.Sleep(2)//加这一句执行结果不同
      select {
      case <-ch:
      fmt.Print("come to read ch!")
      default:
      fmt.Print("come to default!")
      }
      }
      </pre>
    - 示例2
      
      <pre spellcheck="false" class="md-fences mock-cm md-end-block" lang="" cid="n254" mdtype="fences" style="box-sizing: border-box; overflow: visible; font-family: Menlo, Monaco, "Courier New", monospace; font-size: 1.125rem; display: block; break-inside: avoid; text-align: left; white-space: pre-wrap; background: inherit; position: relative !important; color: rgb(122, 122, 122); padding: 0.5rem 1.125em; margin-bottom: 0.88em; border: 1px solid rgb(122, 122, 122); line-height: 1.5rem; width: inherit;">package main
      
      //超时控制的经典实现
      import (
      "fmt"
      "time"
      )
      
      func main() {
      ch := make(chan int)
      timeout := make(chan int, 1)
      go func() {
      time.Sleep(time.Second)
      timeout <- 1
      }()
      select {
      case <-ch:
      fmt.Println("come to read ch!")
      case <-timeout:
      fmt.Println("come to timeout")
      }
      fmt.Print("end of code!")
      }
      </pre>
    - 示例3
      
      <pre spellcheck="false" class="md-fences mock-cm md-end-block" lang="" cid="n257" mdtype="fences" style="box-sizing: border-box; overflow: visible; font-family: Menlo, Monaco, "Courier New", monospace; font-size: 1.125rem; display: block; break-inside: avoid; text-align: left; white-space: pre-wrap; background: inherit; position: relative !important; color: rgb(122, 122, 122); padding: 0.5rem 1.125em; margin-bottom: 0.88em; border: 1px solid rgb(122, 122, 122); line-height: 1.5rem; width: inherit;">package main
      
      //超时控制的经典实现
      import (
      "fmt"
      "time"
      )
      
      func main() {
      ch := make(chan int)
      select {
      case <-ch:
      fmt.Println("come to read ch!")
      case <-time.After(time.Second):
      fmt.Println("come to timeout")
      }
      fmt.Print("end of code!")
      }
      </pre>
深入Go协程编程
- 协程与线程质的不同
  - 协程任务的业务代码主动要求切换,即主动让出执行权
  - 发生了IO,导致执行阻塞
- 线程与协程代码对比(线程几百个就卡,协程十万个都不算多)
  - Java线程
    
    <pre spellcheck="false" class="md-fences mock-cm md-end-block" lang="" cid="n273" mdtype="fences" style="box-sizing: border-box; overflow: visible; font-family: Menlo, Monaco, "Courier New", monospace; font-size: 1.125rem; display: block; break-inside: avoid; text-align: left; white-space: pre-wrap; background: inherit; position: relative !important; color: rgb(122, 122, 122); padding: 0.5rem 1.125em; margin-bottom: 0.88em; border: 1px solid rgb(122, 122, 122); line-height: 1.5rem; width: inherit;">public class MyThread{
    public static void main(String[] args){
    new Thread(new Test_thread()).start();
    new Thread(new Test_thread2()).start()
    }
    }
    class Test_thread implements Runnable{
    public void run(){
    for(int i=0;i<100;i++){
    System.out.println("thread 1:"+i)
    }
    }
    }
    class Test_thread2 implements Runnable{
    public void run(){
    for(int i=100;i<200;i++){
    System.out.println("thread 2:+i);
    }
    }
    }
    </pre>
  - Go协程
    
    <pre spellcheck="false" class="md-fences mock-cm md-end-block" lang="" cid="n276" mdtype="fences" style="box-sizing: border-box; overflow: visible; font-family: Menlo, Monaco, "Courier New", monospace; font-size: 1.125rem; display: block; break-inside: avoid; text-align: left; white-space: pre-wrap; background: inherit; position: relative !important; color: rgb(122, 122, 122); padding: 0.5rem 1.125em; margin-bottom: 0.88em; border: 1px solid rgb(122, 122, 122); line-height: 1.5rem; width: inherit;">package main
    import (
    "fmt"
    // "runtime"
    "strconv"
    "time"
    )
    func main() {
    //协程1
    go func() {
    for i := 1; i < 100; i++ {
    if i == 10 {
    // runtime.Gosched() //主动要求切换CPU
    <-ch //遇到阻塞主动让出,否则一直执行下去
    }
    fmt.Println("routine 1:" + strconv.Itoa(i))
    }
    }()
    //协程2
    go func() {
    for i := 100; i < 200; i++ {
    fmt.Println("routine 2:" + strconv.Itoa(i))
    }
    }()
    time.Sleep(time.Second)
    }
    </pre>

GO语言JSON与MD5

Go语言的JSON

使用的库
- Go语言内置的encoding/json标准库:性能不太好
- github.com/pquerna/ffjson/ffjson
json使用代码

<pre spellcheck="false" class="md-fences mock-cm md-end-block" lang="" cid="n289" mdtype="fences" style="box-sizing: border-box; overflow: visible; font-family: Menlo, Monaco, "Courier New", monospace; font-size: 1.125rem; display: block; break-inside: avoid; text-align: left; white-space: pre-wrap; background: inherit; position: relative !important; color: rgb(122, 122, 122); padding: 0.5rem 1.125em; margin-bottom: 0.88em; border: 1px solid rgb(122, 122, 122); line-height: 1.5rem; width: inherit;">package main

import (
"encoding/json"
"fmt"
)

type Student struct {
Name string //外部要引用要首字母大写
Age int
}

func main() {
//对数组类型的json编码
x := [5]int{1, 2, 3, 4, 5}
s, err := json.Marshal(x)
if err != nil {
panic(err)
}
fmt.Println(string(s))
//对map类型进行json编码
m := make(map[string]float64)
m["zhangsan"] = 100.4
s2, err2 := json.Marshal(m)
if err2 != nil {
panic(err2)
}
fmt.Println(string(s2))
//对对象进行json编码
student := Student{"zhangsan", 26}
s3, err3 := json.Marshal(student)
if err3 != nil {
panic(s3)
}
fmt.Println(string(s3))
//对s3进行解码
var s4 interface{}
json.Unmarshal([]byte(s3), &s4)
fmt.Printf("%v", s4)
}
</pre>
md5使用

<pre spellcheck="false" class="md-fences mock-cm md-end-block" lang="" cid="n292" mdtype="fences" style="box-sizing: border-box; overflow: visible; font-family: Menlo, Monaco, "Courier New", monospace; font-size: 1.125rem; display: block; break-inside: avoid; text-align: left; white-space: pre-wrap; background: inherit; position: relative !important; color: rgb(122, 122, 122); padding: 0.5rem 1.125em; margin-bottom: 0.88em; border: 1px solid rgb(122, 122, 122); line-height: 1.5rem; width: inherit;">package main

import (
"crypto/md5"
"fmt"
)

func main() {
Md5Inst := md5.New()
Md5Inst.Write([]byte("zhangsan"))
Result := Md5Inst.Sum([]byte(""))
fmt.Printf("%x\n\n", Result)
}
</pre>

GO语言HTTP

go语言标准库内建提供了net/http包
处理http请求:使用net/http包提供的http.ListenAndServer()方法,可以在指定的地址进行监听,开启一个HTTP.服务端该方法的原型如下:func ListenAndServe(addr string,hander Handler)error
- 该方法用于在指定的TCP网络地址addr进行监听,然后调用服务端处理程序来处理传入的链接请求.该方法有两个参数:第一个参数addr即监听地址;第二个服务表示服务端处理程序,通常为空,这意味着服务端调用http.DefaultServeMux进行处理,而服务端编写的业务逻辑处理程序http.Handle()或http.HandleFunc()默认注入http.DefaultServeMux中
处理https请求
- func ListenAndServeTLS(addr string,certFile string,keyFile string,handler Handler) error
- http.HandleFunc()方法接受两个参数
  - 第一个参数是http请求的目标路径"/hello",该参数值可以是字符串,也可以是字符串形式的正则表达式,第二个参数指定具体的回调方法,比如helloHandler
  - 当我们的程序运行起来后,访问-http://localhost:8080/hello,程序就会去调用hellloHandler()方法中的业务逻辑程序
http中get和postdaima
- <pre spellcheck="false" class="md-fences mock-cm md-end-block" lang="" cid="n318" mdtype="fences" style="box-sizing: border-box; overflow: visible; font-family: Menlo, Monaco, "Courier New", monospace; font-size: 1.125rem; display: block; break-inside: avoid; text-align: left; white-space: pre-wrap; background: inherit; position: relative !important; color: rgb(122, 122, 122); padding: 0.5rem 1.125em; margin-bottom: 0.88em; border: 1px solid rgb(122, 122, 122); margin-top: 0px; line-height: 1.5rem; width: inherit;">//get代码
  package main
  
  import (
  "fmt"
  "io/ioutil"
  "net/http"
  )
  
  func main() {
  resp, err := http.Get("http://www.baidu.com")
  if err != nil {
  panic(err)
  }
  defer resp.Body.Close()
  body, err := ioutil.ReadAll(resp.Body)
  fmt.Println(string(body))
  }
  //post代码
  package main
  
  import (
  "fmt"
  "io/ioutil"
  "net/http"
  "strings"
  )
  
  func main() {
  resp, err := http.Post("http://www.baidu.com", "application/x-www.form-urlencoded", strings.NewReader("id=1"))
  if err != nil {
  panic(err)
  }
  defer resp.Body.Close()
  body, err := ioutil.ReadAll(resp.Body)
  fmt.Println(string(body))
  }
  </pre>

GO语言正则表达式

Go语言标准库内建提供了regexp包

正则字母含义
- .匹配除换行符以外的任意字符
- \w匹配字母或数字或下划线或汉字
- \s匹配任意的空白符
- \d匹配数字
- \b匹配单词的开始或结束
- ^匹配字符串的开始
- $匹配字符串的结束
- *重复零次或更多次
- +重复一次或更多次
- ?重复零次或一次
- {n}重复n次
- {n,}重复n次或更多次
- {n,m}重复n到m次
- 捕获(exp) 匹配exp,并捕获文本到自动命名的阻组里
- (?<name>exp) 匹配exp,并捕获文本到名称为name的组里,也可以写成(?'name'exp)
- (?:exp)匹配exp,不捕获匹配的文本,也不给此分组分配组号
正则函数
- func Match(pattern string,b []byte)(matched bool,err error)
- func MatchString(pattern string,s string)(matched bool,err error)
- func MustCompile(str string)*Regexp
- func(re * Regexp)FindAllString(s string,n int)[]string
代码演示
- <pre spellcheck="false" class="md-fences mock-cm md-end-block" lang="" cid="n372" mdtype="fences" style="box-sizing: border-box; overflow: visible; font-family: Menlo, Monaco, "Courier New", monospace; font-size: 1.125rem; display: block; break-inside: avoid; text-align: left; white-space: pre-wrap; background: inherit; position: relative !important; color: rgb(122, 122, 122); padding: 0.5rem 1.125em; margin-bottom: 0.88em; border: 1px solid rgb(122, 122, 122); margin-top: 0px; line-height: 1.5rem; width: inherit;">package main
  
  import (
  "fmt"
  "regexp"
  )
  
  func main() {
  isok, _ := regexp.Match("[a-zA-Z]{3}", []byte("zhl"))
  fmt.Printf("%v", isok)
  reg1 := regexp.MustCompile(^z(.*)l<pre spellcheck="false" class="md-fences mock-cm md-end-block" lang="" cid="n372" mdtype="fences" style="box-sizing: border-box; overflow: visible; font-family: Menlo, Monaco, "Courier New", monospace; font-size: 1.125rem; display: block; break-inside: avoid; text-align: left; white-space: pre-wrap; background: inherit; position: relative !important; color: rgb(122, 122, 122); padding: 0.5rem 1.125em; margin-bottom: 0.88em; border: 1px solid rgb(122, 122, 122); margin-top: 0px; line-height: 1.5rem; width: inherit;") result1 := reg1.FindAllString("zhangsan", -1) fmt.Printf("%v\n", result1) reg2 := regexp.MustCompile(z(.{1})(.{1})(.*)l<pre spellcheck="false" class="md-fences mock-cm md-end-block" lang="" cid="n372" mdtype="fences" style="box-sizing: border-box; overflow: visible; font-family: Menlo, Monaco, "Courier New", monospace; font-size: 1.125rem; display: block; break-inside: avoid; text-align: left; white-space: pre-wrap; background: inherit; position: relative !important; color: rgb(122, 122, 122); padding: 0.5rem 1.125em; margin-bottom: 0.88em; border: 1px solid rgb(122, 122, 122); margin-top: 0px; line-height: 1.5rem; width: inherit;")
  result2 := reg2.FindAllStringSubmatch("zhangsan", -1)
  fmt.Printf("%v\n", result2)
  
  }
  
  </pre>
- 代码演示2
  
  <pre spellcheck="false" class="md-fences mock-cm md-end-block" lang="" cid="n375" mdtype="fences" style="box-sizing: border-box; overflow: visible; font-family: Menlo, Monaco, "Courier New", monospace; font-size: 1.125rem; display: block; break-inside: avoid; text-align: left; white-space: pre-wrap; background: inherit; position: relative !important; color: rgb(122, 122, 122); padding: 0.5rem 1.125em; margin-bottom: 0.88em; border: 1px solid rgb(122, 122, 122); line-height: 1.5rem; width: inherit;">package main
  
  import (
  "fmt"
  "io/ioutil"
  "net/http"
  "regexp"
  )
  
  func main() {
  url := "https://movie.douban.com/subject/1292052/"
  resp, err := http.Get(url)
  if err != nil {
  panic(err)
  }
  defer resp.Body.Close()
  sHtml, _ := ioutil.ReadAll(resp.Body)
  // fmt.Println(string(sHtml))
  reg := regexp.MustCompile(<span\s*property="v:itemreviewed">(.*)</span>)
  result := reg.FindAllStringSubmatch(string(sHtml), -1)
  // fmt.Printf("%v", result)
  // for _, v := range result {
  // fmt.Println(v[1])
  // }
  fmt.Println(result[0][1])
  reg1 := regexp.MustCompile(<strong\s*class="ll\s*rating_num"\s*property="v:average">(.*)</strong>)
  result1 := reg1.FindAllStringSubmatch(string(sHtml), -1)
  fmt.Println(result1[0][1])
  }
  </pre>

GO语言Mysql与Redis

Go语言使用mysql驱动包:https://github.com/Go-SQL-Driver/Mysql

使用sql.open()函数用来打开一个注册过的数据库驱动,Go-MySQL-Driver中注册了mysql这个数据库的驱动,第二个参数是DNS(Data Source Name),它是Go-MySQL-Driver定义的一些数据库链接和配置信息.它支持如下格式
- user@unix(/path/to/socket)/dbname?charset=utf8
- user:password@tcp(localhost:5555)/dbname?chaset=utf8
Go语言操作mysql代码
- <pre spellcheck="false" class="md-fences mock-cm md-end-block" lang="" cid="n390" mdtype="fences" style="box-sizing: border-box; overflow: visible; font-family: Menlo, Monaco, "Courier New", monospace; font-size: 1.125rem; display: block; break-inside: avoid; text-align: left; white-space: pre-wrap; background: inherit; position: relative !important; color: rgb(122, 122, 122); padding: 0.5rem 1.125em; margin-bottom: 0.88em; border: 1px solid rgb(122, 122, 122); margin-top: 0px; line-height: 1.5rem; width: inherit;">package main
  
  import (
  "database/sql"
  "fmt"
```
_ "github.com/go-sql-driver/mysql"
```
  )
  
  func main() {
  db, err := sql.Open("mysql", "root:123456@tcp(127.0.0.1:3306)/cost?charset=utf8")
  if err != nil {
  panic(err)
  }
  //插入
  // stmt, err := db.Prepare("insert test set t_id=?,t_name=?,t_time=?")
  // res, err := stmt.Exec(998, "zhangsan", "2019-01-02")
  // id, err := res.LastInsertId()
  //修改
  // stmt, err := db.Prepare("update test set t_name=? where t_id=?")
  // res, err := stmt.Exec("lisi", 999)
  // id, err := res.RowsAffected()
  //数据库一主多从,从库多是用来查询的
  //查询
  rows, err := db.Query("select * from test where t_id=999")
  if err != nil {
  panic(err)
  }
  for rows.Next() {
  var t_id int
  var t_name string
  var t_time string
  err = rows.Scan(&t_id, &t_name, &t_time)
  fmt.Println(t_id, t_name, t_time)
  }
  //在go中创建的变量必须调用一次
  // fmt.Println(id)
  }
  </pre>

Go语言使用的Redis驱动包:https://github.com/astaxie/goredis

驱动包需设置gopath下载使用
下载安装redis并启动
redis的基本操作类型
- string
- hash
- set
- list
- zset
redis代码示例

<pre spellcheck="false" class="md-fences mock-cm md-end-block" lang="" cid="n412" mdtype="fences" style="box-sizing: border-box; overflow: visible; font-family: Menlo, Monaco, "Courier New", monospace; font-size: 1.125rem; display: block; break-inside: avoid; text-align: left; white-space: pre-wrap; background: inherit; position: relative !important; color: rgb(122, 122, 122); padding: 0.5rem 1.125em; margin-bottom: 0.88em; border: 1px solid rgb(122, 122, 122); line-height: 1.5rem; width: inherit;">package main

import (
"fmt"
```
"github.com/astaxie/goredis"
```
)

func main() {
var client goredis.Client
client.Addr = "127.0.0.1:6379"
//存入数据到redis
err := client.Set("test", []byte("hello beifeng"))
if err != nil {
panic(err)
}
//从redis获取数据
res, err := client.Get("test")
if err != nil {
panic(err)
}
fmt.Println(string(res))
//库中hmset方法使用
f := make(map[string]interface{})
f["name"] = "zhangsan"
f["age"] = 12
f["sex"] = "male"
err = client.Hmset("test_hash", f)
if err != nil {
panic(err)
}
//库中 zset方法使用
_, err = client.Zadd("test_zset", []byte("beifeng"), 100)
if err != nil {
panic(err)
}
}
</pre>
redis命令行操作查看
- <pre spellcheck="false" class="md-fences mock-cm md-end-block" lang="" cid="n417" mdtype="fences" style="box-sizing: border-box; overflow: visible; font-family: Menlo, Monaco, "Courier New", monospace; font-size: 1.125rem; display: block; break-inside: avoid; text-align: left; white-space: pre-wrap; background: inherit; position: relative !important; color: rgb(122, 122, 122); padding: 0.5rem 1.125em; margin-bottom: 0.88em; border: 1px solid rgb(122, 122, 122); margin-top: 0px; line-height: 1.5rem; width: inherit;">//启动服务
  redis-server.exe
  //启动客户端查看数据
  E:\quickSorftWare\redis>redis-cli.exe
  127.0.0.1:6379> get test
  "hello golang"
  127.0.0.1:6379> type test_hash
  none
  127.0.0.1:6379> type test_hash
  hash
  127.0.0.1:6379> hgetall test_hash
  1. "age"
  2. "12"
  3. "sex"
  4. "male"
  5. "name"
  6. "zhangsan"
    127.0.0.1:6379> hgetall test_zadd
    (empty list or set)
    127.0.0.1:6379> type test_zadd
    none
    127.0.0.1:6379> type test_zset
    zset
    127.0.0.1:6379> zrange test_zset 0 -1
  7. "golang"
    </pre>

Go语言入坑

GO语言基础

认识并安装GO语言开发环境

Go语言简介

Go语言特点

Go语言开发的应用

一些见解

Go语言环境搭建

GO语言基础知识

第一个Go应用HelloWord

配置

Go语言常用关键字

Go语言开发工具liteide

go语言数据类型

其它基础

GO语言面向对象

类的定义与使用

类的继承与使用

GO语言进阶

GO语言并发编程

Go语言并发编程之协程

GO语言JSON与MD5

Go语言的JSON

GO语言HTTP

GO语言正则表达式

Go语言标准库内建提供了regexp包

GO语言Mysql与Redis

Go语言使用mysql驱动包:https://github.com/Go-SQL-Driver/Mysql

Go语言使用的Redis驱动包:https://github.com/astaxie/goredis

猜你喜欢

热点阅读