Redis sets

Introduction to Redis sets

A Redis set is an unordered collection of unique strings (members). You can use Redis sets to efficiently:

• Track unique items (e.g., track all unique IP addresses accessing a given blog post).
• Represent relations (e.g., the set of all users with a given role).
• Perform common set operations such as intersection, unions, and differences.

Examples

• Store the sets of bikes racing in France and the USA. Note that if you add a member that already exists, it will be ignored.

  Language: >_ Redis CLI Python JavaScript (node-redis) Java-Sync Java-Async Java-Reactive Go C#-Sync (SE.Redis) PHP Ruby Rust-Sync Rust-Async

  Try it

  Show full output

  Copied!

  Copied!

  Foundational: Add members to a set using SADD when you need to store unique items (duplicates are silently ignored)

  SADD bikes:racing:france bike:1 SADD bikes:racing:france bike:1 SADD bikes:racing:france bike:2 bike:3 SADD bikes:racing:usa bike:1 bike:4

  ▼ Commands: SADD

  • SADD ( @write , @set , @fast )

    Adds one or more members to a set. Creates the key if it doesn't exist.

  Redis CLI guide

  Also, check out our other client tools Redis Insight and Redis for VS Code.

  res1 = r.sadd("bikes:racing:france", "bike:1")
  print(res1)  # >>> 1
  
  res2 = r.sadd("bikes:racing:france", "bike:1")
  print(res2)  # >>> 0
  
  res3 = r.sadd("bikes:racing:france", "bike:2", "bike:3")
  print(res3)  # >>> 2
  
  res4 = r.sadd("bikes:racing:usa", "bike:1", "bike:4")
  print(res4)  # >>> 2
  

  ▼ Commands: SADD

  • SADD ( @write , @set , @fast )

    Adds one or more members to a set. Creates the key if it doesn't exist.

    ▶ Method

    • sadd(
      • name: KeyT,
      • *values: FieldT
      ) → Union[Awaitable[int], int]

  Python Quick-Start

  const res1 = await client.sAdd('bikes:racing:france', 'bike:1')
  console.log(res1)  // >>> 1
  
  const res2 = await client.sAdd('bikes:racing:france', 'bike:1')
  console.log(res2)  // >>> 0
  const res3 = await client.sAdd('bikes:racing:france', ['bike:2', 'bike:3'])
  console.log(res3)  // >>> 2
  const res4 = await client.sAdd('bikes:racing:usa', ['bike:1', 'bike:4'])
  console.log(res4)  // >>> 2
  

  ▼ Commands: SADD

  • SADD ( @write , @set , @fast )

    Adds one or more members to a set. Creates the key if it doesn't exist.

    ▶ Method

    • SADD(
      • key: RedisArgument,
      • members: RedisVariadicArgument
      ) → Any

  Node.js Quick-Start

          long res1 = jedis.sadd("bikes:racing:france", "bike:1");
          System.out.println(res1);  // >>> 1
  
          long res2 = jedis.sadd("bikes:racing:france", "bike:1");
          System.out.println(res2);  // >>> 0
  
          long res3 = jedis.sadd("bikes:racing:france", "bike:2", "bike:3");
          System.out.println(res3);  // >>> 2
  
          long res4 = jedis.sadd("bikes:racing:usa", "bike:1", "bike:4");
          System.out.println(res4);  // >>> 2
  

  ▼ Commands: SADD

  • SADD ( @write , @set , @fast )

    Adds one or more members to a set. Creates the key if it doesn't exist.

    ▶ Methods

    • sadd(
      • key: byte[],
      • members: byte[]...
      ) → long // 1 if the new element was added, 0 if the element was already a member of the set
    • sadd(
      • key: String,
      • members: String...
      ) → long // 1 if the new element was added, 0 if the element was already a member of the set

  Java-Sync Quick-Start

              CompletableFuture<Void> sAdd = asyncCommands.sadd("bikes:racing:france", "bike:1").thenCompose(res1 -> {
                  System.out.println(res1); // >>> 1
                  return asyncCommands.sadd("bikes:racing:france", "bike:1");
              }).thenCompose(res2 -> {
                  System.out.println(res2); // >>> 0
                  return asyncCommands.sadd("bikes:racing:france", "bike:2", "bike:3");
              }).thenCompose(res3 -> {
                  System.out.println(res3); // >>> 2
                  return asyncCommands.sadd("bikes:racing:usa", "bike:1", "bike:4");
              }).thenAccept(res4 -> {
                  System.out.println(res4); // >>> 2
              }).toCompletableFuture();
  

  ▼ Commands: SADD

  • SADD ( @write , @set , @fast )

    Adds one or more members to a set. Creates the key if it doesn't exist.

    ▶ Method

    • sadd(
      • key: K, // the key.
      • members: V... // the member type: value.
      ) → RedisFuture<Long> // Long integer-reply the number of elements that were added to the set, not including all the elements already present into the set.

  Java-Async Quick-Start

              Mono<Void> sAdd = reactiveCommands.sadd("bikes:racing:france", "bike:1").doOnNext(result -> {
                  System.out.println(result); // >>> 1
              }).flatMap(v -> reactiveCommands.sadd("bikes:racing:france", "bike:1")).doOnNext(result -> {
                  System.out.println(result); // >>> 0
              }).flatMap(v -> reactiveCommands.sadd("bikes:racing:france", "bike:2", "bike:3")).doOnNext(result -> {
                  System.out.println(result); // >>> 2
              }).flatMap(v -> reactiveCommands.sadd("bikes:racing:usa", "bike:1", "bike:4")).doOnNext(result -> {
                  System.out.println(result); // >>> 2
              }).then();
  

  ▼ Commands: SADD

  • SADD ( @write , @set , @fast )

    Adds one or more members to a set. Creates the key if it doesn't exist.

    ▶ Method

    • sadd(
      • key: K, // the key.
      • members: V... // the member type: value.
      ) → Mono<Long> // Long integer-reply the number of elements that were added to the set, not including all the elements already present into the set.

  Java-Reactive Quick-Start

  	res1, err := rdb.SAdd(ctx, "bikes:racing:france", "bike:1").Result()
  
  	if err != nil {
  		panic(err)
  	}
  
  	fmt.Println(res1) // >>> 1
  
  	res2, err := rdb.SAdd(ctx, "bikes:racing:france", "bike:1").Result()
  
  	if err != nil {
  		panic(err)
  	}
  
  	fmt.Println(res2) // >>> 0
  
  	res3, err := rdb.SAdd(ctx, "bikes:racing:france", "bike:2", "bike:3").Result()
  
  	if err != nil {
  		panic(err)
  	}
  
  	fmt.Println(res3) // >>> 2
  
  	res4, err := rdb.SAdd(ctx, "bikes:racing:usa", "bike:1", "bike:4").Result()
  
  	if err != nil {
  		panic(err)
  	}
  
  	fmt.Println(res4) // >>> 2
  

  ▼ Commands: SADD

  • SADD ( @write , @set , @fast )

    Adds one or more members to a set. Creates the key if it doesn't exist.

    ▶ Method

    • SAdd(
      • ctx: context.Context,
      • key: string,
      • members: ...interface{}
      ) → *IntCmd

  Go Quick-Start

          long res1 = db.SetAdd("bikes:racing:france", ["bike:1"]);
          Console.WriteLine(res1);    // >>> 1
  
          long res2 = db.SetAdd("bikes:racing:france", ["bike:1"]);
          Console.WriteLine(res2);    // >>> 0
  
          long res3 = db.SetAdd("bikes:racing:france", ["bike:2", "bike:3"]);
          Console.WriteLine(res3);    // >>> 2
  
          long res4 = db.SetAdd("bikes:racing:usa", ["bike:1", "bike:4"]);
          Console.WriteLine(res4);    // >>> 2
  

  ▼ Commands: SADD

  • SADD ( @write , @set , @fast )

    Adds one or more members to a set. Creates the key if it doesn't exist.

    ▶ Methods

    • SetAdd(
      • key: RedisKey, // The key of the set.
      • value: RedisValue,
      • flags: CommandFlags // The flags to use for this operation.
      ) → bool // The number of elements that were added to the set, not including all the elements already present into the set.
    • SetAdd(
      • key: RedisKey, // The key of the set.
      • values: RedisValue[], // The values to add to the set.
      • flags: CommandFlags // The flags to use for this operation.
      ) → long // The number of elements that were added to the set, not including all the elements already present into the set.
    • SetAdd(
      • key: RedisKey, // The key of the set.
      • value: RedisValue,
      • flags: CommandFlags // The flags to use for this operation.
      ) → bool // The number of elements that were added to the set, not including all the elements already present into the set.
    • SetAdd(
      • key: RedisKey, // The key of the set.
      • values: RedisValue[], // The values to add to the set.
      • flags: CommandFlags // The flags to use for this operation.
      ) → long // The number of elements that were added to the set, not including all the elements already present into the set.

  C#-Sync (SE.Redis) Quick-Start

          $res1 = $r->sadd('bikes:racing:france', ['bike:1']);
          echo $res1 . PHP_EOL;
          // >>> 1
  
          $res2 = $r->sadd('bikes:racing:france', ['bike:1']);
          echo $res2 . PHP_EOL;
          // >>> 0
  
          $res3 = $r->sadd('bikes:racing:france', ['bike:2', 'bike:3']);
          echo $res3 . PHP_EOL;
          // >>> 2
  
          $res4 = $r->sadd('bikes:racing:usa', ['bike:1', 'bike:4']);
          echo $res4 . PHP_EOL;
          // >>> 2
  

  ▼ Commands: SADD

  • SADD ( @write , @set , @fast )

    Adds one or more members to a set. Creates the key if it doesn't exist.

    ▶ Method

    • sadd(
      • $key: string,
      • $members: array
      ) → int

  PHP Quick-Start

  res1 = r.sadd('bikes:racing:france', ['bike:1'])
  puts res1 # 1
  
  res2 = r.sadd('bikes:racing:france', ['bike:1'])
  puts res2 # 0
  
  res3 = r.sadd('bikes:racing:france', ['bike:2', 'bike:3'])
  puts res3 # 2
  
  res4 = r.sadd('bikes:racing:usa', ['bike:1', 'bike:4'])
  puts res4 # 2
  

  ▼ Commands: SADD

  • SADD ( @write , @set , @fast )

    Adds one or more members to a set. Creates the key if it doesn't exist.

    ▶ Method

    • sadd(
      • key: String,
      • *members: String, Array<String> // one member, or array of members
      ) → Integer // The number of members that were successfully added

  Ruby Quick-Start

          if let Ok(res) = r.sadd("bikes:racing:france", "bike:1") {
              let res: usize = res;
              println!("{res}"); // >>> 1
          }
  
          if let Ok(res) = r.sadd("bikes:racing:france", "bike:1") {
              let res: usize = res;
              println!("{res}"); // >>> 0
          }
  
          if let Ok(res) = r.sadd("bikes:racing:france", &["bike:2", "bike:3"]) {
              let res: usize = res;
              println!("{res}"); // >>> 2
          }
  
          if let Ok(res) = r.sadd("bikes:racing:usa", &["bike:1", "bike:4"]) {
              let res: usize = res;
              println!("{res}"); // >>> 2
          }
  

  ▼ Commands: SADD

  • SADD ( @write , @set , @fast )

    Adds one or more members to a set. Creates the key if it doesn't exist.

    ▶ Method

    • sadd(
      • key: K,
      • member: M
      ) → (usize)

  Rust-Sync Quick-Start

          if let Ok(res) = r.sadd("bikes:racing:france", "bike:1").await {
              let res: usize = res;
              println!("{res}"); // >>> 1
          }
  
          if let Ok(res) = r.sadd("bikes:racing:france", "bike:1").await {
              let res: usize = res;
              println!("{res}"); // >>> 0
          }
  
          if let Ok(res) = r.sadd("bikes:racing:france", &["bike:2", "bike:3"]).await {
              let res: usize = res;
              println!("{res}"); // >>> 2
          }
  
          if let Ok(res) = r.sadd("bikes:racing:usa", &["bike:1", "bike:4"]).await {
              let res: usize = res;
              println!("{res}"); // >>> 2
          }
  

  ▼ Commands: SADD

  • SADD ( @write , @set , @fast )

    Adds one or more members to a set. Creates the key if it doesn't exist.

    ▶ Method

    • sadd(
      • key: K,
      • member: M
      ) → (usize)

  Rust-Async Quick-Start

