Redis lists

Introduction to Redis lists

Redis lists are linked lists of string values. Redis lists are frequently used to:

• Implement stacks and queues.
• Build queue management for background worker systems.

Examples

• Treat a list like a queue (first in, first out):

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

  Show full output

  Copied!

  Copied!

  Queue pattern: Use LPUSH to add items and RPOP to remove them in FIFO order when you need to process items in the order they were added

  > LPUSH bikes:repairs bike:1
  (integer) 1
  > LPUSH bikes:repairs bike:2
  (integer) 2
  > RPOP bikes:repairs
  "bike:1"
  > RPOP bikes:repairs
  "bike:2"

  ▼ Commands: LPUSH, RPOP

  • LPUSH ( @write , @list , @fast )

    Prepends one or more elements to a list. Creates the key if it doesn't exist.
  • RPOP ( @write , @list , @fast )

    Returns and removes the last elements of a list. Deletes the list if the last element was popped.

  Redis CLI guide

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

  res1 = r.lpush("bikes:repairs", "bike:1")
  print(res1)  # >>> 1
  
  res2 = r.lpush("bikes:repairs", "bike:2")
  print(res2)  # >>> 2
  
  res3 = r.rpop("bikes:repairs")
  print(res3)  # >>> bike:1
  
  res4 = r.rpop("bikes:repairs")
  print(res4)  # >>> bike:2
  

  ▼ Commands: LPUSH, RPOP

  • LPUSH ( @write , @list , @fast )

    Prepends one or more elements to a list. Creates the key if it doesn't exist.

    ▶ Method

    • lpush(
      • name: KeyT,
      • *values: FieldT
      ) → Union[Awaitable[int], int]
  • RPOP ( @write , @list , @fast )

    Returns and removes the last elements of a list. Deletes the list if the last element was popped.

    ▶ Method

    • rpop(
      • name: KeyT,
      • count: Optional[int] = None
      ) → Union[Awaitable[Union[str, List, None]], Union[str, List, None]]

  Python Quick-Start

  const res1 = await client.lPush('bikes:repairs', 'bike:1');
  console.log(res1);  // 1
  
  const res2 = await client.lPush('bikes:repairs', 'bike:2');
  console.log(res2);  // 2
  
  const res3 = await client.rPop('bikes:repairs');
  console.log(res3);  // bike:1
  
  const res4 = await client.rPop('bikes:repairs');
  console.log(res4);  // bike:2
  

  ▼ Commands: LPUSH, RPOP

  • LPUSH ( @write , @list , @fast )

    Prepends one or more elements to a list. Creates the key if it doesn't exist.

    ▶ Method

    • LPUSH(
      • key: RedisArgument,
      • elements: RedisVariadicArgument
      ) → Any
  • RPOP ( @write , @list , @fast )

    Returns and removes the last elements of a list. Deletes the list if the last element was popped.

    ▶ Method

    • RPOP(
      • key: RedisArgument
      ) → Any

  Node.js Quick-Start

          long res1 = jedis.lpush("bikes:repairs", "bike:1");
          System.out.println(res1);  // >>> 1
  
          long res2 = jedis.lpush("bikes:repairs", "bike:2");
          System.out.println(res2);  // >>> 2
  
          String res3 = jedis.rpop("bikes:repairs");
          System.out.println(res3);  // >>> bike:1
  
          String res4 = jedis.rpop("bikes:repairs");
          System.out.println(res4); // >>> bike:2
  

  ▼ Commands: LPUSH, RPOP

  • LPUSH ( @write , @list , @fast )

    Prepends one or more elements to a list. Creates the key if it doesn't exist.

    ▶ Methods

    • lpush(
      • key: byte[],
      • strings: byte[]... // data to push
      ) → long // The number of elements inside the list after the push operation
    • lpush(
      • key: String,
      • strings: String... // data to push
      ) → long // The number of elements inside the list after the push operation
    • lpush(
      • key: String,
      • strings: String... // data to push
      ) → long // The number of elements inside the list after the push operation
  • RPOP ( @write , @list , @fast )

    Returns and removes the last elements of a list. Deletes the list if the last element was popped.

    ▶ Methods

    • rpop(
      • key: String
      ) → String // A list of count popped elements, or 'nil' when key does not exist.
    • rpop(
      • key: String,
      • count: int // return up to count elements
      ) → List<String> // A list of count popped elements, or 'nil' when key does not exist.
    • rpop(
      • key: String
      ) → String // A list of count popped elements, or 'nil' when key does not exist.
    • rpop(
      • key: String,
      • count: int // return up to count elements
      ) → List<String> // A list of count popped elements, or 'nil' when key does not exist.

  Java-Sync Quick-Start

              CompletableFuture<Void> queue = asyncCommands.lpush("bikes:repairs", "bike:1").thenCompose(res1 -> {
                  System.out.println(res1); // >>> 1
  
                  return asyncCommands.lpush("bikes:repairs", "bike:2");
              }).thenCompose(res2 -> {
                  System.out.println(res2); // >>> 2
  
                  return asyncCommands.rpop("bikes:repairs");
              }).thenCompose(res3 -> {
                  System.out.println(res3); // >>> bike:1
  
                  return asyncCommands.rpop("bikes:repairs");
              })
                      .thenAccept(System.out::println) // >>> bike:2
                      .toCompletableFuture();
  

  ▼ Commands: LPUSH, RPOP

  • LPUSH ( @write , @list , @fast )

    Prepends one or more elements to a list. Creates the key if it doesn't exist.

    ▶ Method

    • lpush(
      • key: K, // the key.
      • values: V... // the value.
      ) → RedisFuture<Long> // Long integer-reply the length of the list after the push operations.
  • RPOP ( @write , @list , @fast )

    Returns and removes the last elements of a list. Deletes the list if the last element was popped.

    ▶ Methods

    • rpop(
      • key: K // the key.
      ) → RedisFuture<V> // List&lt;V&gt; array-reply list of the last count elements, or null when key does not exist. @since 6.1
    • rpop(
      • key: K, // the key.
      • count: long // the number of elements to return.
      ) → RedisFuture<List<V>> // List&lt;V&gt; array-reply list of the last count elements, or null when key does not exist. @since 6.1

  Java-Async Quick-Start

  	res1, err := rdb.LPush(ctx, "bikes:repairs", "bike:1").Result()
  
  	if err != nil {
  		panic(err)
  	}
  
  	fmt.Println(res1) // >>> 1
  
  	res2, err := rdb.LPush(ctx, "bikes:repairs", "bike:2").Result()
  
  	if err != nil {
  		panic(err)
  	}
  
  	fmt.Println(res2) // >>> 2
  
  	res3, err := rdb.RPop(ctx, "bikes:repairs").Result()
  
  	if err != nil {
  		panic(err)
  	}
  
  	fmt.Println(res3) // >>> bike:1
  
  	res4, err := rdb.RPop(ctx, "bikes:repairs").Result()
  
  	if err != nil {
  		panic(err)
  	}
  
  	fmt.Println(res4) // >>> bike:2
  

  ▼ Commands: LPUSH, RPOP

  • LPUSH ( @write , @list , @fast )

    Prepends one or more elements to a list. Creates the key if it doesn't exist.

    ▶ Method

    • LPush(
      • ctx: context.Context,
      • key: string,
      • values: ...interface{}
      ) → *IntCmd
  • RPOP ( @write , @list , @fast )

    Returns and removes the last elements of a list. Deletes the list if the last element was popped.

    ▶ Method

    • RPop(
      • ctx: context.Context,
      • key: string
      ) → *StringCmd

  Go Quick-Start

          long res1 = db.ListLeftPush("bikes:repairs", "bike:1");
          Console.WriteLine(res1);    // >>> 1
  
          long res2 = db.ListLeftPush("bikes:repairs", "bike:2");
          Console.WriteLine(res2);    // >>> 2
  
          RedisValue res3 = db.ListRightPop("bikes:repairs");
          Console.WriteLine(res3);    // >>> "bike:1"
  
          RedisValue res4 = db.ListRightPop("bikes:repairs");
          Console.WriteLine(res4); // >>> "bike:2"
  

  ▼ Commands: LPUSH, RPOP

  • LPUSH ( @write , @list , @fast )

    Prepends one or more elements to a list. Creates the key if it doesn't exist.

    ▶ Methods

    • ListLeftPush(
      • key: RedisKey, // The key of the list.
      • value: RedisValue,
      • when: When,
      • flags: CommandFlags // The flags to use for this operation.
      ) → long // The length of the list after the push operations.
    • ListLeftPush(
      • key: RedisKey, // The key of the list.
      • values: RedisValue[], // The values to add to the head of the list.
      • when: When,
      • flags: CommandFlags // The flags to use for this operation.
      ) → long // The length of the list after the push operations.
    • ListLeftPush(
      • key: RedisKey, // The key of the list.
      • values: RedisValue[], // The values to add to the head of the list.
      • flags: CommandFlags // The flags to use for this operation.
      ) → long // The length of the list after the push operations.
    • ListLeftPush(
      • key: RedisKey, // The key of the list.
      • value: RedisValue,
      • when: When,
      • flags: CommandFlags // The flags to use for this operation.
      ) → long // The length of the list after the push operations.
    • ListLeftPush(
      • key: RedisKey, // The key of the list.
      • values: RedisValue[], // The values to add to the head of the list.
      • when: When,
      • flags: CommandFlags // The flags to use for this operation.
      ) → long // The length of the list after the push operations.
  • RPOP ( @write , @list , @fast )

    Returns and removes the last elements of a list. Deletes the list if the last element was popped.

    ▶ Methods

    • ListRightPop(
      • key: RedisKey,
      • flags: CommandFlags // The flags to use for this operation.
      ) → RedisValue // A span of contiguous elements from the list, or Null if no non-empty lists are found.
    • ListRightPop(
      • key: RedisKey,
      • count: long, // The maximum number of elements to pop from the list.
      • flags: CommandFlags // The flags to use for this operation.
      ) → RedisValue[] // A span of contiguous elements from the list, or Null if no non-empty lists are found.
    • ListRightPop(
      • keys: RedisKey[], // The keys to look through for elements to pop.
      • count: long, // The maximum number of elements to pop from the list.
      • flags: CommandFlags // The flags to use for this operation.
      ) → ListPopResult // A span of contiguous elements from the list, or Null if no non-empty lists are found.
    • ListRightPop(
      • key: RedisKey,
      • flags: CommandFlags // The flags to use for this operation.
      ) → RedisValue // A span of contiguous elements from the list, or Null if no non-empty lists are found.
    • ListRightPop(
      • key: RedisKey,
      • count: long, // The maximum number of elements to pop from the list.
      • flags: CommandFlags // The flags to use for this operation.
      ) → RedisValue[] // A span of contiguous elements from the list, or Null if no non-empty lists are found.

  C#-Sync (NRedisStack) Quick-Start

          long res1 = db.ListLeftPush("bikes:repairs", "bike:1");
          Console.WriteLine(res1);    // >>> 1
  
          long res2 = db.ListLeftPush("bikes:repairs", "bike:2");
          Console.WriteLine(res2);    // >>> 2
  
          RedisValue res3 = db.ListRightPop("bikes:repairs");
          Console.WriteLine(res3);    // >>> "bike:1"
  
          RedisValue res4 = db.ListRightPop("bikes:repairs");
          Console.WriteLine(res4); // >>> "bike:2"
  

  ▼ Commands: LPUSH, RPOP

  • LPUSH ( @write , @list , @fast )

    Prepends one or more elements to a list. Creates the key if it doesn't exist.

    ▶ Methods

    • ListLeftPush(
      • key: RedisKey, // The key of the list.
      • value: RedisValue,
      • when: When,
      • flags: CommandFlags // The flags to use for this operation.
      ) → long // The length of the list after the push operations.
    • ListLeftPush(
      • key: RedisKey, // The key of the list.
      • values: RedisValue[], // The values to add to the head of the list.
      • when: When,
      • flags: CommandFlags // The flags to use for this operation.
      ) → long // The length of the list after the push operations.
    • ListLeftPush(
      • key: RedisKey, // The key of the list.
      • values: RedisValue[], // The values to add to the head of the list.
      • flags: CommandFlags // The flags to use for this operation.
      ) → long // The length of the list after the push operations.
    • ListLeftPush(
      • key: RedisKey, // The key of the list.
      • value: RedisValue,
      • when: When,
      • flags: CommandFlags // The flags to use for this operation.
      ) → long // The length of the list after the push operations.
    • ListLeftPush(
      • key: RedisKey, // The key of the list.
      • values: RedisValue[], // The values to add to the head of the list.
      • when: When,
      • flags: CommandFlags // The flags to use for this operation.
      ) → long // The length of the list after the push operations.
  • RPOP ( @write , @list , @fast )

    Returns and removes the last elements of a list. Deletes the list if the last element was popped.

    ▶ Methods

    • ListRightPop(
      • key: RedisKey,
      • flags: CommandFlags // The flags to use for this operation.
      ) → RedisValue // A span of contiguous elements from the list, or Null if no non-empty lists are found.
    • ListRightPop(
      • key: RedisKey,
      • count: long, // The maximum number of elements to pop from the list.
      • flags: CommandFlags // The flags to use for this operation.
      ) → RedisValue[] // A span of contiguous elements from the list, or Null if no non-empty lists are found.
    • ListRightPop(
      • keys: RedisKey[], // The keys to look through for elements to pop.
      • count: long, // The maximum number of elements to pop from the list.
      • flags: CommandFlags // The flags to use for this operation.
      ) → ListPopResult // A span of contiguous elements from the list, or Null if no non-empty lists are found.
    • ListRightPop(
      • key: RedisKey,
      • flags: CommandFlags // The flags to use for this operation.
      ) → RedisValue // A span of contiguous elements from the list, or Null if no non-empty lists are found.
    • ListRightPop(
      • key: RedisKey,
      • count: long, // The maximum number of elements to pop from the list.
      • flags: CommandFlags // The flags to use for this operation.
      ) → RedisValue[] // A span of contiguous elements from the list, or Null if no non-empty lists are found.

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

          $res1 = $r->lpush('bikes:repairs', 'bike:1');
          echo $res1 . PHP_EOL;
          // >>> 1
  
          $res2 = $r->lpush('bikes:repairs', 'bike:2');
          echo $res2 . PHP_EOL;
          // >>> 2
  
          $res3 = $r->rpop('bikes:repairs');
          echo $res3 . PHP_EOL;
          // >>> bike:1
  
          $res4 = $r->rpop('bikes:repairs');
          echo $res4 . PHP_EOL;
          // >>> bike:2
  

  ▼ Commands: LPUSH, RPOP

  • LPUSH ( @write , @list , @fast )

    Prepends one or more elements to a list. Creates the key if it doesn't exist.

    ▶ Method

    • lpush(
      • $key: string,
      • $values: array
      ) → int
  • RPOP ( @write , @list , @fast )

    Returns and removes the last elements of a list. Deletes the list if the last element was popped.

    ▶ Method

    • rpop(
      • $key: string
      ) → string|null

  PHP Quick-Start

  res1 = r.lpush('bikes:repairs', 'bike:1')
  puts res1 # 1
  
  res2 = r.lpush('bikes:repairs', 'bike:2')
  puts res2 # 2
  
  res3 = r.rpop('bikes:repairs')
  puts res3 # bike:1
  
  res4 = r.rpop('bikes:repairs')
  puts res4 # bike:2
  

  ▼ Commands: LPUSH, RPOP

  • LPUSH ( @write , @list , @fast )

    Prepends one or more elements to a list. Creates the key if it doesn't exist.

    ▶ Method

    • lpush(
      • key: String,
      • value: String, Array<String> // string value, or array of string values to push
      ) → Integer // the length of the list after the push operation
  • RPOP ( @write , @list , @fast )

    Returns and removes the last elements of a list. Deletes the list if the last element was popped.

    ▶ Method

    • rpop(
      • key: String,
      • count: Integer // number of elements to remove
      ) → nil, String, Array<String> // the values of the last elements

  Ruby Quick-Start

          if let Ok(res) = r.lpush("bikes:repairs", "bike:1") {
              let res: usize = res;
              println!("{res}"); // >>> 1
          }
  
          if let Ok(res) = r.lpush("bikes:repairs", "bike:2") {
              let res: usize = res;
              println!("{res}"); // >>> 2
          }
  
          if let Ok(res) = r.rpop("bikes:repairs", None) {
              let res: Option<String> = res;
              print_optional_string(res.clone()); // >>> bike:1
          }
  
          if let Ok(res) = r.rpop("bikes:repairs", None) {
              let res: Option<String> = res;
              print_optional_string(res.clone()); // >>> bike:2
          }
  

  ▼ Commands: LPUSH, RPOP

  • LPUSH ( @write , @list , @fast )

    Prepends one or more elements to a list. Creates the key if it doesn't exist.

    ▶ Method

    • lpush(
      • key: K,
      • value: V
      ) → (usize)
  • RPOP ( @write , @list , @fast )

    Returns and removes the last elements of a list. Deletes the list if the last element was popped.

    ▶ Method

    • rpop(
      • key: K,
      • count: Option<core
      ) → Generic

  Rust-Sync Quick-Start

          if let Ok(res) = r.lpush("bikes:repairs", "bike:1").await {
              let res: usize = res;
              println!("{res}"); // >>> 1
          }
  
          if let Ok(res) = r.lpush("bikes:repairs", "bike:2").await {
              let res: usize = res;
              println!("{res}"); // >>> 2
          }
  
          if let Ok(res) = r.rpop("bikes:repairs", None).await {
              let res: Option<String> = res;
              print_optional_string(res.clone()); // >>> bike:1
          }
  
          if let Ok(res) = r.rpop("bikes:repairs", None).await {
              let res: Option<String> = res;
              print_optional_string(res.clone()); // >>> bike:2
          }
  

  ▼ Commands: LPUSH, RPOP

  • LPUSH ( @write , @list , @fast )

    Prepends one or more elements to a list. Creates the key if it doesn't exist.

    ▶ Method

    • lpush(
      • key: K,
      • value: V
      ) → (usize)
  • RPOP ( @write , @list , @fast )

    Returns and removes the last elements of a list. Deletes the list if the last element was popped.

    ▶ Method

    • rpop(
      • key: K,
      • count: Option<core
      ) → Generic

  Rust-Async Quick-Start

