goredis常见基础命令

基本操作

//删除键
exists,err:= rdb.Exists(ctx,"key").Result()
if err!=nil{panic(err)
}
if exists>0{err = rdb.Del(ctx,"key").Err()if err!=nil{panic(err)}
}

string类型

//设置一个键值对
//0表示没有过期时间
err:=rdb.Set(ctx,"key1","value1",0).Err()//根据key获取value
value,err:=rdb.Get(ctx,"key1").Result()//设置一个key的值，并返回这个key的旧值
oldVal,err:=rdb.GetSet(ctx,"key1","newVal").Result()//如果key不存在，则设置这个key的值
err:=rdb.setNX(ctx,"key2","value2",0).Err()//批量查询key的值
vals,err:=rdb.MGet(ctx,"key1","key2").Result()//批量设置key的值
err := rdb.MSet(ctx,"key1","value1","key2","value2").Err()//针对一个key的数值进行递增操作，每次加1
val,err:=rdb.Incr(ctx,"key").Result()//IncrBy函数，可以指定每次递增多少
valBy,err:=rdb.IncrBy(ctx,"key",2).Result()//IncrByFloat函数，可以指定每次增长多少，加的是浮点数
valFloat,err := rdb.IncrByFloat(ctx,"key1",2.2).Result()//递减1
val,err := rdb.Decr(ctx,"key",2).Result()//递减指定的值
valBy,err:=rdb.DecrBy(ctx,"key",2).Result()//删除key
rdb.Del(ctx,"key")//删除多个key
err:=rdb.Del(ctx,"key1","key2","key3").Err()//设置过期时间
rdb.Expire(ctx,"key",2*time.Second)

Hash类型

//设置字段值
//添加重复的字段不会报错，只会覆盖
err:=rdb.HSet(ctx,"user_1","username","zhang").Err()//查询字段值
username,err:=rdb.HGet(ctx,"user_1","username").Result()//查询全部字段和值
data,err:=rdb.HGetAll(ctx,"user_1").Result()
//data是一个map类型，使用循环迭代输出
for field,val:=range data{fmt.Println(filed,val)
}//根据key和field字段，累加字段的数值
count, err := rdb.HIncrBy(ctx, "user_1", "count", 2).Result()
if err != nil {panic(err)
}
fmt.Println(count)//返回字段所有字段名
//keys是一个string数组
keys, err := rdb.HKeys(ctx, "user_1").Result()
if err != nil {panic(err)
}
fmt.Println(keys)//查询字段数量
size, err := rdb.HLen(ctx, "user_1").Result()
if err != nil {panic(err)
}
fmt.Println(size)//查询多个字段值
//vals是一个数组
vals, err := rdb.HMGet(ctx, "user_1", "username", "count").Result()
if err != nil {panic(err)
}
fmt.Println(vals)//批量设置字段值
data := make(map[string]interface{})
data["id"] = 1
data["username"] = "li"
//一次性保存多个hash字段值
err := rdb.HMSet(ctx, "key", data).Err()
if err != nil {panic(err)
}//如果field字段不存在，则设置hash的值
err := rdb.HSetNX(ctx, "key", "id", 100).Err()
if err != nil {panic(err)
}//删除字段
//删除不存在的字段不会报错
rdb.HDel(ctx, "key", "id")
//删除多个字段
rdb.HDel(ctx, "key", "id", "username")//检测字段名是否存在
f, err := rdb.HExists(ctx, "key", "id").Result()
if err != nil {panic(err)
}
if f {fmt.Println("存在")
} else {fmt.Println("不存在")
}

List

//插入一个数据
rdb.LPush(ctx, "key", "data1")//LPush支持一次插入任意个数据
err := rdb.LPush(ctx, "key", 1, 2, 3, 4, 5).Err()//当列表存在时才从左边插入插入
err := rdb.LPushX(ctx, "key", "sss").Err()//从列表的右边删除第一个数据，并返回删除的数据
val, err := rdb.RPop(ctx, "key").Result()
fmt.Println(val)//从右边插入数据
rdb.RPush(ctx, "key", "data1")//一次插入多个数据
err := rdb.RPush(ctx, "key", 1, 2, 3, 4, 5).Err()//当列表存在时从右边插入数据
err := rdb.RPushX(ctx, "key", "rVal").Err()//从列表的左边删除第一个数据，并返回
val, err := rdb.LPop(ctx, "key").Result()
fmt.Println(val)//返回列表的长度
val, err := rdb.LLen(ctx, "key").Result()
fmt.Println(val)//返回列表一个范围内的数据
//0到-1就是全部
vals, err := rdb.LRange(ctx, "key", 0, -1).Result()
fmt.Println(vals)//从列表的左边开始，删除第一个100
del, err := rdb.LRem(ctx, "key", 1, 100).Result()
fmt.Println(del)//如果有多个100，则从左边开始，删除前两个100
rdb.LRem(ctx, "key", 2, 100)//如果存在多个100，则从右边开始删除2个100
//第二个参数表示从右边开始删除几个等于100得元素
rdb.LRem(ctx, "key", -2, 100)//如果存在多个100，第二个参数为0，表示删除所有元素等于100得数据
rdb.LRem(ctx, "key", 0, 100)//根据索引查找对应元素，索引从0开始
val, err := rdb.LIndex(ctx, "key", 5).Result()//在列表中元素为5的前边加入4
err := rdb.LInsert(ctx, "Key", "before", 5, 4).Err()//只留下索引是0到2的
rdb.LTrim(ctx, "key1", 0, 2)

Set

无序集合元素不能重复

