1：安裝redigo

go get github.com/garyburd/redigo/redis

2：引用redigo

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

3：連線Redis

c, err := redis.Dial("tcp", "192.168.2.225:6379")
if err != nil {
    fmt.Println("connect to redis err", err.Error())
    return
}
defer c.Close()

4：命令

n,err := c.Do("zadd"
 
,"key","score","member")  //寫
result,err := redis.Values(c.Do("zrange","key",0,-1))//讀

5：sorted set簡單操作

zadd(key, score1,member1,...scoreN,memberN) 向有序結合新增（更新）一個或多個成員
zcard(key)：獲取有序集合的成員
zcount(key,start,end):計算指定區間的成員數
zincrby(key,increment,member):成員member增加increment
zinterstore(dst,numkey,src1,src2..srcN)：求交集，並將結果儲存新的結合
zlexcount(key
 
,start,end):計算字典區間成員數(分數都相同，按照字典排序)
zrange(key,start,end):獲取索引區間的成員
zrangebylex (key,start,end):通過字典區間返回區間內有序集合成員
zrangebyscore(key,start,end):通過分數返回區間內的有序集合
zrank (key,member):返回有序結合的索引
zrem(key,members1...membersN):刪除一個或多個成員
zremrangebylex(key,start,end):移除集合中給定字典區間的成員
zremrangebyrank(key,start,end
 
):移除有序集合中給定的排名區間的所有成員
zremrangebyscore(key,start,end)：移除給定分數區間的所有元素
zrevange(key,start,end):通過索引，分數由高到低，返回指定區域的元素
zrevrangebyscore(key,member)：分數由高向低返回指定區間的成員數
zrevrank(key,member):分數從小到大，返回指定成員的排名
zscore(key,member):返回有序集中，成員的分數值
zunionstore(dst,numkeys,key1...keyN):返回給定的一個或多個集合的並集，並存儲在新的集合中
zscan(key,cursor):迭代有序結合中的元素（包括元素成員和元素分值）

6：示例
6.1：zadd

_, err1 := c.Do("zadd", "curbike", 1, "mobike", 2, "xiaolan", 3, "ofo", 4, "xiaoming")
_, err2 := c.Do("zadd", "tmpdata", 0, "mobike", 0, "xiaolan", 0, "mysql", 0, "redis", 0, "mongo", 0, "xiaoming")
if err1 != nil || err2 != nil {
    fmt.Println("zadd failed", err.Error())
}

6.2：zcard

num, err := c.Do("zcard", "curbike")
if err != nil {
    fmt.Println("zcard failed", err.Error())
} else {
    fmt.Printf("curbike's size is %s:", num)
}

6.3：zcount

num, err = c.Do("zcount", "curbike", 1, 3)
if err != nil {
    fmt.Println("zcount failed ", err.Error())
} else {
    fmt.Println("zcount num is :", num)
}

6.4：zincrby

num, err = c.Do("zincrby", "curbike", 3, "xiaolan")
fmt.Println(reflect.TypeOf(num))
if err != nil {
    fmt.Println("zincrby failed", err.Error())
} else {
    fmt.Println("after zincrby the :", num)
}

6.5：zinterstore

_, err = c.Do("zinterstore", "internewset", 2, "curbike", "tmpdata")
if err != nil {
    fmt.Println("zinterstore failed", err.Error())
} else {
    result, err := redis.Values(c.Do("zrange", "internewset", 0, 10))
    if err != nil {
        fmt.Println("interstore failed", err.Error())
    } else {
        fmt.Printf("interstore newset elsements are:")
        for _, v := range result {
            fmt.Printf("%s ", v.([]byte))
        }
        fmt.Println()
    }
}

6.6：zlexcount

num, err = c.Do("zlexcount", "tmpdata", "[mongo", "[xiaoming")
if err != nil {
    fmt.Println("zlexcount failed", err.Error())
} else {
    fmt.Println("zlexcount in tmpdata is :", num)
}