• Treat a list like a stack (first in, last out):

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

  Show full output

  Copied!

  Copied!

  Stack pattern: Use LPUSH to add items and LPOP to remove them in LIFO order when you need to process items in reverse order

  > LPUSH bikes:repairs bike:1
  (integer) 1
  > LPUSH bikes:repairs bike:2
  (integer) 2
  > LPOP bikes:repairs
  "bike:2"
  > LPOP bikes:repairs
  "bike:1"

  ▼ Commands: LPUSH, LPOP

  • LPUSH ( @write , @list , @fast )

    Prepends one or more elements to a list. Creates the key if it doesn't exist.
  • LPOP ( @write , @list , @fast )

    Returns the first elements in a list after removing it. Deletes the list if the last element was popped.

  Redis CLI guide

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

  res5 = r.lpush("bikes:repairs", "bike:1")
  print(res5)  # >>> 1
  
  res6 = r.lpush("bikes:repairs", "bike:2")
  print(res6)  # >>> 2
  
  res7 = r.lpop("bikes:repairs")
  print(res7)  # >>> bike:2
  
  res8 = r.lpop("bikes:repairs")
  print(res8)  # >>> bike:1
  

  ▼ Commands: LPUSH, LPOP

  • LPUSH ( @write , @list , @fast )

    Prepends one or more elements to a list. Creates the key if it doesn't exist.

    ▶ Method

    • lpush(
      • name: KeyT,
      • *values: FieldT
      ) → Union[Awaitable[int], int]
  • LPOP ( @write , @list , @fast )

    Returns the first elements in a list after removing it. Deletes the list if the last element was popped.

    ▶ Method

    • lpop(
      • name: KeyT,
      • count: Optional[int] = None
      ) → Union[Awaitable[Union[str, List, None]], Union[str, List, None]]

  Python Quick-Start

  const res5 = await client.lPush('bikes:repairs', 'bike:1');
  console.log(res5);  // 1
  
  const res6 = await client.lPush('bikes:repairs', 'bike:2');
  console.log(res6); // 2
  
  const res7 = await client.lPop('bikes:repairs');
  console.log(res7);  // bike:2
  
  const res8 = await client.lPop('bikes:repairs');
  console.log(res8);  // bike:1
  

  ▼ Commands: LPUSH, LPOP

  • LPUSH ( @write , @list , @fast )

    Prepends one or more elements to a list. Creates the key if it doesn't exist.

    ▶ Method

    • LPUSH(
      • key: RedisArgument,
      • elements: RedisVariadicArgument
      ) → Any
  • LPOP ( @write , @list , @fast )

    Returns the first elements in a list after removing it. Deletes the list if the last element was popped.

    ▶ Method

    • LPOP(
      • key: RedisArgument
      ) → Any

  Node.js Quick-Start

          long res5 = jedis.lpush("bikes:repairs", "bike:1");
          System.out.println(res5);  // >>> 1
  
          long res6 = jedis.lpush("bikes:repairs", "bike:2");
          System.out.println(res6);  // >>> 2
  
          String res7 = jedis.lpop("bikes:repairs");
          System.out.println(res7);  // >>> bike:2
  
          String res8 = jedis.lpop("bikes:repairs");
          System.out.println(res8);  // >>> bike:1
  

  ▼ Commands: LPUSH, LPOP

  • LPUSH ( @write , @list , @fast )

    Prepends one or more elements to a list. Creates the key if it doesn't exist.

    ▶ Methods

    • lpush(
      • key: byte[],
      • strings: byte[]... // data to push
      ) → long // The number of elements inside the list after the push operation
    • lpush(
      • key: String,
      • strings: String... // data to push
      ) → long // The number of elements inside the list after the push operation
    • lpush(
      • key: String,
      • strings: String... // data to push
      ) → long // The number of elements inside the list after the push operation
  • LPOP ( @write , @list , @fast )

    Returns the first elements in a list after removing it. Deletes the list if the last element was popped.

    ▶ Methods

    • lpop(
      • key: String
      ) → String // A list of popped elements, or 'nil' when key does not exist
    • lpop(
      • key: String,
      • count: int
      ) → List<String> // A list of popped elements, or 'nil' when key does not exist
    • lpop(
      • key: String
      ) → String // A list of popped elements, or 'nil' when key does not exist
    • lpop(
      • key: String,
      • count: int
      ) → List<String> // A list of popped elements, or 'nil' when key does not exist

  Java-Sync Quick-Start

              CompletableFuture<Void> stack = asyncCommands.lpush("bikes:repairs", "bike:1").thenCompose(res4 -> {
                  System.out.println(res4); // >>> 1
  
                  return asyncCommands.lpush("bikes:repairs", "bike:2");
              }).thenCompose(res5 -> {
                  System.out.println(res5); // >>> 2
  
                  return asyncCommands.lpop("bikes:repairs");
              }).thenCompose(res6 -> {
                  System.out.println(res6); // >>> bike:2
  
                  return asyncCommands.lpop("bikes:repairs");
              })
                      .thenAccept(System.out::println) // >>> bike:1
                      .toCompletableFuture();
  

  ▼ Commands: LPUSH, LPOP

  • LPUSH ( @write , @list , @fast )

    Prepends one or more elements to a list. Creates the key if it doesn't exist.

    ▶ Method

    • lpush(
      • key: K, // the key.
      • values: V... // the value.
      ) → RedisFuture<Long> // Long integer-reply the length of the list after the push operations.
  • LPOP ( @write , @list , @fast )

    Returns the first elements in a list after removing it. Deletes the list if the last element was popped.

    ▶ Methods

    • lpop(
      • key: K // the key.
      ) → RedisFuture<V> // @return List&lt;V&gt; array-reply list of the first count elements, or null when key does not exist. @since 6.1
    • lpop(
      • key: K, // the key.
      • count: long // the number of elements to return.
      ) → RedisFuture<List<V>> // @return List&lt;V&gt; array-reply list of the first count elements, or null when key does not exist. @since 6.1

  Java-Async Quick-Start

  	res5, err := rdb.LPush(ctx, "bikes:repairs", "bike:1").Result()
  
  	if err != nil {
  		panic(err)
  	}
  
  	fmt.Println(res5) // >>> 1
  
  	res6, err := rdb.LPush(ctx, "bikes:repairs", "bike:2").Result()
  
  	if err != nil {
  		panic(err)
  	}
  
  	fmt.Println(res6) // >>> 2
  
  	res7, err := rdb.LPop(ctx, "bikes:repairs").Result()
  
  	if err != nil {
  		panic(err)
  	}
  
  	fmt.Println(res7) // >>> bike:2
  
  	res8, err := rdb.LPop(ctx, "bikes:repairs").Result()
  
  	if err != nil {
  		panic(err)
  	}
  
  	fmt.Println(res8) // >>> bike:1
  

  ▼ Commands: LPUSH, LPOP

  • LPUSH ( @write , @list , @fast )

    Prepends one or more elements to a list. Creates the key if it doesn't exist.

    ▶ Method

    • LPush(
      • ctx: context.Context,
      • key: string,
      • values: ...interface{}
      ) → *IntCmd
  • LPOP ( @write , @list , @fast )

    Returns the first elements in a list after removing it. Deletes the list if the last element was popped.

    ▶ Method

    • LPop(
      • ctx: context.Context,
      • key: string
      ) → *StringCmd

  Go Quick-Start

          long res5 = db.ListLeftPush("bikes:repairs", "bike:1");
          Console.WriteLine(res5);    // >>> 1
  
          long res6 = db.ListLeftPush("bikes:repairs", "bike:2");
          Console.WriteLine(res6);    // >>> 2
  
          RedisValue res7 = db.ListLeftPop("bikes:repairs");
          Console.WriteLine(res7);    // >>> "bike:2"
  
          RedisValue res8 = db.ListLeftPop("bikes:repairs");
          Console.WriteLine(res8);    // >>> "bike:1"
  

  ▼ Commands: LPUSH, LPOP

  • LPUSH ( @write , @list , @fast )

    Prepends one or more elements to a list. Creates the key if it doesn't exist.

    ▶ Methods

    • ListLeftPush(
      • key: RedisKey, // The key of the list.
      • value: RedisValue,
      • when: When,
      • flags: CommandFlags // The flags to use for this operation.
      ) → long // The length of the list after the push operations.
    • ListLeftPush(
      • key: RedisKey, // The key of the list.
      • values: RedisValue[], // The values to add to the head of the list.
      • when: When,
      • flags: CommandFlags // The flags to use for this operation.
      ) → long // The length of the list after the push operations.
    • ListLeftPush(
      • key: RedisKey, // The key of the list.
      • values: RedisValue[], // The values to add to the head of the list.
      • flags: CommandFlags // The flags to use for this operation.
      ) → long // The length of the list after the push operations.
    • ListLeftPush(
      • key: RedisKey, // The key of the list.
      • value: RedisValue,
      • when: When,
      • flags: CommandFlags // The flags to use for this operation.
      ) → long // The length of the list after the push operations.
    • ListLeftPush(
      • key: RedisKey, // The key of the list.
      • values: RedisValue[], // The values to add to the head of the list.
      • when: When,
      • flags: CommandFlags // The flags to use for this operation.
      ) → long // The length of the list after the push operations.
  • LPOP ( @write , @list , @fast )

    Returns the first elements in a list after removing it. Deletes the list if the last element was popped.

    ▶ Methods

    • ListLeftPop(
      • key: RedisKey,
      • flags: CommandFlags // The flags to use for this operation.
      ) → RedisValue // A span of contiguous elements from the list, or Null if no non-empty lists are found.
    • ListLeftPop(
      • key: RedisKey,
      • count: long, // The maximum number of elements to pop from the list.
      • flags: CommandFlags // The flags to use for this operation.
      ) → RedisValue[] // A span of contiguous elements from the list, or Null if no non-empty lists are found.
    • ListLeftPop(
      • keys: RedisKey[], // The keys to look through for elements to pop.
      • count: long, // The maximum number of elements to pop from the list.
      • flags: CommandFlags // The flags to use for this operation.
      ) → ListPopResult // A span of contiguous elements from the list, or Null if no non-empty lists are found.
    • ListLeftPop(
      • key: RedisKey,
      • flags: CommandFlags // The flags to use for this operation.
      ) → RedisValue // A span of contiguous elements from the list, or Null if no non-empty lists are found.
    • ListLeftPop(
      • key: RedisKey,
      • count: long, // The maximum number of elements to pop from the list.
      • flags: CommandFlags // The flags to use for this operation.
      ) → RedisValue[] // A span of contiguous elements from the list, or Null if no non-empty lists are found.

  C#-Sync (NRedisStack) Quick-Start

          long res5 = db.ListLeftPush("bikes:repairs", "bike:1");
          Console.WriteLine(res5);    // >>> 1
  
          long res6 = db.ListLeftPush("bikes:repairs", "bike:2");
          Console.WriteLine(res6);    // >>> 2
  
          RedisValue res7 = db.ListLeftPop("bikes:repairs");
          Console.WriteLine(res7);    // >>> "bike:2"
  
          RedisValue res8 = db.ListLeftPop("bikes:repairs");
          Console.WriteLine(res8);    // >>> "bike:1"
  

  ▼ Commands: LPUSH, LPOP

  • LPUSH ( @write , @list , @fast )

    Prepends one or more elements to a list. Creates the key if it doesn't exist.

    ▶ Methods

    • ListLeftPush(
      • key: RedisKey, // The key of the list.
      • value: RedisValue,
      • when: When,
      • flags: CommandFlags // The flags to use for this operation.
      ) → long // The length of the list after the push operations.
    • ListLeftPush(
      • key: RedisKey, // The key of the list.
      • values: RedisValue[], // The values to add to the head of the list.
      • when: When,
      • flags: CommandFlags // The flags to use for this operation.
      ) → long // The length of the list after the push operations.
    • ListLeftPush(
      • key: RedisKey, // The key of the list.
      • values: RedisValue[], // The values to add to the head of the list.
      • flags: CommandFlags // The flags to use for this operation.
      ) → long // The length of the list after the push operations.
    • ListLeftPush(
      • key: RedisKey, // The key of the list.
      • value: RedisValue,
      • when: When,
      • flags: CommandFlags // The flags to use for this operation.
      ) → long // The length of the list after the push operations.
    • ListLeftPush(
      • key: RedisKey, // The key of the list.
      • values: RedisValue[], // The values to add to the head of the list.
      • when: When,
      • flags: CommandFlags // The flags to use for this operation.
      ) → long // The length of the list after the push operations.
  • LPOP ( @write , @list , @fast )

    Returns the first elements in a list after removing it. Deletes the list if the last element was popped.

    ▶ Methods

    • ListLeftPop(
      • key: RedisKey,
      • flags: CommandFlags // The flags to use for this operation.
      ) → RedisValue // A span of contiguous elements from the list, or Null if no non-empty lists are found.
    • ListLeftPop(
      • key: RedisKey,
      • count: long, // The maximum number of elements to pop from the list.
      • flags: CommandFlags // The flags to use for this operation.
      ) → RedisValue[] // A span of contiguous elements from the list, or Null if no non-empty lists are found.
    • ListLeftPop(
      • keys: RedisKey[], // The keys to look through for elements to pop.
      • count: long, // The maximum number of elements to pop from the list.
      • flags: CommandFlags // The flags to use for this operation.
      ) → ListPopResult // A span of contiguous elements from the list, or Null if no non-empty lists are found.
    • ListLeftPop(
      • key: RedisKey,
      • flags: CommandFlags // The flags to use for this operation.
      ) → RedisValue // A span of contiguous elements from the list, or Null if no non-empty lists are found.
    • ListLeftPop(
      • key: RedisKey,
      • count: long, // The maximum number of elements to pop from the list.
      • flags: CommandFlags // The flags to use for this operation.
      ) → RedisValue[] // A span of contiguous elements from the list, or Null if no non-empty lists are found.

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

          $res5 = $r->lpush('bikes:repairs', 'bike:1');
          echo $res5 . PHP_EOL;
          // >>> 1
  
          $res6 = $r->lpush('bikes:repairs', 'bike:2');
          echo $res6 . PHP_EOL;
          // >>> 2
  
          $res7 = $r->lpop('bikes:repairs');
          echo $res7 . PHP_EOL;
          // >>> bike:2
  
          $res8 = $r->lpop('bikes:repairs');
          echo $res8 . PHP_EOL;
          // >>> bike:1
  

  ▼ Commands: LPUSH, LPOP

  • LPUSH ( @write , @list , @fast )

    Prepends one or more elements to a list. Creates the key if it doesn't exist.

    ▶ Method

    • lpush(
      • $key: string,
      • $values: array
      ) → int
  • LPOP ( @write , @list , @fast )

    Returns the first elements in a list after removing it. Deletes the list if the last element was popped.

    ▶ Method

    • lpop(
      • $key: string
      ) → string|null

  PHP Quick-Start

  res5 = r.lpush('bikes:repairs', 'bike:1')
  puts res5 # 1
  
  res6 = r.lpush('bikes:repairs', 'bike:2')
  puts res6 # 2
  
  res7 = r.lpop('bikes:repairs')
  puts res7 # bike:2
  
  res8 = r.lpop('bikes:repairs')
  puts res8 # bike:1
  

  ▼ Commands: LPUSH, LPOP

  • LPUSH ( @write , @list , @fast )

    Prepends one or more elements to a list. Creates the key if it doesn't exist.

    ▶ Method

    • lpush(
      • key: String,
      • value: String, Array<String> // string value, or array of string values to push
      ) → Integer // the length of the list after the push operation
  • LPOP ( @write , @list , @fast )

    Returns the first elements in a list after removing it. Deletes the list if the last element was popped.

    ▶ Method

    • lpop(
      • key: String,
      • count: Integer // number of elements to remove
      ) → nil, String, Array<String> // the values of the first elements

  Ruby Quick-Start

          if let Ok(res) = r.lpush("bikes:repairs", "bike:1") {
              let res: usize = res;
              println!("{res}"); // >>> 1
          }
  
          if let Ok(res) = r.lpush("bikes:repairs", "bike:2") {
              let res: usize = res;
              println!("{res}"); // >>> 2
          }
  
          if let Ok(res) = r.lpop("bikes:repairs", None) {
              let res: Option<String> = res;
              print_optional_string(res.clone()); // >>> bike:2
          }
  
          if let Ok(res) = r.lpop("bikes:repairs", None) {
              let res: Option<String> = res;
              print_optional_string(res.clone()); // >>> bike:1
          }
  

  ▼ Commands: LPUSH, LPOP

  • LPUSH ( @write , @list , @fast )

    Prepends one or more elements to a list. Creates the key if it doesn't exist.

    ▶ Method

    • lpush(
      • key: K,
      • value: V
      ) → (usize)
  • LPOP ( @write , @list , @fast )

    Returns the first elements in a list after removing it. Deletes the list if the last element was popped.

    ▶ Method

    • lpop(
      • key: K,
      • count: Option<core
      ) → Generic

  Rust-Sync Quick-Start

          if let Ok(res) = r.lpush("bikes:repairs", "bike:1").await {
              let res: usize = res;
              println!("{res}"); // >>> 1
          }
  
          if let Ok(res) = r.lpush("bikes:repairs", "bike:2").await {
              let res: usize = res;
              println!("{res}"); // >>> 2
          }
  
          if let Ok(res) = r.lpop("bikes:repairs", None).await {
              let res: Option<String> = res;
              print_optional_string(res.clone()); // >>> bike:2
          }
  
          if let Ok(res) = r.lpop("bikes:repairs", None).await {
              let res: Option<String> = res;
              print_optional_string(res.clone()); // >>> bike:1
          }
  

  ▼ Commands: LPUSH, LPOP

  • LPUSH ( @write , @list , @fast )

    Prepends one or more elements to a list. Creates the key if it doesn't exist.

    ▶ Method

    • lpush(
      • key: K,
      • value: V
      ) → (usize)
  • LPOP ( @write , @list , @fast )

    Returns the first elements in a list after removing it. Deletes the list if the last element was popped.

    ▶ Method

    • lpop(
      • key: K,
      • count: Option<core
      ) → Generic

  Rust-Async Quick-Start