//添加100到集合中
err := rdb.SAdd(ctx, "key", 100).Err()
if err != nil {panic(err)
}//将100，200，300添加到集合中
//向集合中添加已经存在的元素将会报错
rdb.SAdd(ctx, "key", 100, 200, 300)//获取大小
size, err := rdb.SCard(ctx, "key").Result()
if err != nil {panic(err)
}
fmt.Println(size)//判断元素是否存在
ok, _ := rdb.SIsMember(ctx, "key", 100).Result()
if ok {fmt.Println("存在")
}//获取所有元素
es, _ := rdb.SMembers(ctx, "key").Result()
fmt.Println(es)//删除集合元素
//删除不存在的元素不会报错
rdb.SRem(ctx, "key", 100)//删除多个
rdb.SRem(ctx, "key", 200, 300)//随机返回集合中的元素,并删除
//val是随机删除的元素
val, _ := rdb.SPop(ctx, "key").Result()
fmt.Println(val)//随机删除多个
vals, _ := rdb.SPopN(ctx, "key", 3).Result()
fmt.Println(vals)

sorted set/zset

它为每个成员关联了一个分数（score），这个分数被用来对集合中的成员进行排序。虽然成员必须是唯一的，但是分数可以重复

l1 := redis.Z{Score:  1.0,Member: "zhang",
}
//添加元素,如果元素存在,则更新分数
err := rdb.ZAdd(ctx, "key", l1).Err()
if err != nil {panic(err)
}
err = rdb.ZAdd(ctx, "key", redis.Z{3.8, "zhang"}).Err()
if err != nil {panic(err)
}//返回元素个数
size, err := rdb.ZCard(ctx, "key").Result()
if err != nil {panic(err)
}
fmt.Println(size)//统计某个范围的元素个数
//范围[1,5]
size, err = rdb.ZCount(ctx, "key", "1", "5").Result()
if err != nil {panic(err)
}
fmt.Println(size)// 如果加上（ 则表示大于或者小于，相当于去掉了等于关系。
size, err = rdb.ZCount(ctx, "key", "(1", "5").Result()
if err != nil {panic(err)
}
fmt.Println(size)//增加元素分数
rdb.ZIncrBy(ctx, "key", 2, "zhang")//返回全部数据
//元素按分数从小到大
vals, err := rdb.ZRange(ctx, "key", 0, -1).Result()
if err != nil {panic(err)
}
for _, val := range vals {fmt.Println(val)
}//ZRevRange的结果是按分数从大到小排序
//根据分数范围返回集合元素，元素根据分数从小到大排序，支持分页
//初始化查询条件
op := redis.ZRangeBy{"1","10",0, // 类似sql的limit, 表示开始偏移量5, // 一次返回多少数据
}
vals, err = rdb.ZRangeByScore(ctx, "key", &op).Result()
if err != nil {panic(err)
}
for _, val := range vals {fmt.Println(val)
}// ZRevRangeByScore用法类似ZRangeByScore，区别是元素根据分数从大到小排序。//返回元素和分数
vals, err = rdb.ZRangeByScoreWithScores(ctx, "key", &op).Result()
if err != nil {panic(err)
}
for _, val := range vals {fmt.Println(val.Member)fmt.Println(val.Score)
}//删除集合元素
rdb.ZRem(ctx, "key", "zhang")//删除多个
rdb.ZRem(ctx, "key", "li", "wang")//根据索引范围删除元素
//删除第零个到第一个
rdb.ZRemRangeByRank(ctx, "key", 0, 1)//根据范围删除元素,"("和")"可以使用
rdb.ZRemRangeByScore(ctx, "key", "2", "5")//查询元素对应的分数
score, _ := rdb.ZScore(ctx, "key", "zhang").Result()
fmt.Println(score)//根据元素名,查询集合元素在集合中的排名,从0开始,从小到大
rk, _ := rdb.ZRank(ctx, "key", "zhang").Result()
fmt.Println(rk)
//ZRevRank是按分数从大到小排序

发布订阅

可用于消息的传输

三个部分：发布者，订阅者，Channel（频道）

发布者和订阅者是redis客户端，channel是redis服务端，发布者将消息发送到某个频道，订阅这个频道的订阅者就能接收到这条消息

Subscribe

订阅channel

// 订阅channel1这个channel
sub := rdb.Subscribe(ctx, "channel1")
// sub.Channel() 返回go channel，可以循环读取redis服务器发过来的消息
for msg := range sub.Channel() {// 打印收到的消息fmt.Println(msg.Channel)fmt.Println(msg.Payload)
}
//或者
for {msg, err := sub.ReceiveMessage(ctx)if err != nil {panic(err)}fmt.Println(msg.Channel, msg.Payload)
}

publish

将消息发送给指定的channel

rdb.Publish(ctx,"channel1","message")

PSubscribe

用法跟Subscribe一样，区别是PSubscribe订阅通道(channel)支持模式匹配。

// 订阅channel1这个channel
sub := rdb.PSubscribe(ctx,"ch_user_*")
// 可以匹配ch_user_开头的任意channel

Unsubscribe

取消订阅

// 订阅channel1这个channel
sub := rdb.Subscribe(ctx,"channel1")
// 取消订阅
sub.Unsubscribe(ctx,"channel1")

PubSubNumSub

查询指定的channel有多少个订阅者

// 查询channel_1通道的订阅者数量chs, _ := rdb.PubSubNumSub(ctx, "channel_1").Result()for ch, count := range chs {fmt.Println(ch)    // channel名字fmt.Println(count) // channel的订阅者数量}