6.7：

res, err := redis.Values(c.Do("zrange", "curbike", 0, -1, "withscores"))
if err != nil {
    fmt.Println("zrange in curbike failed", err.Error())
} else {
    fmt.Printf("curbike's element are follow:")
    for _, v := range res {
        fmt.Printf("%s ", v.([]byte))
    }
    fmt.Println()
}

6.8：zrangebylex

res, err = redis.Values(c.Do("zrangebylex", "tmpdata", "[mobike", "[redis"))
if err != nil {
    fmt.Println("zrangebylex failed", err.Error())
} else {
    fmt.Printf("zrangebylex in tmpdata:")
    for _, v := range res {
        fmt.Printf("%s ", v.([]byte))
    }
    fmt.Println()
}

6.9：zrangebyscore

res, err = redis.Values(c.Do("zrangebyscore", "curbike", "(1", "(5"))
if err != nil {
    fmt.Println("zrangebyscore failed", err.Error())
} else {
    fmt.Printf("zrangebyscore's element:")
    for _, v := range res {
        fmt.Printf("%s ", v.([]byte))
    }
    fmt.Println()
}

6.10：zrank

num, err = c.Do("zrank", "internewset", "xiaoming")
if err != nil {
    fmt.Println("zrank failed ", err.Error())
} else {
    fmt.Println("xiaoming's score is ", num)
}

6.11：

_, err = c.Do("zunionstore", "unewzset", 2, "curbike", "tmpdata")
if err != nil {
    fmt.Println("zunionstore failed", err.Error())
} else {
    res, err = redis.Values(c.Do("zrange", "unewzset", 0, 10))
    if err != nil {
        fmt.Println("zunionstore failed", err.Error())
    } else {
        fmt.Printf("union set are:")
        for _, v := range res {
            fmt.Printf("%s ", v.([]byte))
        }
        fmt.Println()
    }
}

6.12：zscore

ret, err := c.Do("zscore", "internewset", "xiaolan")
if err != nil {
    fmt.Println("zscore failed", err.Error())
} else {
    fmt.Printf("curbike 's xiaolan score is:%s\n", ret)
}

6.13：zrevrank

num, err = c.Do("zrevrank", "curbike", "ofo")
if err != nil {
    fmt.Println("zrevrank failed", err.Error())
} else {
    fmt.Println("ofo's zrevrank is :", num)
}

6.14：zrevrangebyscore

res, err = redis.Values(c.Do("zrevrangebyscore", "unewzset", 10, 2))
if err != nil {
    fmt.Println("zrevrangebyscore failed", err.Error())
} else {
    fmt.Printf("zrevrangebyscore are:")
    for _, v := range res {
        fmt.Printf("%s ", v.([]byte))
    }
    fmt.Println()
}

6.15：zrevrange

res, err = redis.Values(c.Do("zrevrange", "unewzset", 0, 10))
 err != nil {
    fmt.Println("zrevrange failed：", err.Error())
} else {
    fmt.Printf("zrevrange element:")
    for _, v := range res {
        fmt.Printf("%s ", v.([]byte))
    }
    fmt.Println()
}

6.16：zrem

num, err = c.Do("zrem", "unewzset", "mysql")
if err != nil {
    fmt.Println("zrem failed", err.Error())
} else {
    fmt.Println("zrem result is:", num)
}

6.17：zremrangebyrank

num, err = c.Do("zremrangebyrank", "unewzset", 1, 4)
if err != nil {
    fmt.Println("zremrangebyrank failed", err.Error())
} else {
    fmt.Println("zremrangebyrank result:", num)
}

6.18：zremrangebyscore

num, err = c.Do("zremrangebyscore", "curbike", 2, 5)
if err != nil {
    fmt.Println("zremrangebyscore failed", err.Error())
} else {
    fmt.Println("zremrangebyscore result:", num)
}

7：示例結果