• Check the length of a list:

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

  Show full output

  Copied!

  Copied!

  Foundational: Get the number of elements in a list using LLEN to check list size

  > LLEN bikes:repairs
  (integer) 0

  ▼ Commands: LLEN

  • LLEN ( @read , @list , @fast )

    Returns the length of a list.

  Redis CLI guide

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

  res9 = r.llen("bikes:repairs")
  print(res9)  # >>> 0
  

  ▼ Commands: LLEN

  • LLEN ( @read , @list , @fast )

    Returns the length of a list.

    ▶ Method

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

  Python Quick-Start

  const res9 = await client.lLen('bikes:repairs');
  console.log(res9); // 0
  

  ▼ Commands: LLEN

  • LLEN ( @read , @list , @fast )

    Returns the length of a list.

    ▶ Method

    • LLEN(
      • key: RedisArgument
      ) → Any

  Node.js Quick-Start

          long res9 = jedis.llen("bikes:repairs");
          System.out.println(res9);  // >>> 0
  

  ▼ Commands: LLEN

  • LLEN ( @read , @list , @fast )

    Returns the length of a list.

    ▶ Methods

    • llen(
      • key: byte[]
      ) → long // The length of the list
    • llen(
      • key: String
      ) → long // The length of the list
    • llen(
      • key: String
      ) → long // The length of the list

  Java-Sync Quick-Start

              CompletableFuture<Void> llen = asyncCommands.llen("bikes:repairs")
                      .thenAccept(System.out::println) // >>> 0
                      .toCompletableFuture();
  

  ▼ Commands: LLEN

  • LLEN ( @read , @list , @fast )

    Returns the length of a list.

    ▶ Method

    • llen(
      • key: K // the key.
      ) → RedisFuture<Long> // Long integer-reply the length of the list at key.

  Java-Async Quick-Start

  	res9, err := rdb.LLen(ctx, "bikes:repairs").Result()
  
  	if err != nil {
  		panic(err)
  	}
  
  	fmt.Println(res9) // >>> 0
  

  ▼ Commands: LLEN

  • LLEN ( @read , @list , @fast )

    Returns the length of a list.

    ▶ Method

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

  Go Quick-Start

          long res9 = db.ListLength("bikes:repairs");
          Console.WriteLine(res9);    // >>> 0
  

  ▼ Commands: LLEN

  • LLEN ( @read , @list , @fast )

    Returns the length of a list.

    ▶ Methods

    • ListLength(
      • key: RedisKey, // The key of the list.
      • flags: CommandFlags // The flags to use for this operation.
      ) → long // The length of the list at key.
    • ListLength(
      • key: RedisKey, // The key of the list.
      • flags: CommandFlags // The flags to use for this operation.
      ) → long // The length of the list at key.

  C#-Sync (NRedisStack) Quick-Start

          long res9 = db.ListLength("bikes:repairs");
          Console.WriteLine(res9);    // >>> 0
  

  ▼ Commands: LLEN

  • LLEN ( @read , @list , @fast )

    Returns the length of a list.

    ▶ Methods

    • ListLength(
      • key: RedisKey, // The key of the list.
      • flags: CommandFlags // The flags to use for this operation.
      ) → long // The length of the list at key.
    • ListLength(
      • key: RedisKey, // The key of the list.
      • flags: CommandFlags // The flags to use for this operation.
      ) → long // The length of the list at key.

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

          $res9 = $r->llen('bikes:repairs');
          echo $res9 . PHP_EOL;
          // >>> 0
  

  ▼ Commands: LLEN

  • LLEN ( @read , @list , @fast )

    Returns the length of a list.

    ▶ Method

    • llen(
      • $key: string
      ) → int

  PHP Quick-Start

  res9 = r.llen('bikes:repairs')
  puts res9 # 0
  

  ▼ Commands: LLEN

  • LLEN ( @read , @list , @fast )

    Returns the length of a list.

    ▶ Method

    • llen(
      • key: String
      ) → Integer

  Ruby Quick-Start

          if let Ok(res) = r.llen("bikes:repairs") {
              let res: usize = res;
              println!("{res}"); // >>> 0
          }
  

  ▼ Commands: LLEN

  • LLEN ( @read , @list , @fast )

    Returns the length of a list.

    ▶ Method

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

  Rust-Sync Quick-Start

          if let Ok(res) = r.llen("bikes:repairs").await {
              let res: usize = res;
              println!("{res}"); // >>> 0
          }
  

  ▼ Commands: LLEN

  • LLEN ( @read , @list , @fast )

    Returns the length of a list.

    ▶ Method

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

  Rust-Async Quick-Start