• Check whether bike:1 or bike:2 are racing in the US.

  Language: >_ Redis CLI Python JavaScript (node-redis) Java-Sync Java-Async Java-Reactive Go C#-Sync (SE.Redis) PHP Ruby Rust-Sync Rust-Async

  Try it

  Show full output

  Copied!

  Copied!

  Foundational: Test set membership using SISMEMBER when you need O(1) lookups (much faster than checking a list)

  SISMEMBER bikes:racing:usa bike:1 SISMEMBER bikes:racing:usa bike:2

  ▼ Commands: SISMEMBER

  • SISMEMBER ( @read , @set , @fast )

    Determines whether a member belongs to a set.

  Redis CLI guide

  Also, check out our other client tools Redis Insight and Redis for VS Code.

  r.sadd("bikes:racing:france", "bike:1", "bike:2", "bike:3")
  r.sadd("bikes:racing:usa", "bike:1", "bike:4")
  res5 = r.sismember("bikes:racing:usa", "bike:1")
  print(res5)  # >>> 1
  
  res6 = r.sismember("bikes:racing:usa", "bike:2")
  print(res6)  # >>> 0
  

  ▼ Commands: SISMEMBER

  • SISMEMBER ( @read , @set , @fast )

    Determines whether a member belongs to a set.

    ▶ Method

    • sismember(
      • name: KeyT,
      • value: str
      ) → Union[Awaitable[Union[Literal[0], Literal[1]]], Union[Literal[0], Literal[1]]]

  Python Quick-Start

  await client.del('bikes:racing:france')
  await client.del('bikes:racing:usa')
  await client.sAdd('bikes:racing:france', ['bike:1', 'bike:2', 'bike:3'])
  await client.sAdd('bikes:racing:usa', ['bike:1', 'bike:4'])
  const res5 = await client.sIsMember('bikes:racing:usa', 'bike:1')
  console.log(res5)  // >>> 1
  
  const res6 = await client.sIsMember('bikes:racing:usa', 'bike:2')
  console.log(res6)  // >>> 0
  

  ▼ Commands: SISMEMBER

  • SISMEMBER ( @read , @set , @fast )

    Determines whether a member belongs to a set.

    ▶ Method

    • SISMEMBER(
      • key: RedisArgument,
      • member: RedisArgument
      ) → Any

  Node.js Quick-Start

          jedis.sadd("bikes:racing:france", "bike:1", "bike:2", "bike:3");
          jedis.sadd("bikes:racing:usa", "bike:1", "bike:4");
  
          boolean res5 = jedis.sismember("bikes:racing:usa", "bike:1");
          System.out.println(res5);  // >>> true
  
          boolean res6 = jedis.sismember("bikes:racing:usa", "bike:2");
          System.out.println(res6);  // >>> false
  

  ▼ Commands: SISMEMBER

  • SISMEMBER ( @read , @set , @fast )

    Determines whether a member belongs to a set.

    ▶ Methods

    • sismember(
      • key: byte[],
      • member: byte[]
      ) → boolean // true if the element is a member of the set, false otherwise
    • sismember(
      • key: String,
      • member: String
      ) → boolean // true if the element is a member of the set, false otherwise

  Java-Sync Quick-Start

              CompletableFuture<Void> sIsMember = asyncCommands.sismember("bikes:racing:usa", "bike:1").thenCompose(res5 -> {
                  System.out.println(res5); // >>> true
                  return asyncCommands.sismember("bikes:racing:usa", "bike:2");
              }).thenAccept(res6 -> {
                  System.out.println(res6); // >>> false
              }).toCompletableFuture();
  

  ▼ Commands: SISMEMBER

  • SISMEMBER ( @read , @set , @fast )

    Determines whether a member belongs to a set.

    ▶ Method

    • sismember(
      • key: K, // the key.
      • member: V // the member type: value.
      ) → RedisFuture<Boolean> // Boolean integer-reply specifically: true if the element is a member of the set. false if the element is not a member of the set, or if key does not exist.

  Java-Async Quick-Start

              Mono<Boolean> sIsMember1 = reactiveCommands.sismember("bikes:racing:usa", "bike:1").doOnNext(result -> {
                  System.out.println(result); // >>> true
              });
  
              Mono<Boolean> sIsMember2 = reactiveCommands.sismember("bikes:racing:usa", "bike:2").doOnNext(result -> {
                  System.out.println(result); // >>> false
              });
  

  ▼ Commands: SISMEMBER

  • SISMEMBER ( @read , @set , @fast )

    Determines whether a member belongs to a set.

    ▶ Method

    • sismember(
      • key: K, // the key.
      • member: V // the member type: value.
      ) → Mono<Boolean> // Boolean integer-reply specifically: true if the element is a member of the set. false if the element is not a member of the set, or if key does not exist.

  Java-Reactive Quick-Start

  	res5, err := rdb.SIsMember(ctx, "bikes:racing:usa", "bike:1").Result()
  
  	if err != nil {
  		panic(err)
  	}
  
  	fmt.Println(res5) // >>> true
  
  	res6, err := rdb.SIsMember(ctx, "bikes:racing:usa", "bike:2").Result()
  
  	if err != nil {
  		panic(err)
  	}
  
  	fmt.Println(res6) // >>> false
  

  ▼ Commands: SISMEMBER

  • SISMEMBER ( @read , @set , @fast )

    Determines whether a member belongs to a set.

    ▶ Method

    • SIsMember(
      • ctx: context.Context,
      • key: string,
      • member: interface{}
      ) → *BoolCmd

  Go Quick-Start

          bool res5 = db.SetContains("bikes:racing:france", "bike:1");
          Console.WriteLine(res5);    // >>> True
  
          bool res6 = db.SetContains("bikes:racing:usa", "bike:2");
          Console.WriteLine(res6);    // >>> False
  

  ▼ Commands: SISMEMBER

  • SISMEMBER ( @read , @set , @fast )

    Determines whether a member belongs to a set.

    ▶ Methods

    • SetContains(
      • key: RedisKey, // The key of the set.
      • value: RedisValue,
      • flags: CommandFlags // The flags to use for this operation.
      ) → bool // true if the element is a member of the set. false if the element is not a member of the set, or if key does not exist.
    • SetContains(
      • key: RedisKey, // The key of the set.
      • values: RedisValue[], // The members to check for.
      • flags: CommandFlags // The flags to use for this operation.
      ) → bool[] // true if the element is a member of the set. false if the element is not a member of the set, or if key does not exist.
    • SetContains(
      • key: RedisKey, // The key of the set.
      • value: RedisValue,
      • flags: CommandFlags // The flags to use for this operation.
      ) → bool // true if the element is a member of the set. false if the element is not a member of the set, or if key does not exist.
    • SetContains(
      • key: RedisKey, // The key of the set.
      • values: RedisValue[], // The members to check for.
      • flags: CommandFlags // The flags to use for this operation.
      ) → bool[] // true if the element is a member of the set. false if the element is not a member of the set, or if key does not exist.

  C#-Sync (SE.Redis) Quick-Start

          $res5 = $r->sismember('bikes:racing:usa', 'bike:1');
          echo $res5 . PHP_EOL;
          // >>> 1
  
          $res6 = $r->sismember('bikes:racing:usa', 'bike:2');
          echo $res6 . PHP_EOL;
          // >>> 0
  

  ▼ Commands: SISMEMBER

  • SISMEMBER ( @read , @set , @fast )

    Determines whether a member belongs to a set.

    ▶ Method

    • sismember(
      • $key: string,
      • $member: string
      ) → int

  PHP Quick-Start

  r.del('bikes:racing:france', 'bikes:racing:usa')
  r.sadd('bikes:racing:france', ['bike:1', 'bike:2', 'bike:3'])
  r.sadd('bikes:racing:usa', ['bike:1', 'bike:4'])
  res5 = r.sismember('bikes:racing:usa', 'bike:1')
  puts res5 # true
  
  res6 = r.sismember('bikes:racing:usa', 'bike:2')
  puts res6 # false
  

  ▼ Commands: SISMEMBER

  • SISMEMBER ( @read , @set , @fast )

    Determines whether a member belongs to a set.

    ▶ Method

    • sismember(
      • key: String,
      • member: String
      ) → Boolean

  Ruby Quick-Start

          if let Ok(res) = r.sismember("bikes:racing:usa", "bike:1") {
              let res: bool = res;
              println!("{}", i32::from(res)); // >>> 1
          }
  
          if let Ok(res) = r.sismember("bikes:racing:usa", "bike:2") {
              let res: bool = res;
              println!("{}", i32::from(res)); // >>> 0
          }
  

  ▼ Commands: SISMEMBER

  • SISMEMBER ( @read , @set , @fast )

    Determines whether a member belongs to a set.

    ▶ Method

    • sismember(
      • key: K,
      • member: M
      ) → (bool)

  Rust-Sync Quick-Start

          if let Ok(res) = r.sismember("bikes:racing:usa", "bike:1").await {
              let res: bool = res;
              println!("{}", i32::from(res)); // >>> 1
          }
  
          if let Ok(res) = r.sismember("bikes:racing:usa", "bike:2").await {
              let res: bool = res;
              println!("{}", i32::from(res)); // >>> 0
          }
  

  ▼ Commands: SISMEMBER

  • SISMEMBER ( @read , @set , @fast )

    Determines whether a member belongs to a set.

    ▶ Method

    • sismember(
      • key: K,
      • member: M
      ) → (bool)

  Rust-Async Quick-Start

