Go Redis 库 Redigo


https://github.com/garyburd/redigo/

引入库

import (
    "github.com/garyburd/redigo/redis"
)

查询数据

cli, cerr := redis.Dial("tcp", ip:port, redis.DialPassword(redisPasswd), redis.DialDatabase(1))
if cerr != nil {
    fmt.Println(cerr)
}
defer cli.Close()
// 查询 key
val, err := redis.String(cli.Do("GET", key))
if err != nil {
    fmt.Println(err)
}
return val

写入数据

cli, cerr := redis.Dial("tcp", ip:port, redis.DialPassword(redisPasswd), redis.DialDatabase(1))
if cerr != nil {
    fmt.Println(cerr)
}
defer cli.Close()
_, err := cli.Do("SET", key, value)
if err != nil {
    fmt.Println(err)
}
阅读全文

Go MySQL 库 go-sql-driver


https://github.com/go-sql-driver/mysql

引入库

import (
    "database/sql"

    _ "github.com/go-sql-driver/mysql"
)

查询数据

// 建立 MySQL 链接
db, err := sql.Open("mysql", "user:passwd@tcp(ip:port)/db")
if err != nil {
    fmt.Println(err)
}
defer db.Close()
// 执行 SQL
rows, rerr := db.Query(sqlInfo)
if rerr != nil {
    fmt.Println(rerr)
}
defer rows.Close()
// 获取 SQL 数据
for rows.Next() {
    var returnData string
    err := rows.Scan(&returnData)
    if err != nil {
        fmt.Println(err)
    }
    return returnData
}
return returnData

写入/更新数据

// 建立 MySQL 链接
db, err := sql.Open("mysql", "user:passwd@tcp(ip:port)/db")
if err != nil {
    fmt.Println(err)
}
defer db.Close()
// 执行 SQL
db.Exec(sqlInfo)
阅读全文

Go 实现简单的 Set


需求
对于 Set 类型的数据结构,其实本质上跟 List 没什么多大的区别。无非是 Set 不能含有重复的 Item 的特性,Set 有初始化、Add、Clear、Remove、Contains 等操作。

Go中Map的数据结构,Key是不允许重复的:

m := map[string]string{
    "1": "one",
    "2": "two",
    "1": "one",
    "3": "three",
}
fmt.Println(m)

程序会直接报错,提示重复 Key 值,这样就非常符合 Set 的特性需求了。

定义
前面分析出 Set 的 Value 为固定的值,用一个常量替代即可。但是笔者分析的实现源码,用的是一个空结构体来实现的,如下所示:

// 空结构体
var Exists = struct{}{}
// Set is the main interface
type Set struct {
    // struct 为结构体类型的变量
    m map[interface{}]struct{}
}


阅读全文

Go 实现简单的 List 链表


需求
大家都知道基本链表得有以下特性:链表的初始化、链表的长度、节点的插入、删除、查找等一些常见的基本操作,最后写好之后,需要测试。

实现
初始化
有语言基础的人都知道,链表是由节点连接而成,这其中在定义一个 List 数据结构之外,还需要定义一个 Node 类型的数据结构。先说 Node 类型的数据结构,首先 List 按照正常的设计应该是可以存储基本类型的数据的,这就要求 Node 中的 Value
的类型不能固定。

type Node struct {
    Value      interface{} 
    next, prev *Node       
}

下面就是定义 List 结构体了,有了上面的分析,List 结构体的定义就很好实现了:

type List struct {
    // 头节点
    root   Node
    // list 长度
    length int
}

处理好空 List:

// 返回 List 的指针
func New() *List {
    // 获取 List{} 的地址
    l := &List{}
    // list 初始长度为0
    l.length = 0
    l.root.next = &l.root
    l.root.prev = &l.root
    return l
}

判空和长度
List 的判空和获取长度也是非常基础和重要的,判断是否为空,返回的数据类型是布尔类型的。什么情况下 List 是为空呢?根据前面的定义,头节点的 next 指针域指向是头结点本身的地址即为空。另外,判空函数写好了,总不能什么类型的数据都去调用这个函数,我们需要指定调用的数据类型,在本例中当然是 List 类型的了,为了方便操作,传入一个 List 的地址即可。

func (l *List) IsEmpty() bool {
    return l.root.next == &l.root
}

分析完毕之后,获取 list 的长度就简单很多了:

func (l *List) Length() int {
    return l.length
}

头插和尾插
因为在定义 List 数据结构的时候,就定义了一个 root 头节点。所以此时,可以很方便的实现头插入和尾插入。考虑能够同时插入多个 Node 节点,利用 Go 中的变长参数实现该特性。对插入的 Node 节点进行循环处理,新节点的指针域和 root 节点的指针域做相应改变:

func (l *List) PushFront(elements ...interface{}) {
    for _, element := range elements {
        n := &Node{Value: element}
        // 新节点的 next 是 root 节点的 next
        n.next = l.root.next
        // 新节点的 prev 存储的是 root 的地址
        n.prev = &l.root
        // 原来 root 节点的 next 的 prev 是新节点
        l.root.next.prev = n
        // 头插法 root 之后始终是新节点
        l.root.next = n
        // list 长度加1
        l.length++
    }
}

尾插法:

func (l *List) PushBack(elements ...interface{}) {
    for _, element := range elements {
        n := &Node{Value: element}
        n.next = &l.root
        n.prev = l.root.prev
        l.root.prev.next = n
        l.root.prev = n
        l.length++
    }
}

查找
查找最终的效果是返回指定数值的索引,如果不存在的话返回-1即可。对于链表的查找是一个遍历的过程,在此时就需要考虑遍历的起始和终止区间了,不能越界出错。因为是循环链表,终止节点也很好办。

func (l *List) Find(element interface{}) int {
    index := 0
    p := l.root.next
    for p != &l.root && p.Value != element {
        p = p.next
        index++
    }
    // p 不是 root
    if p != &l.root {
        return index
    }
    return -1
}

删除
链表的删除操作逻辑很清晰,将一个 Node 的节点与前后节点断开即可,同时前后节点和 Node 节点本身指针域也要做相应修改,最后别忘记将链表的长度减少相应长度。

func (l *List) remove(n *Node) {
    n.prev.next = n.next
    n.next.prev = n.prev
    n.next = nil
    n.prev = nil
    l.length--
}

删除并返回 List 中的第一个数据:


func (l *List) Lpop() interface{} {
    if l.length == 0 {
        // null 的表现形式 nil
        return nil
    }
    n := l.root.next
    l.remove(n)
    return n.Value
}

遍历
下面 normalIndex 函数的作用返回一个正常逻辑的 Index,例如处理好一些越界问题:

func (l *List) normalIndex(index int) int {
    if index > l.length-1 {
        index = l.length - 1
    }
    if index < -l.length {
        index = 0
    }
    // 将给定的 index 与 length 做取余处理
    index = (l.length + index) % l.length
    return index
}

如下的函数为获取指定范围内的数据,根据传入的参数需要指定 start 和 end,最后返回的应该是一个切片或者数组,具体类型未知:

func (l *List) Range(start, end int) []interface{} {
    // 获取正常的 start 和 end
    start = l.normalIndex(start)
    end = l.normalIndex(end)
    // 声明一个 interface 类型的数组
    res := []interface{}{}
      // 如果上下界不符合逻辑,返回空 res
    if start > end {
        return res
    }
    sNode := l.index(start)
    eNode := l.index(end)
    // 起始点和重点遍历
    for n := sNode; n != eNode; {
          // res的append方式
        res = append(res, n.Value)
        n = n.next
    }
    res = append(res, eNode.Value)
    return res
}
阅读全文

Go 语言小细节(四)


map 的容量
你可以在 map 创建时指定它的容量,但你无法在 map 上使用 cap() 函数。

package main
func main() {  
    m := make(map[string]int,99)
    cap(m)
}

匿名函数作用域陷阱

import (
    "fmt"
)

func main(){
    var msgs []func()
    array := []string{
        "1", "2", "3", "4",
    }
    for _, e := range array{
        msgs = append(msgs, func(){
            fmt.Println(e)
        })
    }
    for _, v := range msgs{
        v()
    }
}

阅读全文

Go 语言小细节(三)


在 for 语句的闭包中使用迭代变量会有问题
在 for 迭代过程中,迭代变量会一直保留,只是每次迭代值不一样。因此在 for 循环中在闭包里直接引用迭代变量,在执行时直接取迭代变量的值,而不是闭包所在迭代的变量值。如果闭包要取所在迭代变量的值,就需要 for 中定义一个变量来保存所在迭代的值,或者通过闭包函数传参。

package main

import (  
    "fmt"
    "time"
)

func forState1(){
    data := []string{"one","two","three"}

    for _,v := range data {
        go func() {
            fmt.Println(v)
        }()
    }
    time.Sleep(3 * time.Second)
    // three, three, three

    for _,v := range data {
        vcopy := v
        // 使用临时变量
        go func() {
            fmt.Println(vcopy)
        }()
    }
    time.Sleep(3 * time.Second)
    // one, two, three

    for _,v := range data {
        go func(in string) {
            fmt.Println(in)
        }(v)
    }
    time.Sleep(3 * time.Second)
    // one, two, three
}

func main() {  
    forState1()
}

阅读全文

Go 语言小细节(二)


数组用于函数传参时是值复制
方法或函数调用时,传入参数都是值复制,跟赋值一致,除非是 map、slice、channel、指针类型这些特殊类型是引用传递。

x := [3]int{1,2,3}

数组在函数中传参是值复制