• Atomically pop an element from one list and push to another:

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

  Show full output

  Copied!

  Copied!

  Atomic transfer: Use LMOVE to move elements between lists in a single operation when you need to transfer items without race conditions

  > LPUSH bikes:repairs bike:1
  (integer) 1
  > LPUSH bikes:repairs bike:2
  (integer) 2
  > LMOVE bikes:repairs bikes:finished LEFT LEFT
  "bike:2"
  > LRANGE bikes:repairs 0 -1
  1) "bike:1"
  > LRANGE bikes:finished 0 -1
  1) "bike:2"

  ▼ Commands: LPUSH, LMOVE, LRANGE

  • LPUSH ( @write , @list , @fast )

    Prepends one or more elements to a list. Creates the key if it doesn't exist.
  • LMOVE ( @write , @list , @slow )

    Returns an element after popping it from one list and pushing it to another. Deletes the list if the last element was moved.
  • LRANGE ( @read , @list , @slow )

    Returns a range of elements from a list.

  Redis CLI guide

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

  res10 = r.lpush("bikes:repairs", "bike:1")
  print(res10)  # >>> 1
  
  res11 = r.lpush("bikes:repairs", "bike:2")
  print(res11)  # >>> 2
  
  res12 = r.lmove("bikes:repairs", "bikes:finished", "LEFT", "LEFT")
  print(res12)  # >>> 'bike:2'
  
  res13 = r.lrange("bikes:repairs", 0, -1)
  print(res13)  # >>> ['bike:1']
  
  res14 = r.lrange("bikes:finished", 0, -1)
  print(res14)  # >>> ['bike:2']
  

  ▼ Commands: LPUSH, LMOVE, LRANGE

  • LPUSH ( @write , @list , @fast )

    Prepends one or more elements to a list. Creates the key if it doesn't exist.

    ▶ Method

    • lpush(
      • name: KeyT,
      • *values: FieldT
      ) → Union[Awaitable[int], int]
  • LMOVE ( @write , @list , @slow )

    Returns an element after popping it from one list and pushing it to another. Deletes the list if the last element was moved.

    ▶ Method

    • lmove(
      • first_list: str,
      • second_list: str,
      • src: str = "LEFT",
      • dest: str = "RIGHT"
      ) → ResponseT
  • LRANGE ( @read , @list , @slow )

    Returns a range of elements from a list.

    ▶ Method

    • lrange(
      • name: KeyT,
      • start: int,
      • end: int
      ) → Union[Awaitable[list], list]

  Python Quick-Start

  const res10 = await client.lPush('bikes:repairs', 'bike:1');
  console.log(res10);  // 1
  
  const res11 = await client.lPush('bikes:repairs', 'bike:2');
  console.log(res11);  // 2
  
  const res12 = await client.lMove('bikes:repairs', 'bikes:finished', 'LEFT', 'LEFT');
  console.log(res12);  // 'bike:2'
  
  const res13 = await client.lRange('bikes:repairs', 0, -1);
  console.log(res13);  // ['bike:1']
  
  const res14 = await client.lRange('bikes:finished', 0, -1);
  console.log(res14);  // ['bike:2']
  

  ▼ Commands: LPUSH, LMOVE, LRANGE

  • LPUSH ( @write , @list , @fast )

    Prepends one or more elements to a list. Creates the key if it doesn't exist.

    ▶ Method

    • LPUSH(
      • key: RedisArgument,
      • elements: RedisVariadicArgument
      ) → Any
  • LMOVE ( @write , @list , @slow )

    Returns an element after popping it from one list and pushing it to another. Deletes the list if the last element was moved.
  • LRANGE ( @read , @list , @slow )

    Returns a range of elements from a list.

    ▶ Method

    • LRANGE(
      • key: RedisArgument,
      • start: number,
      • stop: number
      ) → Any

  Node.js Quick-Start

          long res10 = jedis.lpush("bikes:repairs", "bike:1");
          System.out.println(res10);  // >>> 1
  
          long res11 = jedis.lpush("bikes:repairs", "bike:2");
          System.out.println(res11);  // >>> 2
  
          String res12 = jedis.lmove("bikes:repairs", "bikes:finished", ListDirection.LEFT, ListDirection.LEFT);
          System.out.println(res12);  // >>> bike:2
  
          List<String> res13 = jedis.lrange("bikes:repairs", 0, -1);
          System.out.println(res13);  // >>> [bike:1]
  
          List<String> res14 = jedis.lrange("bikes:finished", 0, -1);
          System.out.println(res14);  // >>> [bike:2]
  

  ▼ Commands: LPUSH, LMOVE, LRANGE

  • LPUSH ( @write , @list , @fast )

    Prepends one or more elements to a list. Creates the key if it doesn't exist.

    ▶ Methods

    • lpush(
      • key: byte[],
      • strings: byte[]... // data to push
      ) → long // The number of elements inside the list after the push operation
    • lpush(
      • key: String,
      • strings: String... // data to push
      ) → long // The number of elements inside the list after the push operation
    • lpush(
      • key: String,
      • strings: String... // data to push
      ) → long // The number of elements inside the list after the push operation
  • LMOVE ( @write , @list , @slow )

    Returns an element after popping it from one list and pushing it to another. Deletes the list if the last element was moved.

    ▶ Methods

    • lmove(
      • srcKey: String,
      • dstKey: String,
      • to: ListDirection from final ListDirection // can be LEFT or RIGHT
      ) → String // The element being popped and pushed
    • lmove(
      • srcKey: String,
      • dstKey: String,
      • from: ListDirection, // can be LEFT or RIGHT
      • to: ListDirection // can be LEFT or RIGHT
      ) → String // The element being popped and pushed
  • LRANGE ( @read , @list , @slow )

    Returns a range of elements from a list.

    ▶ Methods

    • lrange(
      • key: String,
      • start: long,
      • stop: long
      ) → List<String> // A list of elements in the specified range
    • lrange(
      • key: String,
      • start: long,
      • stop: long
      ) → List<String> // A list of elements in the specified range

  Java-Sync Quick-Start

              CompletableFuture<Void> lmovelrange = asyncCommands.lpush("bikes:repairs", "bike:1").thenCompose(res7 -> {
                  System.out.println(res7); // >>> 1
  
                  return asyncCommands.lpush("bikes:repairs", "bike:2");
              }).thenCompose(res8 -> {
                  System.out.println(res8); // >>> 2
  
                  return asyncCommands.lmove("bikes:repairs", "bikes:finished", LMoveArgs.Builder.leftLeft());
              }).thenCompose(res9 -> {
                  System.out.println(res9); // >>> bike:2
  
                  return asyncCommands.lrange("bikes:repairs", 0, -1);
              }).thenCompose(res10 -> {
                  System.out.println(res10); // >>> [bike:1]
  
                  return asyncCommands.lrange("bikes:finished", 0, -1);
              })
                      .thenAccept(System.out::println) // >>> [bike:2]
                      .toCompletableFuture();
  

  ▼ Commands: LPUSH, LMOVE, LRANGE

  • LPUSH ( @write , @list , @fast )

    Prepends one or more elements to a list. Creates the key if it doesn't exist.

    ▶ Method

    • lpush(
      • key: K, // the key.
      • values: V... // the value.
      ) → RedisFuture<Long> // Long integer-reply the length of the list after the push operations.
  • LMOVE ( @write , @list , @slow )

    Returns an element after popping it from one list and pushing it to another. Deletes the list if the last element was moved.

    ▶ Method

    • lmove(
      • source: K, // the source key.
      • destination: K, // the destination type: key.
      • args: LMoveArgs // command arguments to configure source and destination directions.
      ) → RedisFuture<V> // V bulk-string-reply the element being popped and pushed. @since 6.1
  • LRANGE ( @read , @list , @slow )

    Returns a range of elements from a list.

    ▶ Methods

    • lrange(
      • key: K, // the key.
      • start: long, // the start type: long.
      • stop: long // the stop type: long.
      ) → RedisFuture<List<V>> // Long count of elements in the specified range.
    • lrange(
      • channel: ValueStreamingChannel<V>, // the channel.
      • key: K, // the key.
      • start: long, // the start type: long.
      • stop: long // the stop type: long.
      ) → RedisFuture<Long> // Long count of elements in the specified range.

  Java-Async Quick-Start

  	res10, err := rdb.LPush(ctx, "bikes:repairs", "bike:1").Result()
  
  	if err != nil {
  		panic(err)
  	}
  
  	fmt.Println(res10) // >>> 1
  
  	res11, err := rdb.LPush(ctx, "bikes:repairs", "bike:2").Result()
  
  	if err != nil {
  		panic(err)
  	}
  
  	fmt.Println(res11) // >>> 2
  
  	res12, err := rdb.LMove(ctx, "bikes:repairs", "bikes:finished", "LEFT", "LEFT").Result()
  
  	if err != nil {
  		panic(err)
  	}
  
  	fmt.Println(res12) // >>> bike:2
  
  	res13, err := rdb.LRange(ctx, "bikes:repairs", 0, -1).Result()
  
  	if err != nil {
  		panic(err)
  	}
  
  	fmt.Println(res13) // >>> [bike:1]
  
  	res14, err := rdb.LRange(ctx, "bikes:finished", 0, -1).Result()
  
  	if err != nil {
  		panic(err)
  	}
  
  	fmt.Println(res14) // >>> [bike:2]
  

  ▼ Commands: LPUSH, LMOVE, LRANGE

  • LPUSH ( @write , @list , @fast )

    Prepends one or more elements to a list. Creates the key if it doesn't exist.

    ▶ Method

    • LPush(
      • ctx: context.Context,
      • key: string,
      • values: ...interface{}
      ) → *IntCmd
  • LMOVE ( @write , @list , @slow )

    Returns an element after popping it from one list and pushing it to another. Deletes the list if the last element was moved.

    ▶ Method

    • LMove(
      • ctx: context.Context,
      • source: Any,
      • destination: Any,
      • srcpos: Any,
      • destpos: string
      ) → *StringCmd
  • LRANGE ( @read , @list , @slow )

    Returns a range of elements from a list.

    ▶ Method

    • LRange(
      • ctx: context.Context,
      • key: string,
      • start: Any,
      • stop: int64
      ) → *StringSliceCmd

  Go Quick-Start

          long res10 = db.ListLeftPush("{bikes}:repairs", "bike:1");
          Console.WriteLine(res10);   // >>> 1
  
          long res11 = db.ListLeftPush("{bikes}:repairs", "bike:2");
          Console.WriteLine(res11);   // >>> 2
  
          RedisValue res12 = db.ListMove("{bikes}:repairs", "{bikes}:finished", ListSide.Left, ListSide.Left);
          Console.Write(res12);   // >>> "bike:2"
  
          RedisValue[] res13 = db.ListRange("{bikes}:repairs", 0, -1);
          Console.WriteLine(string.Join(", ", res13));    // >>> "bike:1"
  
          RedisValue[] res14 = db.ListRange("{bikes}:finished", 0, -1);
          Console.WriteLine(string.Join(", ", res14));    // >>> "bike:2"
  

  ▼ Commands: LPUSH, LMOVE, LRANGE

  • LPUSH ( @write , @list , @fast )

    Prepends one or more elements to a list. Creates the key if it doesn't exist.

    ▶ Methods

    • ListLeftPush(
      • key: RedisKey, // The key of the list.
      • value: RedisValue,
      • when: When,
      • flags: CommandFlags // The flags to use for this operation.
      ) → long // The length of the list after the push operations.
    • ListLeftPush(
      • key: RedisKey, // The key of the list.
      • values: RedisValue[], // The values to add to the head of the list.
      • when: When,
      • flags: CommandFlags // The flags to use for this operation.
      ) → long // The length of the list after the push operations.
    • ListLeftPush(
      • key: RedisKey, // The key of the list.
      • values: RedisValue[], // The values to add to the head of the list.
      • flags: CommandFlags // The flags to use for this operation.
      ) → long // The length of the list after the push operations.
    • ListLeftPush(
      • key: RedisKey, // The key of the list.
      • value: RedisValue,
      • when: When,
      • flags: CommandFlags // The flags to use for this operation.
      ) → long // The length of the list after the push operations.
    • ListLeftPush(
      • key: RedisKey, // The key of the list.
      • values: RedisValue[], // The values to add to the head of the list.
      • when: When,
      • flags: CommandFlags // The flags to use for this operation.
      ) → long // The length of the list after the push operations.
  • LMOVE ( @write , @list , @slow )

    Returns an element after popping it from one list and pushing it to another. Deletes the list if the last element was moved.

    ▶ Methods

    • ListMove(
      • sourceKey: RedisKey, // The key of the list to remove from.
      • destinationKey: RedisKey, // The key of the list to move to.
      • sourceSide: ListSide, // What side of the sourceKey list to remove from.
      • destinationSide: ListSide, // What side of the destinationKey list to move to.
      • flags: CommandFlags // The flags to use for this operation.
      ) → RedisValue // The element being popped and pushed or Null if there is no element to move.
    • ListMove(
      • sourceKey: RedisKey, // The key of the list to remove from.
      • destinationKey: RedisKey, // The key of the list to move to.
      • sourceSide: ListSide, // What side of the sourceKey list to remove from.
      • destinationSide: ListSide, // What side of the destinationKey list to move to.
      • flags: CommandFlags // The flags to use for this operation.
      ) → RedisValue // The element being popped and pushed or Null if there is no element to move.
  • LRANGE ( @read , @list , @slow )

    Returns a range of elements from a list.

    ▶ Methods

    • ListRange(
      • key: RedisKey, // The key of the list.
      • start: long, // The start index of the list.
      • stop: long, // The stop index of the list.
      • flags: CommandFlags // The flags to use for this operation.
      ) → RedisValue[] // List of elements in the specified range.
    • ListRange(
      • key: RedisKey, // The key of the list.
      • start: long, // The start index of the list.
      • stop: long, // The stop index of the list.
      • flags: CommandFlags // The flags to use for this operation.
      ) → RedisValue[] // List of elements in the specified range.

  C#-Sync (NRedisStack) Quick-Start

          long res10 = db.ListLeftPush("{bikes}:repairs", "bike:1");
          Console.WriteLine(res10);   // >>> 1
  
          long res11 = db.ListLeftPush("{bikes}:repairs", "bike:2");
          Console.WriteLine(res11);   // >>> 2
  
          RedisValue res12 = db.ListMove("{bikes}:repairs", "{bikes}:finished", ListSide.Left, ListSide.Left);
          Console.Write(res12);   // >>> "bike:2"
  
          RedisValue[] res13 = db.ListRange("{bikes}:repairs", 0, -1);
          Console.WriteLine(string.Join(", ", res13));    // >>> "bike:1"
  
          RedisValue[] res14 = db.ListRange("{bikes}:finished", 0, -1);
          Console.WriteLine(string.Join(", ", res14));    // >>> "bike:2"
  

  ▼ Commands: LPUSH, LMOVE, LRANGE

  • LPUSH ( @write , @list , @fast )

    Prepends one or more elements to a list. Creates the key if it doesn't exist.

    ▶ Methods

    • ListLeftPush(
      • key: RedisKey, // The key of the list.
      • value: RedisValue,
      • when: When,
      • flags: CommandFlags // The flags to use for this operation.
      ) → long // The length of the list after the push operations.
    • ListLeftPush(
      • key: RedisKey, // The key of the list.
      • values: RedisValue[], // The values to add to the head of the list.
      • when: When,
      • flags: CommandFlags // The flags to use for this operation.
      ) → long // The length of the list after the push operations.
    • ListLeftPush(
      • key: RedisKey, // The key of the list.
      • values: RedisValue[], // The values to add to the head of the list.
      • flags: CommandFlags // The flags to use for this operation.
      ) → long // The length of the list after the push operations.
    • ListLeftPush(
      • key: RedisKey, // The key of the list.
      • value: RedisValue,
      • when: When,
      • flags: CommandFlags // The flags to use for this operation.
      ) → long // The length of the list after the push operations.
    • ListLeftPush(
      • key: RedisKey, // The key of the list.
      • values: RedisValue[], // The values to add to the head of the list.
      • when: When,
      • flags: CommandFlags // The flags to use for this operation.
      ) → long // The length of the list after the push operations.
  • LMOVE ( @write , @list , @slow )

    Returns an element after popping it from one list and pushing it to another. Deletes the list if the last element was moved.

    ▶ Methods

    • ListMove(
      • sourceKey: RedisKey, // The key of the list to remove from.
      • destinationKey: RedisKey, // The key of the list to move to.
      • sourceSide: ListSide, // What side of the sourceKey list to remove from.
      • destinationSide: ListSide, // What side of the destinationKey list to move to.
      • flags: CommandFlags // The flags to use for this operation.
      ) → RedisValue // The element being popped and pushed or Null if there is no element to move.
    • ListMove(
      • sourceKey: RedisKey, // The key of the list to remove from.
      • destinationKey: RedisKey, // The key of the list to move to.
      • sourceSide: ListSide, // What side of the sourceKey list to remove from.
      • destinationSide: ListSide, // What side of the destinationKey list to move to.
      • flags: CommandFlags // The flags to use for this operation.
      ) → RedisValue // The element being popped and pushed or Null if there is no element to move.
  • LRANGE ( @read , @list , @slow )

    Returns a range of elements from a list.

    ▶ Methods

    • ListRange(
      • key: RedisKey, // The key of the list.
      • start: long, // The start index of the list.
      • stop: long, // The stop index of the list.
      • flags: CommandFlags // The flags to use for this operation.
      ) → RedisValue[] // List of elements in the specified range.
    • ListRange(
      • key: RedisKey, // The key of the list.
      • start: long, // The start index of the list.
      • stop: long, // The stop index of the list.
      • flags: CommandFlags // The flags to use for this operation.
      ) → RedisValue[] // List of elements in the specified range.

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

          $res10 = $r->lpush('bikes:repairs', 'bike:1');
          echo $res10 . PHP_EOL;
          // >>> 1
  
          $res11 = $r->lpush('bikes:repairs', 'bike:2');
          echo $res11 . PHP_EOL;
          // >>> 2
  
          $res12 = $r->lmove('bikes:repairs', 'bikes:finished', 'LEFT', 'LEFT');
          echo $res12 . PHP_EOL;
          // >>> 'bike:2'
  
          $res13 = $r->lrange('bikes:repairs', 0, -1);
          echo json_encode($res13) . PHP_EOL;
          // >>> ['bike:1']
  
          $res14 = $r->lrange('bikes:finished', 0, -1);
          echo json_encode($res14) . PHP_EOL;
          // >>> ['bike:2']
  

  ▼ Commands: LPUSH, LMOVE, LRANGE

  • LPUSH ( @write , @list , @fast )

    Prepends one or more elements to a list. Creates the key if it doesn't exist.

    ▶ Method

    • lpush(
      • $key: string,
      • $values: array
      ) → int
  • LMOVE ( @write , @list , @slow )

    Returns an element after popping it from one list and pushing it to another. Deletes the list if the last element was moved.

    ▶ Method

    • lmove(
      • $source: string,
      • $destination: string,
      • $where: string,
      • $to: string
      ) → string
  • LRANGE ( @read , @list , @slow )

    Returns a range of elements from a list.

    ▶ Method

    • lrange(
      • $key: string,
      • $start: int,
      • $stop: int
      ) → string[]

  PHP Quick-Start

  res10 = r.lpush('bikes:repairs', 'bike:1')
  puts res10 # 1
  
  res11 = r.lpush('bikes:repairs', 'bike:2')
  puts res11 # 2
  
  res12 = r.lmove('bikes:repairs', 'bikes:finished', 'LEFT', 'LEFT')
  puts res12 # bike:2
  
  res13 = r.lrange('bikes:repairs', 0, -1)
  puts res13.inspect # ["bike:1"]
  
  res14 = r.lrange('bikes:finished', 0, -1)
  puts res14.inspect # ["bike:2"]
  

  ▼ Commands: LPUSH, LMOVE, LRANGE

  • LPUSH ( @write , @list , @fast )

    Prepends one or more elements to a list. Creates the key if it doesn't exist.

    ▶ Method

    • lpush(
      • key: String,
      • value: String, Array<String> // string value, or array of string values to push
      ) → Integer // the length of the list after the push operation
  • LMOVE ( @write , @list , @slow )

    Returns an element after popping it from one list and pushing it to another. Deletes the list if the last element was moved.

    ▶ Method

    • lmove(
      • source: String, // source key
      • destination: String, // destination key
      • where_source: String, Symbol, // LEFT or RIGHT
      • where_destination: String, Symbol // LEFT or RIGHT
      ) → nil, String // the element, or nil when the source key does not exist
  • LRANGE ( @read , @list , @slow )

    Returns a range of elements from a list.

    ▶ Method

    • lrange(
      • key: String,
      • start: Integer, // start index
      • stop: Integer // stop index
      ) → Array<String>

  Ruby Quick-Start

          if let Ok(res) = r.lpush("bikes:repairs", "bike:1") {
              let res: usize = res;
              println!("{res}"); // >>> 1
          }
  
          if let Ok(res) = r.lpush("bikes:repairs", "bike:2") {
              let res: usize = res;
              println!("{res}"); // >>> 2
          }
  
          if let Ok(res) = r.lmove(
              "bikes:repairs",
              "bikes:finished",
              Direction::Left,
              Direction::Left,
          ) {
              let res: String = res;
              println!("{res}"); // >>> bike:2
          }
  
          if let Ok(res) = r.lrange("bikes:repairs", 0, -1) {
              let res: Vec<String> = res;
              println!("{res:?}"); // >>> ["bike:1"]
          }
  
          if let Ok(res) = r.lrange("bikes:finished", 0, -1) {
              let res: Vec<String> = res;
              println!("{res:?}"); // >>> ["bike:2"]
          }
  

  ▼ Commands: LPUSH, LMOVE, LRANGE

  • LPUSH ( @write , @list , @fast )

    Prepends one or more elements to a list. Creates the key if it doesn't exist.

    ▶ Method

    • lpush(
      • key: K,
      • value: V
      ) → (usize)
  • LMOVE ( @write , @list , @slow )

    Returns an element after popping it from one list and pushing it to another. Deletes the list if the last element was moved.

    ▶ Method

    • lmove(
      • srckey: S,
      • dstkey: D,
      • src_dir: Direction,
      • dst_dir: Direction
      ) → (String)
  • LRANGE ( @read , @list , @slow )

    Returns a range of elements from a list.

    ▶ Method

    • lrange(
      • key: K,
      • start: isize,
      • stop: isize
      ) → (Vec<String>)

  Rust-Sync Quick-Start

          if let Ok(res) = r.lpush("bikes:repairs", "bike:1").await {
              let res: usize = res;
              println!("{res}"); // >>> 1
          }
  
          if let Ok(res) = r.lpush("bikes:repairs", "bike:2").await {
              let res: usize = res;
              println!("{res}"); // >>> 2
          }
  
          if let Ok(res) = r
              .lmove(
                  "bikes:repairs",
                  "bikes:finished",
                  Direction::Left,
                  Direction::Left,
              )
              .await
          {
              let res: String = res;
              println!("{res}"); // >>> bike:2
          }
  
          if let Ok(res) = r.lrange("bikes:repairs", 0, -1).await {
              let res: Vec<String> = res;
              println!("{res:?}"); // >>> ["bike:1"]
          }
  
          if let Ok(res) = r.lrange("bikes:finished", 0, -1).await {
              let res: Vec<String> = res;
              println!("{res:?}"); // >>> ["bike:2"]
          }
  

  ▼ Commands: LPUSH, LMOVE, LRANGE

  • LPUSH ( @write , @list , @fast )

    Prepends one or more elements to a list. Creates the key if it doesn't exist.

    ▶ Method

    • lpush(
      • key: K,
      • value: V
      ) → (usize)
  • LMOVE ( @write , @list , @slow )

    Returns an element after popping it from one list and pushing it to another. Deletes the list if the last element was moved.

    ▶ Method

    • lmove(
      • srckey: S,
      • dstkey: D,
      • src_dir: Direction,
      • dst_dir: Direction
      ) → (String)
  • LRANGE ( @read , @list , @slow )

    Returns a range of elements from a list.

    ▶ Method

    • lrange(
      • key: K,
      • start: isize,
      • stop: isize
      ) → (Vec<String>)

  Rust-Async Quick-Start

