站长资源脚本专栏

import （
  "github.com/garyburd/redigo/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()

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):迭代有序结合中的元素（包括元素成员和元素分值）

_, 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())
}

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

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

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)
}

_, 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()
  }
}

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)
}

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()
}

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()
}

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()
}

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

_, 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()
  }
}

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)
}

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

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()
}

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()
}

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

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

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

func GetRedisClient() *redis.Client {
	return redis.NewClient(&redis.Options{
		Addr:   "localhost:6379",
		Password: "",
		DB:    0,
	})
}
// redisZsetTest Zset(sorted set有序不重复集合)
func redisZsetTest(cli *redis.Client){
	lang := []redis.Z{
		redis.Z{Score: 90.0, Member: "java"},
		redis.Z{Score: 80.0, Member: "go"},
		redis.Z{Score: 70.0, Member: "python"},
		redis.Z{Score: 60.0, Member: "php"},
		redis.Z{Score: 50.0, Member: "ruby"},
	}
	l1:= struct {
		Score float64
		Member interface{}
	}{
		40,
		"javaScript",
	}
	//l2 :=redis.Z{
	//	Score: 30,
	//	Member: "Object-C",
	//}
	// 添加一个值
	cli.ZAdd("lang",l1)
	// 添加多个值
	_,err:=cli.ZAdd("lang",lang...).Result()
	if err != nil {
		panic(err)
	}
	//升序：查询zset中指定区间的成员,-1代表取到最后
	fmt.Println("ZRange:",cli.ZRange("lang",0,3).Val())		//[javaScript ruby php python]
	//降序：查询zset中指定区间的成员,-1代表取到最后
	fmt.Println("ZRevRange:",cli.ZRevRange("lang",0,-1).Val())	// [java go python php ruby javaScript]
	// [Go javaScript ruby php python go java]
	opt:=redis.ZRangeBy{
		Min:  "50",	//最小分数
		Max:  "90",	//最大分数
		Offset: 2,		//在满足条件的范围，从offset下标处开始取值
		Count: 3,		//查询结果集个数
	}
	//升序：根据opt条件查询Member成员
	fmt.Println(cli.ZRangeByScore("lang",opt).Val())	// [python go java]
	//降序：根据opt条件查询Member成员
	fmt.Println(cli.ZRevRangeByScore("lang",opt).Val())	//[python php ruby]
	//升序:根据下标范围返回的redis.Z结构体切片
	fmt.Println(cli.ZRangeWithScores("lang",0,3).Val())	//[{40 javaScript} {50 ruby} {60 php} {70 python}]
	//降序：根据下标范围返回的redis.Z结构体切片
	fmt.Println(cli.ZRevRangeWithScores("lang",0,-1).Val())//[{90 java} {80 go} {70 python} {60 php} {50 ruby} {40 javaScript}]
	//升序：根据opt条件，返回的redis.Z结构体切片
	fmt.Println(cli.ZRangeByScoreWithScores("lang",opt).Val())
	//降序：根据opt条件，返回的redis.Z结构体切片
	fmt.Println(cli.ZRevRangeByScoreWithScores("lang",opt).Val())
	fmt.Println(cli.ZRangeByLex("lang",opt).Val())
	fmt.Println(cli.ZRevRangeByLex("lang",opt).Val())
	// 获取指定成员的score
	f:=cli.ZScore("lang","go").Val()
	fmt.Println(f)	// 80
	// 获取指定成员的下标
	fmt.Println(cli.ZRank("lang","python").Val())	//3
	// 返回指定区间的成员个数
	fmt.Println(cli.ZCount("lang","50","80").Val())//4
	// 返回集合中成员的个数
	fmt.Println(cli.ZCard("lang").Val())	//6
	// 根据成员名称，移除指定成员（可以多个): 0:失败 0<：成功
	fmt.Println(cli.ZRem("lang","c++").Val())//0
	fmt.Println(cli.ZRem("lang","javaScript","java").Val())//2
	fmt.Println(cli.ZRange("lang",0,-1).Val())	// [ruby php python go]
	// 升序：根据下标区间移除指定成员
	fmt.Println(cli.ZRemRangeByRank("lang",1,2).Val())		//2:表示移除了两个
	fmt.Println(cli.ZRangeWithScores("lang",0,-1).Val())	// [{50 ruby} {80 go}]
	// 升序：根据分数区间移除指定成员
	fmt.Println(cli.ZRemRangeByScore("lang","70","90").Val())	//1:表示移除了一个
	fmt.Println(cli.ZRangeWithScores("lang",0,-1).Val())	// [{50 ruby}]
}
func main() {
	rdb := GetRedisClient()
	defer rdb.Close()
	pong := rdb.Ping().Val()
	fmt.Printf("数据库连接状态：%v\n", pong) // 数据连接状态：PONG
	redisZsetTest(rdb)
}