• Which bikes are competing in both races?

  Language: >_ Redis CLI Python JavaScript (node-redis) Java-Sync Java-Async Java-Reactive Go C#-Sync (SE.Redis) PHP Ruby Rust-Sync Rust-Async

  Try it

  Show full output

  Copied!

  Copied!

  Set intersection: Find common members across multiple sets using SINTER when you need to identify shared items (e.g., users in multiple groups)

  SINTER bikes:racing:france bikes:racing:usa

  ▼ Commands: SINTER

  • SINTER ( @read , @set , @slow )

    Returns the intersect of multiple sets.

  Redis CLI guide

  Also, check out our other client tools Redis Insight and Redis for VS Code.

  r.sadd("bikes:racing:france", "bike:1", "bike:2", "bike:3")
  r.sadd("bikes:racing:usa", "bike:1", "bike:4")
  res7 = r.sinter("bikes:racing:france", "bikes:racing:usa")
  print(res7)  # >>> {'bike:1'}
  

  ▼ Commands: SINTER

  • SINTER ( @read , @set , @slow )

    Returns the intersect of multiple sets.

    ▶ Method

    • sinter(
      • keys: List,
      • *args: List
      ) → Union[Awaitable[list], list]

  Python Quick-Start

  import { createClient } from 'redis';
  
  const client = createClient();
  await client.connect();
  
  const res1 = await client.sAdd('bikes:racing:france', 'bike:1')
  console.log(res1)  // >>> 1
  
  const res2 = await client.sAdd('bikes:racing:france', 'bike:1')
  console.log(res2)  // >>> 0
  const res3 = await client.sAdd('bikes:racing:france', ['bike:2', 'bike:3'])
  console.log(res3)  // >>> 2
  const res4 = await client.sAdd('bikes:racing:usa', ['bike:1', 'bike:4'])
  console.log(res4)  // >>> 2
  
  
  await client.del('bikes:racing:france')
  await client.del('bikes:racing:usa')
  await client.sAdd('bikes:racing:france', ['bike:1', 'bike:2', 'bike:3'])
  await client.sAdd('bikes:racing:usa', ['bike:1', 'bike:4'])
  const res5 = await client.sIsMember('bikes:racing:usa', 'bike:1')
  console.log(res5)  // >>> 1
  
  const res6 = await client.sIsMember('bikes:racing:usa', 'bike:2')
  console.log(res6)  // >>> 0
  
  
  await client.del('bikes:racing:france')
  await client.del('bikes:racing:usa')
  await client.sAdd('bikes:racing:france', ['bike:1', 'bike:2', 'bike:3'])
  await client.sAdd('bikes:racing:usa', ['bike:1', 'bike:4'])
  const res7 = await client.sInter(['bikes:racing:france', 'bikes:racing:usa'])
  console.log(res7)  // >>> {'bike:1'}
  
  
  await client.del('bikes:racing:france')
  await client.sAdd('bikes:racing:france', ['bike:1', 'bike:2', 'bike:3'])
  const res8 = await client.sCard('bikes:racing:france')
  console.log(res8)  // >>> 3
  
  
  await client.del('bikes:racing:france')
  
  const res9 = await client.sAdd('bikes:racing:france', ['bike:1', 'bike:2', 'bike:3'])
  console.log(res9)  // >>> 3
  
  const res10 = await client.sMembers('bikes:racing:france')
  console.log(res10)  // >>> ['bike:1', 'bike:2', 'bike:3']
  
  
  // Recreate the set so this example runs on its own.
  await client.del('bikes:racing:france')
  await client.sAdd('bikes:racing:france', ['bike:1', 'bike:2', 'bike:3'])
  
  const res11 = await client.sIsMember('bikes:racing:france', 'bike:1')
  console.log(res11)  // >>> 1
  
  const res12 = await client.smIsMember('bikes:racing:france', ['bike:2', 'bike:3', 'bike:4'])
  console.log(res12)  // >>> [1, 1, 0]
  
  
  await client.del('bikes:racing:france')
  await client.del('bikes:racing:usa')
  
  await client.sAdd('bikes:racing:france', ['bike:1', 'bike:2', 'bike:3'])
  await client.sAdd('bikes:racing:usa', ['bike:1', 'bike:4'])
  const res13 = await client.sDiff(['bikes:racing:france', 'bikes:racing:usa'])
  console.log(res13)  // >>> [ 'bike:2', 'bike:3' ]
  
  
  await client.del('bikes:racing:france')
  await client.del('bikes:racing:usa')
  await client.del('bikes:racing:italy')
  
  await client.sAdd('bikes:racing:france', ['bike:1', 'bike:2', 'bike:3'])
  await client.sAdd('bikes:racing:usa', ['bike:1', 'bike:4'])
  await client.sAdd('bikes:racing:italy', ['bike:1', 'bike:2', 'bike:3', 'bike:4'])
  
  const res14 = await client.sInter(
    ['bikes:racing:france', 'bikes:racing:usa', 'bikes:racing:italy']
  )
  console.log(res14)  // >>> ['bike:1']
  
  const res15 = await client.sUnion(
    ['bikes:racing:france', 'bikes:racing:usa', 'bikes:racing:italy']
  )
  console.log(res15)  // >>> ['bike:1', 'bike:2', 'bike:3', 'bike:4']
  
  const res16 = await client.sDiff(['bikes:racing:france', 'bikes:racing:usa', 'bikes:racing:italy'])
  console.log(res16)  // >>> []
  
  const res17 = await client.sDiff(['bikes:racing:usa', 'bikes:racing:france'])
  console.log(res17)  // >>> ['bike:4']
  
  const res18 = await client.sDiff(['bikes:racing:france', 'bikes:racing:usa'])
  console.log(res18)  // >>> ['bike:2', 'bike:3']
  
  
  await client.del('bikes:racing:france')
  
  await client.sAdd('bikes:racing:france', ['bike:1', 'bike:2', 'bike:3', 'bike:4', 'bike:5'])
  
  const res19 = await client.sRem('bikes:racing:france', 'bike:1')
  console.log(res19)  // >>> 1
  
  const res20 = await client.sPop('bikes:racing:france')
  console.log(res20)  // >>> bike:3 or other random value
  
  const res21 = await client.sMembers('bikes:racing:france')
  console.log(res21)  // >>> ['bike:2', 'bike:4', 'bike:5']; depends on previous result
  
  const res22 = await client.sRandMember('bikes:racing:france')
  console.log(res22)  // >>> bike:4 or other random value
  
  

  ▼ Commands: SINTER

  • SINTER ( @read , @set , @slow )

    Returns the intersect of multiple sets.

    ▶ Method

    • SINTER(
      • keys: RedisVariadicArgument
      ) → Any

  Node.js Quick-Start

          jedis.sadd("bikes:racing:france", "bike:1", "bike:2", "bike:3");
          jedis.sadd("bikes:racing:usa", "bike:1", "bike:4");
  
          Set<String> res7 = jedis.sinter("bikes:racing:france", "bikes:racing:usa");
          System.out.println(res7);  // >>> [bike:1]
  

  ▼ Commands: SINTER

  • SINTER ( @read , @set , @slow )

    Returns the intersect of multiple sets.

    ▶ Method

    • sinter(
      • keys: String...
      ) → Set<String> // A set with members of the resulting set

  Java-Sync Quick-Start

              CompletableFuture<Void> sInter = asyncCommands.sinter("bikes:racing:france", "bikes:racing:usa")
                      .thenAccept(res7 -> {
                          System.out.println(res7); // >>> [bike:1]
                      }).toCompletableFuture();
  

  ▼ Commands: SINTER

  • SINTER ( @read , @set , @slow )

    Returns the intersect of multiple sets.

    ▶ Methods

    • sinter(
      • keys: K... // the keys.
      ) → RedisFuture<Set<V>> // Long count of members of the resulting set.
    • sinter(
      • channel: ValueStreamingChannel<V>, // the channel.
      • keys: K... // the keys.
      ) → RedisFuture<Long> // Long count of members of the resulting set.

  Java-Async Quick-Start

              Mono<List<String>> sInter = reactiveCommands.sinter("bikes:racing:france", "bikes:racing:usa").collectList()
                      .doOnNext(result -> {
                          System.out.println(result); // >>> [bike:1]
                      });
  

  ▼ Commands: SINTER

  • SINTER ( @read , @set , @slow )

    Returns the intersect of multiple sets.

    ▶ Methods

    • sinter(
      • keys: K... // the keys.
      ) → Flux<V> // Long count of members of the resulting set. @deprecated since 6.0 in favor of consuming large results through the org.reactivestreams.Publisher returned by #sinter.
    • sinter(
      • channel: ValueStreamingChannel<V>, // the channel.
      • keys: K... // the keys.
      ) → Mono<Long> // Long count of members of the resulting set. @deprecated since 6.0 in favor of consuming large results through the org.reactivestreams.Publisher returned by #sinter.

  Java-Reactive Quick-Start

  	res7, err := rdb.SInter(ctx, "bikes:racing:france", "bikes:racing:usa").Result()
  
  	if err != nil {
  		panic(err)
  	}
  
  	fmt.Println(res7) // >>> [bike:1]
  

  ▼ Commands: SINTER

  • SINTER ( @read , @set , @slow )

    Returns the intersect of multiple sets.

    ▶ Method

    • SInter(
      • ctx: context.Context,
      • keys: ...string
      ) → *StringSliceCmd

  Go Quick-Start

          long res7 = db.SetAdd("{bikes:racing}:france", ["bike:1", "bike:2", "bike:3"]);
          long res8 = db.SetAdd("{bikes:racing}:usa", ["bike:1", "bike:4"]);
  
          RedisValue[] res9 = db.SetCombine(SetOperation.Intersect, ["{bikes:racing}:france", "{bikes:racing}:usa"]);
          Console.WriteLine(string.Join(", ", res9)); // >>> bike:1
  

  ▼ Commands: SINTER

  • SINTER ( @read , @set , @slow )

    Returns the intersect of multiple sets.

    ▶ Methods

    • SetCombine(
      • operation: SetOperation, // The operation to perform.
      • first: RedisKey,
      • second: RedisKey,
      • flags: CommandFlags // The flags to use for this operation.
      ) → RedisValue[] // List with members of the resulting set.
    • SetCombine(
      • operation: SetOperation, // The operation to perform.
      • keys: RedisKey[], // The keys of the sets to operate on.
      • flags: CommandFlags // The flags to use for this operation.
      ) → RedisValue[] // List with members of the resulting set.
    • SetCombine(
      • operation: SetOperation, // The operation to perform.
      • first: RedisKey,
      • second: RedisKey,
      • flags: CommandFlags // The flags to use for this operation.
      ) → RedisValue[] // List with members of the resulting set.
    • SetCombine(
      • operation: SetOperation, // The operation to perform.
      • keys: RedisKey[], // The keys of the sets to operate on.
      • flags: CommandFlags // The flags to use for this operation.
      ) → RedisValue[] // List with members of the resulting set.

  C#-Sync (SE.Redis) Quick-Start

          $res7 = $r->sinter(['bikes:racing:france', 'bikes:racing:usa']);
          echo json_encode($res7) . PHP_EOL;
          // >>> ["bike:1"]
  

  ▼ Commands: SINTER

  • SINTER ( @read , @set , @slow )

    Returns the intersect of multiple sets.

    ▶ Method

    • sinter(
      • $keys: array|string
      ) → string[]

  PHP Quick-Start

  r.del('bikes:racing:france', 'bikes:racing:usa')
  r.sadd('bikes:racing:france', ['bike:1', 'bike:2', 'bike:3'])
  r.sadd('bikes:racing:usa', ['bike:1', 'bike:4'])
  res7 = r.sinter('bikes:racing:france', 'bikes:racing:usa')
  puts res7.inspect # ["bike:1"]
  

  ▼ Commands: SINTER

  • SINTER ( @read , @set , @slow )

    Returns the intersect of multiple sets.

    ▶ Method

    • sinter(
      • *keys: String, Array<String> // keys pointing to sets to intersect
      ) → Array<String> // members in the intersection

  Ruby Quick-Start

          if let Ok(res) = r.sinter(&["bikes:racing:france", "bikes:racing:usa"]) {
              let res: HashSet<String> = res;
              let res = sorted_set(res);
              println!("{res:?}"); // >>> ["bike:1"]
          }
  

  ▼ Commands: SINTER

  • SINTER ( @read , @set , @slow )

    Returns the intersect of multiple sets.

    ▶ Method

    • sinter(
      • keys: K
      ) → (HashSet<String>)

  Rust-Sync Quick-Start

          if let Ok(res) = r.sinter(&["bikes:racing:france", "bikes:racing:usa"]).await {
              let res: HashSet<String> = res;
              let res = sorted_set(res);
              println!("{res:?}"); // >>> ["bike:1"]
          }
  

  ▼ Commands: SINTER

  • SINTER ( @read , @set , @slow )

    Returns the intersect of multiple sets.

    ▶ Method

    • sinter(
      • keys: K
      ) → (HashSet<String>)

  Rust-Async Quick-Start