func(arr [3]int) {
    arr[0] = 7
    fmt.Println(arr)
    // [7 2 3]
}(x)
fmt.Println(x)
// [1 2 3]

使用数组指针实现引用传参

func(arr *[3]int) {
    (*arr)[0] = 7
    fmt.Println(arr)
    // &[7 2 3]
}(&x)
fmt.Println(x)
// [7 2 3]

阅读全文

Go 语言小细节(一)


多个 defer 出现的时候,多个 defer 之间按照 LIFO(后进先出)的顺序执行

package main
import "fmt"
func main(){
    defer func(){
        fmt.Println("1")
    }()
    defer func(){
        fmt.Println("2")
    }()
    defer func(){
        fmt.Println("3")
    }()
}

对应的输出是:

3
2
1

阅读全文

Go json 反序列化成 interface{} 对 Number 的处理


json 的规范中,对于数字类型,并不区分是整型还是浮点型。
go json number.gif
对于如下 json 文本:

{
    "name": "ethancai",
    "fansCount": 9223372036854775807
}

如果反序列化的时候指定明确的结构体和变量类型

package main

import (
    "encoding/json"
    "fmt"
)

type User struct {
    Name      string
    FansCount int64
}

func main() {
    const jsonStream = `{"name":"ethancai", "fansCount": 9223372036854775807}`
    var user User  // 类型为User
    err := json.Unmarshal([]byte(jsonStream), &user)
    if err != nil {
        fmt.Println("error:", err)
    }
    fmt.Printf("%+v \n", user)
}

Output:

{Name:ethancai FansCount:9223372036854775807}

如果反序列化不指定结构体类型或者变量类型,则 json 中的数字类型,默认被反序列化成 float64 类型:

package main

import (
    "encoding/json"
    "fmt"
    "reflect"
)

func main() {
    const jsonStream = `{"name":"ethancai", "fansCount": 9223372036854775807}`
    // 不指定反序列化的类型
    var user interface{}
    err := json.Unmarshal([]byte(jsonStream), &user)
    if err != nil {
        fmt.Println("error:", err)
    }
    m := user.(map[string]interface{})
    fansCount := m["fansCount"]
    fmt.Printf("%+v \n", reflect.TypeOf(fansCount).Name())
    fmt.Printf("%+v \n", fansCount.(float64))
}

Output:

float64
9.223372036854776e+18

另一个程序

package main

import (
    "encoding/json"
    "fmt"
)

type User struct {
    Name      string
    // 不指定FansCount变量的类型
    FansCount interface{}
}

func main() {
    const jsonStream = `{"name":"ethancai", "fansCount": 9223372036854775807}`
    var user User
    err := json.Unmarshal([]byte(jsonStream), &user)
    if err != nil {
        fmt.Println("error:", err)
    }
    fmt.Printf("%+v \n", user)
}

Output:

{Name:ethancai FansCount:9.223372036854776e+18}

从上面的程序可以发现,如果 fansCount 精度比较高,反序列化成 float64 类型的数值时存在丢失精度的问题。

package main

import (
    "encoding/json"
    "fmt"
    "reflect"
    "strings"
)

func main() {
    const jsonStream = `{"name":"ethancai", "fansCount": 9223372036854775807}`
    decoder := json.NewDecoder(strings.NewReader(jsonStream))
    // UseNumber causes the Decoder to unmarshal a number into an interface{} as a Number instead of as a float64.
    decoder.UseNumber()
    var user interface{}
    if err := decoder.Decode(&user); err != nil {
        fmt.Println("error:", err)
        return
    }
    m := user.(map[string]interface{})
    fansCount := m["fansCount"]
    fmt.Printf("%+v \n", reflect.TypeOf(fansCount).PkgPath() + "." + reflect.TypeOf(fansCount).Name())
    v, err := fansCount.(json.Number).Int64()
    if err != nil {
        fmt.Println("error:", err)
        return
    }
    fmt.Printf("%+v \n", v)
}

Output:

encoding/json.Number
9223372036854775807

上面的程序,使用了 func (*Decoder) UseNumber 方法告诉反序列化 json 的数字类型的时候,不要直接转换成 float64,而是转换成 json.Number 类型。
json.Number内部实现机制:

// A Number represents a JSON number literal.
type Number string

// String returns the literal text of the number.
func (n Number) String() string { return string(n) }

// Float64 returns the number as a float64.
func (n Number) Float64() (float64, error) {
    return strconv.ParseFloat(string(n), 64)
}

// Int64 returns the number as an int64.
func (n Number) Int64() (int64, error) {
    return strconv.ParseInt(string(n), 10, 64)
}

json.Number 本质是字符串,反序列化的时候将 json 的数值先转成 json.Number,其实是一种延迟处理的手段,待后续逻辑需要时候,再把 json.Number 转成 float64 或者 int64。

阅读全文