HGETALL

Syntax

HGETALL key

Available since:

Redis Open Source 2.0.0

Time complexity:

O(N) where N is the size of the hash.

ACL categories:

@read, @hash, @slow,

Returns all fields and values of the hash stored at key. In the returned value, every field name is followed by its value, so the length of the reply is twice the size of the hash.

Examples

Language:

redis> HSET myhash field1 "Hello"
(integer) 1
redis> HSET myhash field2 "World"
(integer) 1
redis> HGETALL myhash
1) "field1"
2) "Hello"
3) "field2"
4) "World"

Are you tired of using redis-cli? Try Redis Insight - the developer GUI for Redis.

Get Redis Insight

import redis
r = redis.Redis(host="localhost", port=6379, db=0, decode_responses=True)
hdel1 = r.hset("myhash", "field1", "foo")
print(hdel1)
# >>> 1
hdel2 = r.hget("myhash", "field1")
print(hdel2)
# >>> 1
hdel3 = r.hget("myhash", "field2")
print(hdel3)
# >>> 0
res1 = r.hset("myhash", "field1", "Hello")
print(res1)
# >>> 1
res2 = r.hget("myhash", "field1")
print(res2)
# >>> Hello
res3 = r.hset("myhash", mapping={"field2": "Hi", "field3": "World"})
print(res3)
# >>> 2
res4 = r.hget("myhash", "field2")
print(res4)
# >>> Hi
res5 = r.hget("myhash", "field3")
print(res5)
# >>> World
res6 = r.hgetall("myhash")
print(res6)
# >>> { "field1": "Hello", "field2": "Hi", "field3": "World" }
res7 = r.hset("myhash", "field1", "foo")
print(res7)
# >>> 1
res8 = r.hget("myhash", "field1")
print(res8)
# >>> foo
res9 = r.hget("myhash", "field2")
print(res9)
# >>> None
res10 = r.hset("myhash", mapping={"field1": "Hello", "field2": "World"})
res11 = r.hgetall("myhash")
print(res11) # >>> { "field1": "Hello", "field2": "World" }
res10 = r.hset("myhash", mapping={"field1": "Hello", "field2": "World"})
res11 = r.hvals("myhash")
print(res11) # >>> [ "Hello", "World" ]

Python Quick-Start

import assert from 'node:assert';
import { createClient } from 'redis';
const client = createClient();
await client.connect().catch(console.error);
const hDel1 = await client.hSet('myhash', 'field1', 'Hello')
console.log(hDel1) // 1

const hDel2 = await client.hDel('myhash', 'field1')
console.log(hDel2) // 1

const hDel3 = await client.hDel('myhash', 'field2')
console.log(hDel3) // 0

const res1 = await client.hSet('myhash', 'field1', 'Hello')
console.log(res1) // 1

const res2 = await client.hGet('myhash', 'field1')
console.log(res2) // Hello

const res3 = await client.hSet(
 'myhash',
 {
 'field2': 'Hi',
 'field3': 'World'
 }
)
console.log(res3) // 2

const res4 = await client.hGet('myhash', 'field2')
console.log(res4) // Hi

const res5 = await client.hGet('myhash', 'field3')
console.log(res5) // World

const res6 = await client.hGetAll('myhash')
console.log(res6) 
const res7 = await client.hSet('myhash', 'field1', 'foo')
console.log(res7) // 1

const res8 = await client.hGet('myhash', 'field1')
console.log(res8) // foo

const res9 = await client.hGet('myhash', 'field2')
console.log(res9) // null

const res10 = await client.hSet(
 'myhash',
 {
 'field1': 'Hello',
 'field2': 'World'
 }
)
const res11 = await client.hGetAll('myhash')
console.log(res11) // [Object: null prototype] { field1: 'Hello', field2: 'World' }

const res12 = await client.hSet(
 'myhash',
 {
 'field1': 'Hello',
 'field2': 'World'
 }
)
const res13 = await client.hVals('myhash')
console.log(res13) // [ 'Hello', 'World' ]

await client.close();

Node.js Quick-Start

