redis中的hash也是我們使用中的高頻資料結構， 它的構造基本上和程式語言中的HashTable，Dictionary大同小異， 如果大家往後有什麼邏
輯需要用
Dictionary存放的話， 可以根據場景優先考慮下redis哦， 起碼可以裝裝逼嘛， 現在我預設你已經有裝逼的衝動了， 開啟redis手冊， 看看有哪些我們
用得到
的裝逼方法。

一： 常用方法

只要是一個數據結構，最基礎的永遠是CURD，redis中的insert和update，永遠只會需要set來替代，比如下面的Hset，如下圖：

前面幾篇文章我都沒有挑選一個方法仔細講解， 其實也沒什麼好講解的， 就好似C#中的一個類的一個方法而已， 知道傳遞一些啥引數就

HSET key field value

將雜湊表 key 中的域field 的值設為 value 。

如果 key 不存在，一個新的雜湊表被建立並進行HSET 操作。

如果域 field 已經存在於雜湊表中，舊值將被覆蓋。

可用版本：

>= 2.0.0

時間複雜度：

O(1)

返回值：

如果 field 是雜湊表中的一個新建域，並且值設定成功，返回1 。 如果雜湊表中域 field 已經存在且舊值已被新值覆蓋，返回 0 。

redis> HSET website google "www.g.cn"       # 設定一個新域
(integer) 1

redis> HSET website google "www.google.com" # 覆蓋一箇舊域
(integer) 0
 

在資料夾中的執行：src/redis-cli

或許有人看了上面的console有一點疑惑， 那就是前面有幾個引數， 比如person，name啦， 然後才是value， 如果你看了第一篇的話， 你大概就明
白了，
其實在redis的這個層面， 它永遠只有一個鍵， 一個值， 這個鍵永遠都是字串物件， 也就是SDS物件， 而值的種類就多了， 有字串物件， 有佇列
物件，
還有這篇的hash物件， 往後的有序集合物件等等， 如果你還不明白的話， 轉化為C#語言就是。

呼叫方法就是這麼的簡單， 關鍵在於時不時的需要你看一看手冊， 其實最重要的是瞭解下它在

二： 探索原理
hash的原始碼是在dict.h原始碼裡面， 列舉如下：

typedef struct dictEntry {
void *key;
union {
void *val;
uint64_t u64;
int64_t s64;
double d;
} v;
struct dictEntry *next;
} dictEntry;
typedef struct dictType {
unsigned int (*hashFunction)(const void *key);
void *(*keyDup)(void *privdata, const void *key);
void *(*valDup)(void *privdata, const void *obj);
int (*keyCompare)(void *privdata, const void *key1, const void *key2);
void (*keyDestructor)(void *privdata, void *key);
void (*valDestructor)(void *privdata, void *obj);
} dictType;
/* This is our hash table structure. Every dictionary has two of this as we
* implement incremental rehashing, for the old to the new 0. */
typedef struct dictht {
dictEntry **table;
unsigned long size;
unsigned long sizemask;
unsigned long used;
} dictht;
typedef struct dict {
dictType *type;
void *privdata;
dictht ht[2];
long rehashidx; /* rehashing not in progress if rehashidx == -1 */
int iterators; /* number of iterators currently running */
} dict;
/* If safe is set to 1 this is a safe iterator, that means, you can call
* dictAdd, dictFind, and other functions against the dictionary even while
* iterating. Otherwise it is a non safe iterator, and only dictNext()
* should be called while iterating. */
typedef struct dictIterator {
dict *d;
long index;
int table, safe;
dictEntry *entry, *nextEntry;
/* unsafe iterator fingerprint for misuse detection. */
long long fingerprint;
} dictIterator;

1. dict結構

typedef struct dict {
2 dictType *type;
3 void *privdata;
4 dictht ht[2];
5 long rehashidx; /* rehashing not in progress if rehashidx == -1 */
6 int iterators; /* number of iterators currently running */
7 } dict;

typedef struct dictType {
2 unsigned int (*hashFunction)(const void *key);
3 void *(*keyDup)(void *privdata, const void *key);
4 void *(*valDup)(void *privdata, const void *obj);
5 int (*keyCompare)(void *privdata, const void *key1, const void *key2);
6 void (*keyDestructor)(void *privdata, void *key);
7 void (*valDestructor)(void *privdata, void *obj);
8 } dictType;

從上面這個資料結構中你可以看到裡面都是一些方法， 但是有一個非常重要的方法， 那就是第一個hashFunction， 可以看到它就是計算hash值
的，
跟C#中的dictionary中求hash值一樣一樣的。

<2> dictht ht[2]
你可能會疑問， 為什麼這個屬性是2個大小的陣列呢， 其實正真使用的是ht[0]， 而ht[1]是用於擴容hash表時的暫存陣列， 這一點也很奇葩，
同時也很精妙， redis為什麼會這麼做呢？ ？ ？ 仔細想想你可能會明白， 擴容有兩種方法， 要麼一次性擴容， 要麼漸進性擴容， 後面這種擴容是什
麼意思呢？ 就是我在擴容的同時不影響前端的CURD， 我慢慢的把資料從ht[0]轉移到ht[1]中， 同時rehashindex來記錄轉移的情況， 當全部轉移
完成之後， 將ht[1]改成ht[0]使用， 就這麼簡單。
2. dicth結構

typedef struct dictht {
2 dictEntry **table;
3 unsigned long size;
4 unsigned long sizemask;
5 unsigned long used;
6 } dictht;

typedef struct dictEntry {2 void *key;
3 union {
4 void *val;
5 uint64_t u64;
6 int64_t s64;
7 double d;
8 } v;
9 struct dictEntry *next;
10 } dictEntry;

從這個資料結構上面你可以看到有三個大屬性。
第一個就是： *key： 它就是hash表中的key。
第二個就是： union的*val就是hash的value。
第三個就是： *next就是為了防止hash衝突採用的掛鏈手段。
這個原理和C#中的Dictionary還是一樣一樣的。

不知道你看懂了沒有， 如果總結上面描述的話， 我可以畫出如下的hash結構圖。