• To limit the length of a list you can call LTRIM:

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

  Show full output

  Copied!

  Copied!

  Capped lists: Use LTRIM to keep only a specific range of elements when you need to maintain a fixed-size list

  > DEL bikes:repairs
  (integer) 1
  > RPUSH bikes:repairs bike:1 bike:2 bike:3 bike:4 bike:5
  (integer) 5
  > LTRIM bikes:repairs 0 2
  OK
  > LRANGE bikes:repairs 0 -1
  1) "bike:1"
  2) "bike:2"
  3) "bike:3"

  ▼ Commands: DEL, RPUSH, LTRIM, LRANGE

  • DEL ( @keyspace , @write , @slow )

    Deletes one or more keys.
  • RPUSH ( @write , @list , @fast )

    Appends one or more elements to a list. Creates the key if it doesn't exist.
  • LTRIM ( @write , @list , @slow )

    Removes elements from both ends a list. Deletes the list if all elements were trimmed.
  • LRANGE ( @read , @list , @slow )

    Returns a range of elements from a list.

  Redis CLI guide

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

  r.delete("bikes:repairs")
  
  res48 = r.lpush("bikes:repairs", "bike:1", "bike:2", "bike:3", "bike:4", "bike:5")
  print(res48)  # >>> 5
  
  res49 = r.ltrim("bikes:repairs", 0, 2)
  print(res49)  # >>> True
  
  res50 = r.lrange("bikes:repairs", 0, -1)
  print(res50)  # >>> ['bike:5', 'bike:4', 'bike:3']
  

  ▼ Commands: DEL, RPUSH, LTRIM, LRANGE

  • DEL ( @keyspace , @write , @slow )

    Deletes one or more keys.

    ▶ Method

    • delete(
      • names: KeyT
      ) → int
  • RPUSH ( @write , @list , @fast )

    Appends one or more elements to a list. Creates the key if it doesn't exist.

    ▶ Method

    • rpush(
      • name: KeyT,
      • *values: FieldT
      ) → Union[Awaitable[int], int]
  • LTRIM ( @write , @list , @slow )

    Removes elements from both ends a list. Deletes the list if all elements were trimmed.

    ▶ Method

    • ltrim(
      • name: KeyT,
      • start: int,
      • end: int
      ) → Union[Awaitable[str], str]
  • LRANGE ( @read , @list , @slow )

    Returns a range of elements from a list.

    ▶ Method

    • lrange(
      • name: KeyT,
      • start: int,
      • end: int
      ) → Union[Awaitable[list], list]

  Python Quick-Start

  await client.del('bikes:repairs');
  
  const res48 = await client.lPush(
    'bikes:repairs', ['bike:1', 'bike:2', 'bike:3', 'bike:4', 'bike:5']
  );
  console.log(res48);  // 5
  
  const res49 = await client.lTrim('bikes:repairs', 0, 2);
  console.log(res49);  // 'OK'
  
  const res50 = await client.lRange('bikes:repairs', 0, -1);
  console.log(res50);  // ['bike:5', 'bike:4', 'bike:3']
  

  ▼ Commands: DEL, RPUSH, LTRIM, LRANGE

  • DEL ( @keyspace , @write , @slow )

    Deletes one or more keys.

    ▶ Method

    • DEL(
      • keys: RedisVariadicArgument
      ) → Any
  • RPUSH ( @write , @list , @fast )

    Appends one or more elements to a list. Creates the key if it doesn't exist.

    ▶ Method

    • RPUSH(
      • key: RedisArgument,
      • element: RedisVariadicArgument
      ) → Any
  • LTRIM ( @write , @list , @slow )

    Removes elements from both ends a list. Deletes the list if all elements were trimmed.
  • LRANGE ( @read , @list , @slow )

    Returns a range of elements from a list.

    ▶ Method

    • LRANGE(
      • key: RedisArgument,
      • start: number,
      • stop: number
      ) → Any

  Node.js Quick-Start

          jedis.del("bikes:repairs");
  
          long res48 = jedis.lpush("bikes:repairs", "bike:1", "bike:2", "bike:3", "bike:4", "bike:5");
          System.out.println(res48);  // >>> 5
  
          String res49 = jedis.ltrim("bikes:repairs", 0, 2);
          System.out.println(res49);  // >>> OK
  
          List<String> res50 = jedis.lrange("bikes:repairs", 0, -1);
          System.out.println(res50);  // >>> [bike:5, bike:4, bike:3]
  

  ▼ Commands: DEL, RPUSH, LTRIM, LRANGE

  • DEL ( @keyspace , @write , @slow )

    Deletes one or more keys.

    ▶ Methods

    • del(
      • keys: byte[]...
      ) → long // An integer greater than 0 if one or more keys were removed, 0 if none of the specified keys existed
    • del(
      • key: byte[]
      ) → long // An integer greater than 0 if one or more keys were removed, 0 if none of the specified keys existed
    • del(
      • keys: String...
      ) → long // An integer greater than 0 if one or more keys were removed, 0 if none of the specified keys existed
    • del(
      • key: String
      ) → long // An integer greater than 0 if one or more keys were removed, 0 if none of the specified keys existed
  • RPUSH ( @write , @list , @fast )

    Appends one or more elements to a list. Creates the key if it doesn't exist.

    ▶ Methods

    • rpush(
      • key: byte[],
      • strings: byte[]... // data to push
      ) → long // The number of elements inside the list after the push operation
    • rpush(
      • key: String,
      • strings: String... // data to push
      ) → long // The number of elements inside the list after the push operation
    • rpush(
      • key: String,
      • strings: String... // data to push
      ) → long // The number of elements inside the list after the push operation
  • LTRIM ( @write , @list , @slow )

    Removes elements from both ends a list. Deletes the list if all elements were trimmed.

    ▶ Methods

    • ltrim(
      • key: byte[],
      • start: long,
      • stop: long
      ) → String // OK
    • ltrim(
      • key: String,
      • start: long,
      • stop: long
      ) → String // OK
    • ltrim(
      • key: String,
      • start: long,
      • stop: long
      ) → String // OK
  • LRANGE ( @read , @list , @slow )

    Returns a range of elements from a list.

    ▶ Methods

    • lrange(
      • key: String,
      • start: long,
      • stop: long
      ) → List<String> // A list of elements in the specified range
    • lrange(
      • key: String,
      • start: long,
      • stop: long
      ) → List<String> // A list of elements in the specified range

  Java-Sync Quick-Start

              CompletableFuture<Void> ltrim1 = asyncCommands
                      .lpush("bikes:repairs", "bike:1", "bike:2", "bike:3", "bike:4", "bike:5").thenCompose(res37 -> {
                          System.out.println(res37); // >>> 5
  
                          return asyncCommands.ltrim("bikes:repairs", 0, 2);
                      }).thenCompose(res38 -> {
                          System.out.println(res38); // >>> OK
  
                          return asyncCommands.lrange("bikes:repairs", 0, -1);
                      })
                      .thenAccept(System.out::println) // >>> [bike:5, bike:4, bike:3]
                      .toCompletableFuture();
  

  ▼ Commands: DEL, RPUSH, LTRIM, LRANGE

  • DEL ( @keyspace , @write , @slow )

    Deletes one or more keys.

    ▶ Method

    • del(
      • keys: K... // the keys.
      ) → RedisFuture<Long> // Long integer-reply The number of keys that were removed.
  • RPUSH ( @write , @list , @fast )

    Appends one or more elements to a list. Creates the key if it doesn't exist.

    ▶ Method

    • rpush(
      • key: K, // the key.
      • values: V... // the value.
      ) → RedisFuture<Long> // Long integer-reply the length of the list after the push operation.
  • LTRIM ( @write , @list , @slow )

    Removes elements from both ends a list. Deletes the list if all elements were trimmed.

    ▶ Method

    • ltrim(
      • key: K, // the key.
      • start: long, // the start type: long.
      • stop: long // the stop type: long.
      ) → RedisFuture<String> // String simple-string-reply.
  • LRANGE ( @read , @list , @slow )

    Returns a range of elements from a list.

    ▶ Methods

    • lrange(
      • key: K, // the key.
      • start: long, // the start type: long.
      • stop: long // the stop type: long.
      ) → RedisFuture<List<V>> // Long count of elements in the specified range.
    • lrange(
      • channel: ValueStreamingChannel<V>, // the channel.
      • key: K, // the key.
      • start: long, // the start type: long.
      • stop: long // the stop type: long.
      ) → RedisFuture<Long> // Long count of elements in the specified range.

  Java-Async Quick-Start

  	rdb.Del(ctx, "bikes:repairs")
  
  	res51, err := rdb.LPush(ctx, "bikes:repairs", "bike:1", "bike:2", "bike:3", "bike:4", "bike:5").Result()
  
  	if err != nil {
  		panic(err)
  	}
  
  	fmt.Println(res51) // >>> 5
  
  	res52, err := rdb.LTrim(ctx, "bikes:repairs", 0, 2).Result()
  
  	if err != nil {
  		panic(err)
  	}
  
  	fmt.Println(res52) // >>> OK
  
  	res53, err := rdb.LRange(ctx, "bikes:repairs", 0, -1).Result()
  
  	if err != nil {
  		panic(err)
  	}
  
  	fmt.Println(res53) // >>> [bike:5 bike:4 bike:3]
  

  ▼ Commands: DEL, RPUSH, LTRIM, LRANGE

  • DEL ( @keyspace , @write , @slow )

    Deletes one or more keys.

    ▶ Method

    • Del(
      • ctx: context.Context,
      • keys: ...string
      ) → *IntCmd
  • RPUSH ( @write , @list , @fast )

    Appends one or more elements to a list. Creates the key if it doesn't exist.

    ▶ Method

    • RPush(
      • ctx: context.Context,
      • key: string,
      • values: ...interface{}
      ) → *IntCmd
  • LTRIM ( @write , @list , @slow )

    Removes elements from both ends a list. Deletes the list if all elements were trimmed.

    ▶ Method

    • LTrim(
      • ctx: context.Context,
      • key: string,
      • start: Any,
      • stop: int64
      ) → *StatusCmd
  • LRANGE ( @read , @list , @slow )

    Returns a range of elements from a list.

    ▶ Method

    • LRange(
      • ctx: context.Context,
      • key: string,
      • start: Any,
      • stop: int64
      ) → *StringSliceCmd

  Go Quick-Start

          long res49 = db.ListLeftPush("bikes:repairs", ["bike:1", "bike:2", "bike:3", "bike:4", "bike:5"]);
          Console.WriteLine(res49);   // >>> 5
  
          db.ListTrim("bikes:repairs", 0, 2);
          RedisValue[] res50 = db.ListRange("bikes:repairs", 0, -1);
          Console.WriteLine(string.Join(", ", res50));    // >>> "bike:5, bike:4, bike:3"
  

  ▼ Commands: DEL, RPUSH, LTRIM, LRANGE

  • DEL ( @keyspace , @write , @slow )

    Deletes one or more keys.

    ▶ Methods

    • KeyDelete(
      • key: RedisKey,
      • flags: CommandFlags // The flags to use for this operation.
      ) → bool // The number of keys that were removed.
    • KeyDelete(
      • keys: RedisKey[], // The keys to delete.
      • flags: CommandFlags // The flags to use for this operation.
      ) → long // The number of keys that were removed.
  • RPUSH ( @write , @list , @fast )

    Appends one or more elements to a list. Creates the key if it doesn't exist.

    ▶ Methods

    • ListRightPush(
      • key: RedisKey, // The key of the list.
      • value: RedisValue,
      • when: When,
      • flags: CommandFlags // The flags to use for this operation.
      ) → long // The length of the list after the push operation.
    • ListRightPush(
      • key: RedisKey, // The key of the list.
      • values: RedisValue[], // The values to add to the tail of the list.
      • when: When,
      • flags: CommandFlags // The flags to use for this operation.
      ) → long // The length of the list after the push operation.
    • ListRightPush(
      • key: RedisKey, // The key of the list.
      • values: RedisValue[], // The values to add to the tail of the list.
      • flags: CommandFlags // The flags to use for this operation.
      ) → long // The length of the list after the push operation.
    • ListRightPush(
      • key: RedisKey, // The key of the list.
      • value: RedisValue,
      • when: When,
      • flags: CommandFlags // The flags to use for this operation.
      ) → long // The length of the list after the push operation.
    • ListRightPush(
      • key: RedisKey, // The key of the list.
      • values: RedisValue[], // The values to add to the tail of the list.
      • when: When,
      • flags: CommandFlags // The flags to use for this operation.
      ) → long // The length of the list after the push operation.
  • LTRIM ( @write , @list , @slow )

    Removes elements from both ends a list. Deletes the list if all elements were trimmed.

    ▶ Methods

    • ListTrim(
      • key: RedisKey, // The key of the list.
      • start: long, // The start index of the list to trim to.
      • stop: long, // The end index of the list to trim to.
      • flags: CommandFlags // The flags to use for this operation.
      ) → void
    • ListTrim(
      • key: RedisKey, // The key of the list.
      • start: long, // The start index of the list to trim to.
      • stop: long, // The end index of the list to trim to.
      • flags: CommandFlags // The flags to use for this operation.
      ) → void
  • LRANGE ( @read , @list , @slow )

    Returns a range of elements from a list.

    ▶ Methods

    • ListRange(
      • key: RedisKey, // The key of the list.
      • start: long, // The start index of the list.
      • stop: long, // The stop index of the list.
      • flags: CommandFlags // The flags to use for this operation.
      ) → RedisValue[] // List of elements in the specified range.
    • ListRange(
      • key: RedisKey, // The key of the list.
      • start: long, // The start index of the list.
      • stop: long, // The stop index of the list.
      • flags: CommandFlags // The flags to use for this operation.
      ) → RedisValue[] // List of elements in the specified range.

  C#-Sync (NRedisStack) Quick-Start

          db.KeyDelete("bikes:repairs");
  
          long res49 = db.ListLeftPush("bikes:repairs", ["bike:1", "bike:2", "bike:3", "bike:4", "bike:5"]);
          Console.WriteLine(res49);   // >>> 5
  
          db.ListTrim("bikes:repairs", 0, 2);
          RedisValue[] res50 = db.ListRange("bikes:repairs", 0, -1);
          Console.WriteLine(string.Join(", ", res50));    // >>> "bike:5, bike:4, bike:3"
  

  ▼ Commands: DEL, RPUSH, LTRIM, LRANGE

  • DEL ( @keyspace , @write , @slow )

    Deletes one or more keys.

    ▶ Methods

    • KeyDelete(
      • key: RedisKey,
      • flags: CommandFlags // The flags to use for this operation.
      ) → bool // The number of keys that were removed.
    • KeyDelete(
      • keys: RedisKey[], // The keys to delete.
      • flags: CommandFlags // The flags to use for this operation.
      ) → long // The number of keys that were removed.
  • RPUSH ( @write , @list , @fast )

    Appends one or more elements to a list. Creates the key if it doesn't exist.

    ▶ Methods

    • ListRightPush(
      • key: RedisKey, // The key of the list.
      • value: RedisValue,
      • when: When,
      • flags: CommandFlags // The flags to use for this operation.
      ) → long // The length of the list after the push operation.
    • ListRightPush(
      • key: RedisKey, // The key of the list.
      • values: RedisValue[], // The values to add to the tail of the list.
      • when: When,
      • flags: CommandFlags // The flags to use for this operation.
      ) → long // The length of the list after the push operation.
    • ListRightPush(
      • key: RedisKey, // The key of the list.
      • values: RedisValue[], // The values to add to the tail of the list.
      • flags: CommandFlags // The flags to use for this operation.
      ) → long // The length of the list after the push operation.
    • ListRightPush(
      • key: RedisKey, // The key of the list.
      • value: RedisValue,
      • when: When,
      • flags: CommandFlags // The flags to use for this operation.
      ) → long // The length of the list after the push operation.
    • ListRightPush(
      • key: RedisKey, // The key of the list.
      • values: RedisValue[], // The values to add to the tail of the list.
      • when: When,
      • flags: CommandFlags // The flags to use for this operation.
      ) → long // The length of the list after the push operation.
  • LTRIM ( @write , @list , @slow )

    Removes elements from both ends a list. Deletes the list if all elements were trimmed.

    ▶ Methods

    • ListTrim(
      • key: RedisKey, // The key of the list.
      • start: long, // The start index of the list to trim to.
      • stop: long, // The end index of the list to trim to.
      • flags: CommandFlags // The flags to use for this operation.
      ) → void
    • ListTrim(
      • key: RedisKey, // The key of the list.
      • start: long, // The start index of the list to trim to.
      • stop: long, // The end index of the list to trim to.
      • flags: CommandFlags // The flags to use for this operation.
      ) → void
  • LRANGE ( @read , @list , @slow )

    Returns a range of elements from a list.

    ▶ Methods

    • ListRange(
      • key: RedisKey, // The key of the list.
      • start: long, // The start index of the list.
      • stop: long, // The stop index of the list.
      • flags: CommandFlags // The flags to use for this operation.
      ) → RedisValue[] // List of elements in the specified range.
    • ListRange(
      • key: RedisKey, // The key of the list.
      • start: long, // The start index of the list.
      • stop: long, // The stop index of the list.
      • flags: CommandFlags // The flags to use for this operation.
      ) → RedisValue[] // List of elements in the specified range.

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

          $res48 = $r->lpush('bikes:repairs', 'bike:1', 'bike:2', 'bike:3', 'bike:4', 'bike:5');
          echo $res48 . PHP_EOL;
          // >>> 5
  
          $res49 = $r->ltrim('bikes:repairs', 0, 2);
          echo $res49 . PHP_EOL;
          // >>> True
  
          $res50 = $r->lrange('bikes:repairs', 0, -1);
          echo json_encode($res50) . PHP_EOL;
          // >>> ['bike:5', 'bike:4', 'bike:3']
  

  ▼ Commands: DEL, RPUSH, LTRIM, LRANGE

  • DEL ( @keyspace , @write , @slow )

    Deletes one or more keys.

    ▶ Method

    • del(
      • $keyOrKeys: string[]|string,
      • $keys: string ...
      ) → int
  • RPUSH ( @write , @list , @fast )

    Appends one or more elements to a list. Creates the key if it doesn't exist.

    ▶ Method

    • rpush(
      • $key: string,
      • $values: array
      ) → int
  • LTRIM ( @write , @list , @slow )

    Removes elements from both ends a list. Deletes the list if all elements were trimmed.

    ▶ Method

    • ltrim(
      • $key: string,
      • $start: int,
      • $stop: int
      ) → mixed
  • LRANGE ( @read , @list , @slow )

    Returns a range of elements from a list.

    ▶ Method

    • lrange(
      • $key: string,
      • $start: int,
      • $stop: int
      ) → string[]

  PHP Quick-Start

  r.del('bikes:repairs')
  
  res15 = r.rpush('bikes:repairs', ['bike:1', 'bike:2', 'bike:3', 'bike:4', 'bike:5'])
  puts res15 # 5
  
  res16 = r.ltrim('bikes:repairs', 0, 2)
  puts res16 # OK
  
  res17 = r.lrange('bikes:repairs', 0, -1)
  puts res17.inspect # ["bike:1", "bike:2", "bike:3"]
  

  ▼ Commands: DEL, RPUSH, LTRIM, LRANGE

  • DEL ( @keyspace , @write , @slow )

    Deletes one or more keys.

    ▶ Method

    • del(
      • *keys: String, Array<String>
      ) → Integer // number of keys that were deleted
  • RPUSH ( @write , @list , @fast )

    Appends one or more elements to a list. Creates the key if it doesn't exist.

    ▶ Method

    • rpush(
      • key: String,
      • value: String, Array<String> // string value, or array of string values to push
      ) → Integer // the length of the list after the push operation
  • LTRIM ( @write , @list , @slow )

    Removes elements from both ends a list. Deletes the list if all elements were trimmed.

    ▶ Method

    • ltrim(
      • key: String,
      • start: Integer, // start index
      • stop: Integer // stop index
      ) → String // OK
  • LRANGE ( @read , @list , @slow )

    Returns a range of elements from a list.

    ▶ Method

    • lrange(
      • key: String,
      • start: Integer, // start index
      • stop: Integer // stop index
      ) → Array<String>

  Ruby Quick-Start

          if let Ok(res) = r.del("bikes:repairs") {
              let res: usize = res;
              println!("{res}"); // >>> 1
          }
  
          if let Ok(res) = r.rpush("bikes:repairs", &["bike:1", "bike:2", "bike:3", "bike:4", "bike:5"]) {
              let res: usize = res;
              println!("{res}"); // >>> 5
          }
  
          if let Ok(res) = r.ltrim("bikes:repairs", 0, 2) {
              let res: () = res;
              let _ = res;
              println!("OK"); // >>> OK
          }
  
          if let Ok(res) = r.lrange("bikes:repairs", 0, -1) {
              let res: Vec<String> = res;
              println!("{res:?}"); // >>> ["bike:1", "bike:2", "bike:3"]
          }
  

  ▼ Commands: DEL, RPUSH, LTRIM, LRANGE

  • DEL ( @keyspace , @write , @slow )

    Deletes one or more keys.
  • RPUSH ( @write , @list , @fast )

    Appends one or more elements to a list. Creates the key if it doesn't exist.

    ▶ Method

    • rpush(
      • key: K,
      • value: V
      ) → (usize)
  • LTRIM ( @write , @list , @slow )

    Removes elements from both ends a list. Deletes the list if all elements were trimmed.

    ▶ Method

    • ltrim(
      • key: K,
      • start: isize,
      • stop: isize
      ) → (())
  • LRANGE ( @read , @list , @slow )

    Returns a range of elements from a list.

    ▶ Method

    • lrange(
      • key: K,
      • start: isize,
      • stop: isize
      ) → (Vec<String>)

  Rust-Sync Quick-Start

          if let Ok(res) = r.del("bikes:repairs").await {
              let res: usize = res;
              println!("{res}"); // >>> 1
          }
  
          if let Ok(res) = r
              .rpush(
                  "bikes:repairs",
                  &["bike:1", "bike:2", "bike:3", "bike:4", "bike:5"],
              )
              .await
          {
              let res: usize = res;
              println!("{res}"); // >>> 5
          }
  
          if let Ok(res) = r.ltrim("bikes:repairs", 0, 2).await {
              let res: () = res;
              let _ = res;
              println!("OK"); // >>> OK
          }
  
          if let Ok(res) = r.lrange("bikes:repairs", 0, -1).await {
              let res: Vec<String> = res;
              println!("{res:?}"); // >>> ["bike:1", "bike:2", "bike:3"]
          }
  

  ▼ Commands: DEL, RPUSH, LTRIM, LRANGE

  • DEL ( @keyspace , @write , @slow )

    Deletes one or more keys.
  • RPUSH ( @write , @list , @fast )

    Appends one or more elements to a list. Creates the key if it doesn't exist.

    ▶ Method

    • rpush(
      • key: K,
      • value: V
      ) → (usize)
  • LTRIM ( @write , @list , @slow )

    Removes elements from both ends a list. Deletes the list if all elements were trimmed.

    ▶ Method

    • ltrim(
      • key: K,
      • start: isize,
      • stop: isize
      ) → (())
  • LRANGE ( @read , @list , @slow )

    Returns a range of elements from a list.

    ▶ Method

    • lrange(
      • key: K,
      • start: isize,
      • stop: isize
      ) → (Vec<String>)

  Rust-Async Quick-Start