• How many bikes are racing in France?

  Language: >_ Redis CLI Python JavaScript (node-redis) Java-Sync Java-Async Java-Reactive Go C#-Sync (SE.Redis) PHP Ruby Rust-Sync Rust-Async

  Try it

  Show full output

  Copied!

  Copied!

  Foundational: Get the cardinality of a set using SCARD when you need to count unique items efficiently

  SCARD bikes:racing:france

  ▼ Commands: SCARD

  • SCARD ( @read , @set , @fast )

    Returns the number of members in a set.

  Redis CLI guide

  Also, check out our other client tools Redis Insight and Redis for VS Code.

  r.sadd("bikes:racing:france", "bike:1", "bike:2", "bike:3")
  res8 = r.scard("bikes:racing:france")
  print(res8)  # >>> 3
  

  ▼ Commands: SCARD

  • SCARD ( @read , @set , @fast )

    Returns the number of members in a set.

    ▶ Method

    • scard(
      • name: KeyT
      ) → Union[Awaitable[int], int]

  Python Quick-Start

  await client.del('bikes:racing:france')
  await client.sAdd('bikes:racing:france', ['bike:1', 'bike:2', 'bike:3'])
  const res8 = await client.sCard('bikes:racing:france')
  console.log(res8)  // >>> 3
  

  ▼ Commands: SCARD

  • SCARD ( @read , @set , @fast )

    Returns the number of members in a set.

    ▶ Method

    • SCARD(
      • key: RedisArgument
      ) → Any

  Node.js Quick-Start

          jedis.sadd("bikes:racing:france", "bike:1", "bike:2", "bike:3");
  
          long res8 = jedis.scard("bikes:racing:france");
          System.out.println(res8);  // >>> 3
  

  ▼ Commands: SCARD

  • SCARD ( @read , @set , @fast )

    Returns the number of members in a set.

    ▶ Methods

    • scard(
      • key: byte[]
      ) → long // The cardinality (number of elements) of the set as an integer
    • scard(
      • key: String
      ) → long // The cardinality (number of elements) of the set as an integer

  Java-Sync Quick-Start

              CompletableFuture<Void> sCard = asyncCommands.scard("bikes:racing:france").thenAccept(res8 -> {
                  System.out.println(res8); // >>> 3
              }).toCompletableFuture();
  

  ▼ Commands: SCARD

  • SCARD ( @read , @set , @fast )

    Returns the number of members in a set.

    ▶ Method

    • scard(
      • key: K // the key.
      ) → RedisFuture<Long> // Long integer-reply the cardinality (number of elements) of the set, or false if key does not exist.

  Java-Async Quick-Start

              Mono<Long> sCard = reactiveCommands.scard("bikes:racing:france").doOnNext(result -> {
                  System.out.println(result); // >>> 3
              });
  

  ▼ Commands: SCARD

  • SCARD ( @read , @set , @fast )

    Returns the number of members in a set.

    ▶ Method

    • scard(
      • key: K // the key.
      ) → Mono<Long> // Long integer-reply the cardinality (number of elements) of the set, or false if key does not exist.

  Java-Reactive Quick-Start

  	res8, err := rdb.SCard(ctx, "bikes:racing:france").Result()
  
  	if err != nil {
  		panic(err)
  	}
  
  	fmt.Println(res8) // >>> 3
  

  ▼ Commands: SCARD

  • SCARD ( @read , @set , @fast )

    Returns the number of members in a set.

    ▶ Method

    • SCard(
      • ctx: context.Context,
      • key: string
      ) → *IntCmd

  Go Quick-Start

          long res10 = db.SetAdd("bikes:racing:france", ["bike:1", "bike:2", "bike:3"]);
          long res11 = db.SetLength("bikes:racing:france");
          Console.WriteLine(res11);   // >>> 3
  

  ▼ Commands: SCARD

  • SCARD ( @read , @set , @fast )

    Returns the number of members in a set.

    ▶ Methods

    • SetLength(
      • key: RedisKey, // The key of the set.
      • flags: CommandFlags // The flags to use for this operation.
      ) → long // The cardinality (number of elements) of the set, or 0 if key does not exist.
    • SetLength(
      • key: RedisKey, // The key of the set.
      • flags: CommandFlags // The flags to use for this operation.
      ) → long // The cardinality (number of elements) of the set, or 0 if key does not exist.

  C#-Sync (SE.Redis) Quick-Start

          $res8 = $r->scard('bikes:racing:france');
          echo $res8 . PHP_EOL;
          // >>> 3
  

  ▼ Commands: SCARD

  • SCARD ( @read , @set , @fast )

    Returns the number of members in a set.

    ▶ Method

    • scard(
      • $key: string
      ) → int

  PHP Quick-Start

  r.del('bikes:racing:france')
  r.sadd('bikes:racing:france', ['bike:1', 'bike:2', 'bike:3'])
  res8 = r.scard('bikes:racing:france')
  puts res8 # 3
  

  ▼ Commands: SCARD

  • SCARD ( @read , @set , @fast )

    Returns the number of members in a set.

    ▶ Method

    • scard(
      • key: String
      ) → Integer

  Ruby Quick-Start

          if let Ok(res) = r.scard("bikes:racing:france") {
              let res: usize = res;
              println!("{res}"); // >>> 3
          }
  

  ▼ Commands: SCARD

  • SCARD ( @read , @set , @fast )

    Returns the number of members in a set.

    ▶ Method

    • scard(
      • key: K
      ) → (usize)

  Rust-Sync Quick-Start

          if let Ok(res) = r.scard("bikes:racing:france").await {
              let res: usize = res;
              println!("{res}"); // >>> 3
          }
  

  ▼ Commands: SCARD

  • SCARD ( @read , @set , @fast )

    Returns the number of members in a set.

    ▶ Method

    • scard(
      • key: K
      ) → (usize)

  Rust-Async Quick-Start

Tutorial

The SADD command adds new elements to a set. It's also possible to do a number of other operations against sets like testing if a given element already exists, performing the intersection, union or difference between multiple sets, and so forth.

r.delete("bikes:racing:france")

res9 = r.sadd("bikes:racing:france", "bike:1", "bike:2", "bike:3")
print(res9)  # >>> 3

res10 = r.smembers("bikes:racing:france")
print(res10)  # >>> {'bike:1', 'bike:2', 'bike:3'}