importjava.util.HashMap;importjava.util.Map;importjava.util.List;importjava.util.Collections;importredis.clients.jedis.UnifiedJedis;import staticjava.util.stream.Collectors.toList;import staticorg.junit.jupiter.api.Assertions.assertEquals;import staticorg.junit.jupiter.api.Assertions.assertNull;publicclass CmdsHashExample{publicvoidrun(){UnifiedJedisjedis=newUnifiedJedis("redis://localhost:6379");Map<String,String>hDelExampleParams=newHashMap<>();hDelExampleParams.put("field1","foo");longhDelResult1=jedis.hset("myhash",hDelExampleParams);System.out.println(hDelResult1);// >>> 1longhDelResult2=jedis.hdel("myhash","field1");System.out.println(hDelResult2);// >>> 1longhDelResult3=jedis.hdel("myhash","field2");System.out.println(hDelResult3);// >>> 0Map<String,String>hGetExampleParams=newHashMap<>();hGetExampleParams.put("field1","foo");longhGetResult1=jedis.hset("myhash",hGetExampleParams);System.out.println(hGetResult1);// >>> 1StringhGetResult2=jedis.hget("myhash","field1");System.out.println(hGetResult2);// >>> fooStringhGetResult3=jedis.hget("myhash","field2");System.out.println(hGetResult3);// >>> nullMap<String,String>hGetAllExampleParams=newHashMap<>();hGetAllExampleParams.put("field1","Hello");hGetAllExampleParams.put("field2","World");longhGetAllResult1=jedis.hset("myhash",hGetAllExampleParams);System.out.println(hGetAllResult1);// >>> 2Map<String,String>hGetAllResult2=jedis.hgetAll("myhash");System.out.println(hGetAllResult2.entrySet().stream().sorted((s1,s2)->s1.getKey().compareTo(s2.getKey())).collect(toList()).toString());// >>> [field1=Hello, field2=World]Map<String,String>hSetExampleParams=newHashMap<>();hSetExampleParams.put("field1","Hello");longhSetResult1=jedis.hset("myhash",hSetExampleParams);System.out.println(hSetResult1);// >>> 1StringhSetResult2=jedis.hget("myhash","field1");System.out.println(hSetResult2);// >>> HellohSetExampleParams.clear();hSetExampleParams.put("field2","Hi");hSetExampleParams.put("field3","World");longhSetResult3=jedis.hset("myhash",hSetExampleParams);System.out.println(hSetResult3);// >>> 2StringhSetResult4=jedis.hget("myhash","field2");System.out.println(hSetResult4);// >>> HiStringhSetResult5=jedis.hget("myhash","field3");System.out.println(hSetResult5);// >>> WorldMap<String,String>hSetResult6=jedis.hgetAll("myhash");for(Stringkey:hSetResult6.keySet()){System.out.println("Key: "+key+", Value: "+hSetResult6.get(key));}// >>> Key: field3, Value: World// >>> Key: field2, Value: Hi// >>> Key: field1, Value: HelloMap<String,String>hValsExampleParams=newHashMap<>();hValsExampleParams.put("field1","Hello");hValsExampleParams.put("field2","World");longhValsResult1=jedis.hset("myhash",hValsExampleParams);System.out.println(hValsResult1);// >>> 2List<String>hValsResult2=jedis.hvals("myhash");Collections.sort(hValsResult2);System.out.println(hValsResult2);// >>> [Hello, World]jedis.close();}}

Java-Sync Quick-Start

packageio.redis.examples.async;importio.lettuce.core.*;importio.lettuce.core.api.async.RedisAsyncCommands;importio.lettuce.core.api.StatefulRedisConnection;importjava.util.*;importjava.util.concurrent.CompletableFuture;publicclass CmdsHashExample{publicvoidrun(){Map<String,String>hDelExampleParams=newHashMap<>();hDelExampleParams.put("field1","foo");CompletableFuture<Void>hDelExample=asyncCommands.hset("myhash",hDelExampleParams).thenCompose(res1->{System.out.println(res1);// >>> 1returnasyncCommands.hdel("myhash","field1");}).thenCompose(res2->{System.out.println(res2);// >>> 1returnasyncCommands.hdel("myhash","field2");}).thenAccept(res3->{System.out.println(res3);// >>> 0}).toCompletableFuture();hDelExample.join();CompletableFuture<Void>hSetExample=asyncCommands.hset("myhash","field1","Hello").thenCompose(res1->{System.out.println(res1);// >>> 1returnasyncCommands.hget("myhash","field1");}).thenCompose(res2->{System.out.println(res2);// >>> HelloMap<String,String>hSetExampleParams=newHashMap<>();hSetExampleParams.put("field2","Hi");hSetExampleParams.put("field3","World");returnasyncCommands.hset("myhash",hSetExampleParams);}).thenCompose(res3->{System.out.println(res3);// >>> 2returnasyncCommands.hget("myhash","field2");}).thenCompose(res4->{System.out.println(res4);// >>> HireturnasyncCommands.hget("myhash","field3");}).thenCompose(res5->{System.out.println(res5);// >>> WorldreturnasyncCommands.hgetall("myhash");}).thenAccept(res6->{System.out.println(res6);// >>> {field1=Hello, field2=Hi, field3=World}}).toCompletableFuture();hSetExample.join();Map<String,String>hGetExampleParams=newHashMap<>();hGetExampleParams.put("field1","foo");CompletableFuture<Void>hGetExample=asyncCommands.hset("myhash",hGetExampleParams).thenCompose(res1->{System.out.println(res1);// >>> 1returnasyncCommands.hget("myhash","field1");}).thenCompose(res2->{System.out.println(res2);// >>> fooreturnasyncCommands.hget("myhash","field2");}).thenAccept(res3->{System.out.println(res3);// >>> null}).toCompletableFuture();hGetExample.join();Map<String,String>hGetAllExampleParams=newHashMap<>();hGetAllExampleParams.put("field1","Hello");hGetAllExampleParams.put("field2","World");CompletableFuture<Void>hGetAllExample=asyncCommands.hset("myhash",hGetAllExampleParams).thenCompose(res1->{returnasyncCommands.hgetall("myhash");}).thenAccept(res2->{System.out.println(res2);// >>> {field1=Hello, field2=World}}).toCompletableFuture();hGetAllExample.join();Map<String,String>hValsExampleParams=newHashMap<>();hValsExampleParams.put("field1","Hello");hValsExampleParams.put("field2","World");CompletableFuture<Void>hValsExample=asyncCommands.hset("myhash",hValsExampleParams).thenCompose(res1->{returnasyncCommands.hvals("myhash");}).thenAccept(res2->{List<String>sortedValues=newArrayList<>(res2);Collections.sort(sortedValues);System.out.println(sortedValues);// >>> [Hello, World]}).toCompletableFuture();hValsExample.join();}finally{redisClient.shutdown();}}}

Java-Async Quick-Start

packageio.redis.examples.reactive;importio.lettuce.core.*;importio.lettuce.core.api.reactive.RedisReactiveCommands;importio.lettuce.core.api.StatefulRedisConnection;importreactor.core.publisher.Mono;importjava.util.*;publicclass CmdsHashExample{publicvoidrun(){RedisClientredisClient=RedisClient.create("redis://localhost:6379");try(StatefulRedisConnection<String,String>connection=redisClient.connect()){RedisReactiveCommands<String,String>reactiveCommands=connection.reactive();Map<String,String>hDelExampleParams=newHashMap<>();hDelExampleParams.put("field1","foo");Mono<Long>hDelExample1=reactiveCommands.hset("myhash",hDelExampleParams).doOnNext(result->{System.out.println(result);// >>> 1});hDelExample1.block();Mono<Long>hDelExample2=reactiveCommands.hdel("myhash","field1").doOnNext(result->{System.out.println(result);// >>> 1});hDelExample2.block();Mono<Long>hDelExample3=reactiveCommands.hdel("myhash","field2").doOnNext(result->{System.out.println(result);// >>> 0});hDelExample3.block();Mono<Boolean>hSetExample1=reactiveCommands.hset("myhash","field1","Hello").doOnNext(result->{System.out.println(result);// >>> True});hSetExample1.block();Mono<String>hSetExample2=reactiveCommands.hget("myhash","field1").doOnNext(result->{System.out.println(result);// >>> Hello});hSetExample2.block();Map<String,String>hSetExampleParams=newHashMap<>();hSetExampleParams.put("field2","Hi");hSetExampleParams.put("field3","World");Mono<Long>hSetExample3=reactiveCommands.hset("myhash",hSetExampleParams).doOnNext(result->{System.out.println(result);// >>> 2});hSetExample3.block();Mono<String>hSetExample4=reactiveCommands.hget("myhash","field2").doOnNext(result->{System.out.println(result);// >>> Hi});hSetExample4.block();Mono<String>hSetExample5=reactiveCommands.hget("myhash","field3").doOnNext(result->{System.out.println(result);// >>> World});hSetExample5.block();Mono<Map<String,String>>hSetExample6=reactiveCommands.hgetall("myhash").collectMap(KeyValue::getKey,KeyValue::getValue).doOnNext(result->{System.out.println(result);// >>> {field1=Hello, field2=Hi, field3=World}});hSetExample6.block();Map<String,String>hGetExampleParams=newHashMap<>();hGetExampleParams.put("field1","foo");Mono<Long>hGetExample1=reactiveCommands.hset("myhash",hGetExampleParams).doOnNext(result->{System.out.println(result);// >>> 1});hGetExample1.block();Mono<String>hGetExample2=reactiveCommands.hget("myhash","field1").doOnNext(result->{System.out.println(result);// >>> foo});hGetExample2.block();Mono<String>hGetExample3=reactiveCommands.hget("myhash","field2").doOnNext(result->{System.out.println(result);// >>> null});hGetExample3.block();Map<String,String>hGetAllExampleParams=newHashMap<>();hGetAllExampleParams.put("field1","Hello");hGetAllExampleParams.put("field2","World");Mono<Long>hGetAllExample1=reactiveCommands.hset("myhash",hGetAllExampleParams).doOnNext(result->{});hGetAllExample1.block();Mono<Map<String,String>>hGetAllExample2=reactiveCommands.hgetall("myhash").collectMap(KeyValue::getKey,KeyValue::getValue).doOnNext(result->{System.out.println(result);// >>> {field1=Hello, field2=World}});hGetAllExample2.block();Map<String,String>hValsExampleParams=newHashMap<>();hValsExampleParams.put("field1","Hello");hValsExampleParams.put("field2","World");Mono<Long>hValsExample1=reactiveCommands.hset("myhash",hValsExampleParams).doOnNext(result->{});hValsExample1.block();Mono<List<String>>hValsExample2=reactiveCommands.hvals("myhash").collectList().doOnNext(result->{List<String>sortedValues=newArrayList<>(result);Collections.sort(sortedValues);System.out.println(sortedValues);// >>> [Hello, World]});hValsExample2.block();}finally{redisClient.shutdown();}}}

Java-Reactive Quick-Start

package example_commands_test
import (
	"context"
	"fmt"
	"sort"
	"github.com/redis/go-redis/v9"
)
func ExampleClient_hset() {
	ctx := context.Background()
	rdb := redis.NewClient(&redis.Options{
		Addr: "localhost:6379",
		Password: "", // no password docs
		DB: 0, // use default DB
	})
	res1, err := rdb.HSet(ctx, "myhash", "field1", "Hello").Result()
	if err != nil {
		panic(err)
	}
	fmt.Println(res1) // >>> 1
	res2, err := rdb.HGet(ctx, "myhash", "field1").Result()
	if err != nil {
		panic(err)
	}
	fmt.Println(res2) // >>> Hello
	res3, err := rdb.HSet(ctx, "myhash",
		"field2", "Hi",
		"field3", "World",
	).Result()
	if err != nil {
		panic(err)
	}
	fmt.Println(res3) // >>> 2
	res4, err := rdb.HGet(ctx, "myhash", "field2").Result()
	if err != nil {
		panic(err)
	}
	fmt.Println(res4) // >>> Hi
	res5, err := rdb.HGet(ctx, "myhash", "field3").Result()
	if err != nil {
		panic(err)
	}
	fmt.Println(res5) // >>> World
	res6, err := rdb.HGetAll(ctx, "myhash").Result()
	if err != nil {
		panic(err)
	}
	keys := make([]string, 0, len(res6))
	for key, _ := range res6 {
		keys = append(keys, key)
	}
	sort.Strings(keys)
	for _, key := range keys {
		fmt.Printf("Key: %v, value: %v\n", key, res6[key])
	}
	// >>> Key: field1, value: Hello
	// >>> Key: field2, value: Hi
	// >>> Key: field3, value: World
}
func ExampleClient_hget() {
	ctx := context.Background()
	rdb := redis.NewClient(&redis.Options{
		Addr: "localhost:6379",
		Password: "", // no password docs
		DB: 0, // use default DB
	})
	res7, err := rdb.HSet(ctx, "myhash", "field1", "foo").Result()
	if err != nil {
		panic(err)
	}
	fmt.Println(res7) // >>> 1
	res8, err := rdb.HGet(ctx, "myhash", "field1").Result()
	if err != nil {
		panic(err)
	}
	fmt.Println(res8) // >>> foo
	res9, err := rdb.HGet(ctx, "myhash", "field2").Result()
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println(res9) // >>> <empty string>
}
func ExampleClient_hgetall() {
	ctx := context.Background()
	rdb := redis.NewClient(&redis.Options{
		Addr: "localhost:6379",
		Password: "", // no password
		DB: 0, // use default DB
	})
	hGetAllResult1, err := rdb.HSet(ctx, "myhash",
		"field1", "Hello",
		"field2", "World",
	).Result()
	if err != nil {
		panic(err)
	}
	fmt.Println(hGetAllResult1) // >>> 2
	hGetAllResult2, err := rdb.HGetAll(ctx, "myhash").Result()
	if err != nil {
		panic(err)
	}
	keys := make([]string, 0, len(hGetAllResult2))
	for key, _ := range hGetAllResult2 {
		keys = append(keys, key)
	}
	sort.Strings(keys)
	for _, key := range keys {
		fmt.Printf("Key: %v, value: %v\n", key, hGetAllResult2[key])
	}
	// >>> Key: field1, value: Hello
	// >>> Key: field2, value: World
}
func ExampleClient_hvals() {
	ctx := context.Background()
	rdb := redis.NewClient(&redis.Options{
		Addr: "localhost:6379",
		Password: "", // no password docs
		DB: 0, // use default DB
	})
	hValsResult1, err := rdb.HSet(ctx, "myhash",
		"field1", "Hello",
		"field2", "World",
	).Result()
	if err != nil {
		panic(err)
	}
	fmt.Println(hValsResult1) // >>> 2
	hValsResult2, err := rdb.HVals(ctx, "myhash").Result()
	if err != nil {
		panic(err)
	}
	sort.Strings(hValsResult2)
	fmt.Println(hValsResult2) // >>> [Hello World]
}
func ExampleClient_hdel() {
	ctx := context.Background()
	rdb := redis.NewClient(&redis.Options{
		Addr: "localhost:6379",
		Password: "", // no password docs
		DB: 0, // use default DB
	})
	hdel1, err := rdb.HSet(ctx, "myhash", "field1", "foo").Result()
	if err != nil {
		panic(err)
	}
	fmt.Println(hdel1) // >>> 1
	hdel2, err := rdb.HDel(ctx, "myhash", "field1").Result()
	if err != nil {
		panic(err)
	}
	fmt.Println(hdel2) // >>> 1
	hdel3, err := rdb.HDel(ctx, "myhash", "field2").Result()
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println(hdel3) // >>> 0
}

Go Quick-Start

using StackExchange.Redis;
using Xunit;
namespace Doc;
public class CmdsHashExample
{
 public void Run()
 {
 var muxer = ConnectionMultiplexer.Connect("localhost:6379");
 var db = muxer.GetDatabase();
 // Clear any keys here before using them in tests.
 db.KeyDelete("myhash");
 bool hdelRes1 = db.HashSet("myhash", "field1", "foo");
 RedisValue hdelRes2 = db.HashDelete("myhash", "field1");
 Console.WriteLine(hdelRes2); // >>> 1
 RedisValue hdelRes3 = db.HashDelete("myhash", "field1");
 Console.WriteLine(hdelRes3); // >>> 0
 Assert.True(hdelRes1);
 Assert.Equal(1, hdelRes2);
 Assert.Equal(0, hdelRes3);
 db.KeyDelete("myhash");
 bool hgetRes1 = db.HashSet("myhash", "field1", "foo");
 RedisValue hgetRes2 = db.HashGet("myhash", "field1");
 Console.WriteLine(hgetRes2); // >>> foo
 RedisValue hgetRes3 = db.HashGet("myhash", "field2");
 Console.WriteLine(hgetRes3); // >>> Null
 Assert.True(hgetRes1);
 Assert.Equal("foo", hgetRes2);
 Assert.Equal(RedisValue.Null, hgetRes3);
 db.KeyDelete("myhash");
 bool hsetRes1 = db.HashSet("myhash", "field1", "Hello");
 RedisValue hsetRes2 = db.HashGet("myhash", "field1");
 Console.WriteLine(hsetRes2); // >>> Hello
 db.HashSet(
 "myhash",
 [
 new("field2", "Hi"),
 new("field3", "World")
 ]
 );
 RedisValue hsetRes3 = db.HashGet("myhash", "field2");
 Console.WriteLine(hsetRes3); // >>> Hi
 RedisValue hsetRes4 = db.HashGet("myhash", "field3");
 Console.WriteLine(hsetRes4); // >>> World
 HashEntry[] hsetRes5 = db.HashGetAll("myhash");
 Console.WriteLine($"{string.Join(", ", hsetRes5.Select(h => $"{h.Name}: {h.Value}"))}");
 // >>> field1: Hello, field2: Hi, field3: World
 Assert.True(hsetRes1);
 Assert.Equal("Hello", hsetRes2);
 Assert.Equal("Hi", hsetRes3);
 Assert.Equal("World", hsetRes4);
 Assert.Equal(
 "field1: Hello, field2: Hi, field3: World",
 string.Join(", ", hsetRes5.Select(h => $"{h.Name}: {h.Value}"))
 );
 db.KeyDelete("myhash");
 db.HashSet("myhash",
 [
 new("field1", "Hello"),
 new("field2", "World")
 ]
 );
 HashEntry[] hGetAllResult = db.HashGetAll("myhash");
 Array.Sort(hGetAllResult, (a1, a2) => a1.Name.CompareTo(a2.Name));
 Console.WriteLine(
 string.Join(", ", hGetAllResult.Select(e => $"{e.Name}: {e.Value}"))
 );
 // >>> field1: Hello, field2: World
 Assert.Equal("field1: Hello, field2: World", string.Join(", ", hGetAllResult.Select(e => $"{e.Name}: {e.Value}")));
 db.KeyDelete("myhash");
 db.HashSet("myhash",
 [
 new("field1", "Hello"),
 new("field2", "World")
 ]
 );
 RedisValue[] hValsResult = db.HashValues("myhash");
 Array.Sort(hValsResult);
 Console.WriteLine(string.Join(", ", hValsResult));
 // >>> Hello, World
 Assert.Equal("Hello, World", string.Join(", ", hValsResult));
 }
}

C#-Sync Quick-Start

<?php
require_once __DIR__ . '/../vendor/autoload.php';
use PHPUnit\Framework\TestCase;
use Predis\Client as PredisClient;
class CmdsHashTest extends TestCase
{
 private PredisClient $redis;
 protected function setUp(): void
 {
 $this->redis = new PredisClient([
 'scheme' => 'tcp',
 'host' => '127.0.0.1',
 'port' => 6379,
 'password' => '',
 'database' => 0,
 ]);
 // Clean up before each test
 $this->redis->flushall();
 }
 public function testCmdsHash(): void
 {
 echo "\n=== Testing Redis Hash Commands ===\n";
 echo "\n--- HDEL Command ---\n";
 $hDelResult1 = $this->redis->hset('myhash', 'field1', 'foo');
 echo "HSET myhash field1 foo: " . $hDelResult1 . "\n"; // >>> 1

 $hDelResult2 = $this->redis->hdel('myhash', 'field1');
 echo "HDEL myhash field1: " . $hDelResult2 . "\n"; // >>> 1

 $hDelResult3 = $this->redis->hdel('myhash', 'field2');
 echo "HDEL myhash field2: " . $hDelResult3 . "\n"; // >>> 0

 $this->assertEquals(1, $hDelResult1);
 $this->assertEquals(1, $hDelResult2);
 $this->assertEquals(0, $hDelResult3);
 echo "\n--- HGET Command ---\n";
 $hGetResult1 = $this->redis->hset('myhash', 'field1', 'foo');
 echo "HSET myhash field1 foo: " . $hGetResult1 . "\n"; // >>> 1

 $hGetResult2 = $this->redis->hget('myhash', 'field1');
 echo "HGET myhash field1: " . ($hGetResult2 ?? 'null') . "\n"; // >>> foo

 $hGetResult3 = $this->redis->hget('myhash', 'field2');
 echo "HGET myhash field2: " . ($hGetResult3 ?? 'null') . "\n"; // >>> null

 $this->assertEquals(1, $hGetResult1);
 $this->assertEquals('foo', $hGetResult2);
 $this->assertNull($hGetResult3);
 echo "\n--- HGETALL Command ---\n";
 $hGetAllResult1 = $this->redis->hmset('myhash', ['field1' => 'Hello', 'field2' => 'World']);
 echo "HMSET myhash field1 Hello field2 World: " . ($hGetAllResult1 ? 'OK' : 'FAIL') . "\n"; // >>> OK

 $hGetAllResult2 = $this->redis->hgetall('myhash');
 echo "HGETALL myhash: " . json_encode($hGetAllResult2) . "\n"; // >>> {"field1":"Hello","field2":"World"}

 $this->assertEquals('OK', $hGetAllResult1);
 $this->assertEquals(['field1' => 'Hello', 'field2' => 'World'], $hGetAllResult2);
 echo "\n--- HSET Command ---\n";
 // Clean up first
 $this->redis->del('myhash');
 $hSetResult1 = $this->redis->hset('myhash', 'field1', 'Hello');
 echo "HSET myhash field1 Hello: " . $hSetResult1 . "\n"; // >>> 1

 $hSetResult2 = $this->redis->hget('myhash', 'field1');
 echo "HGET myhash field1: " . $hSetResult2 . "\n"; // >>> Hello

 $hSetResult3 = $this->redis->hmset('myhash', ['field2' => 'Hi', 'field3' => 'World']);
 echo "HMSET myhash field2 Hi field3 World: " . ($hSetResult3 ? 'OK' : 'FAIL') . "\n"; // >>> OK

 $hSetResult4 = $this->redis->hget('myhash', 'field2');
 echo "HGET myhash field2: " . $hSetResult4 . "\n"; // >>> Hi

 $hSetResult5 = $this->redis->hget('myhash', 'field3');
 echo "HGET myhash field3: " . $hSetResult5 . "\n"; // >>> World

 $hSetResult6 = $this->redis->hgetall('myhash');
 echo "HGETALL myhash: ";
 foreach ($hSetResult6 as $key => $value) {
 echo "Key: $key, Value: $value; ";
 }
 echo "\n";
 $this->assertEquals(1, $hSetResult1);
 $this->assertEquals('Hello', $hSetResult2);
 $this->assertEquals('OK', $hSetResult3);
 $this->assertEquals('Hi', $hSetResult4);
 $this->assertEquals('World', $hSetResult5);
 $this->assertEquals(['field1' => 'Hello', 'field2' => 'Hi', 'field3' => 'World'], $hSetResult6);
 echo "\n--- HVALS Command ---\n";
 // Clean up first
 $this->redis->del('myhash');
 $hValsResult1 = $this->redis->hmset('myhash', ['field1' => 'Hello', 'field2' => 'World']);
 echo "HMSET myhash field1 Hello field2 World: " . ($hValsResult1 ? 'OK' : 'FAIL') . "\n"; // >>> OK

 $hValsResult2 = $this->redis->hvals('myhash');
 echo "HVALS myhash: " . json_encode($hValsResult2) . "\n"; // >>> ["Hello","World"]

 $this->assertEquals('OK', $hValsResult1);
 $this->assertEquals(['Hello', 'World'], $hValsResult2);
 echo "\n=== All Hash Commands Tests Passed! ===\n";
 }
 protected function tearDown(): void
 {
 // Clean up after each test
 $this->redis->flushall();
 $this->redis->disconnect();
 }
}

PHP Quick-Start

Give these commands a try in the interactive console:

Return information

RESP2 RESP3

Array reply: a list of fields and their values, or an empty list when key does not exist.

Products

Tools

Get Redis

Connect

Learn

Latest

See how it works

HGETALL

Examples

Return information