erlang dict 使用

erlang 的 dict 模块比较完整的实现了一个键值(Key -Value)字典。通过这个模块，你可以插入，附加(append)，删除，更新键值对字典，也提供了获取字典大小和检查键是否存在等调用接口，而且还包含一些对字典键或值进行操作的函数方法，例如：递归(fold)、过滤(filter)、遍历(map)字典等特殊操作函数。

new() -> dictionary()：生成一个新的原始字典（其实是返回一个内部定义的dict记录record）

dict:new().%% 下面是返回的dict记录的初始值，具体请看\lib\stdlib-1.18.2\src\dict.erl-record(dict, {size=0      :: non_neg_integer(),   % Number of elementsn=?seg_size      :: non_neg_integer(),   % Number of active slotsmaxn=?seg_size   :: non_neg_integer(),% Maximum slotsbso=?seg_size div 2:: non_neg_integer(),   % Buddy slot offsetexp_size=?exp_size :: non_neg_integer(),   % Size to expand atcon_size=?con_size :: non_neg_integer(),   % Size to contract atempty      :: tuple(),% Empty segmentsegs      :: tuple()      % Segments}).

store(Key, Value, Dict1) -> Dict2：以键值对的形式(Key - Value)存储在字典里。如果字典里

已经存在Key的键，则Key相关的值替换为Value

D = dict:new(),D1 = dict:store(k1, v1, D).%% D2 = dict:store(k2, v2, D1).%% D3 = dict:store(k2, v3, D2).

from_list(List) -> Dict：把一个key-value形式的列表转换为一个字典

dict:from_list([{k1, v1}, {k2, v2}, {k3, v3}]).%% 相当于D = dict:new(),D1 = dict:store(k1, v1, D),D2 = dict:store(k2, v2, D1),D3 = dict:store(k3, v3, D2).

size(Dict) -> int()：返回字典元素的数量

dict:size(dict:from_list([{k1, v1}, {k2, v2}, {k3, v3}])).

to_list(Dict) -> List：把字典转换成一个列表形式

D = dict:from_list([{k1, v1}, {k2, v2}, {k3, v3}]).dict:to_list(D).

append(Key, Value, Dict1) -> Dict2：给与键相关联的值的当前列表添加一个新值

D = dict:new().D1 = dict:append(a, b, D).dict:to_list(D1).D2 = dict:append(a, c, D1).dict:to_list(D2).

append_list(Key, ValList, Dict1) -> Dict2：给与键相关联的值的当前列表添加一个列表值

D = dict:new(),D1 = dict:store(k, [v1], D),D2 = dict:append_list(k, [v2, v3], D1),dict:to_list(D2).

erase(Key, Dict1) -> Dict2：清除字典里与键相关联的所有项

D = dict:from_list([{k1, v1}, {k2, v2}, {k3, v3}]).dict:to_list(D).dict:to_list(dict:erase(k1, D)).

is_key(Key, Dict) -> bool()：指定的键(Key)是否在字典里

D = dict:from_list([{k1, v1}, {k2, v2}, {k3, v3}]),dict:is_key(k1, D).

fetch(Key, Dict) -> Value：返回一个在字典里跟键相关联的值（如果在字典里没有相关联的值则报错）

D = dict:from_list([{k1, v1}, {k2, v2}, {k3, v3}]).dict:fetch(k1, D).

fetch_keys(Dict) -> Keys：以列表的形式返回字典里所有的键

D = dict:from_list([{k1, v1}, {k2, v2}, {k3, v3}]).dict:fetch_keys(D).

filter(Pred, Dict1) -> Dict2：返回符合筛选过滤函数(Pred)条件的所有键和值的字典

D = dict:from_list([{k1, v1}, {k2, v2}, {k3, v3}]),D1 = dict:filter(fun(_K, V)-> V == v2 end, D),dict:to_list(D1).

find(Key, Dict) -> {ok, Value} | error：跟fetch一样，都是查找返回一个在字典里跟键相关联的值，不过返回的格式不一样，而且字典里没有相关联的值不会，只返回一个原子error

D = dict:from_list([{k1, v1}, {k2, v2}, {k3, v3}]),dict:find(k1, D).

fold(Fun, Acc0, Dict) -> Acc1：对字典里的每一个键(Key)或值(Value)跟一个临时累积参数一齐遍历调用函数(Fun)，并返回一个新的累积器（accumulator）以传给下一次函数(Fun)调用

%% 这里是求字典里所有值得平方和D = dict:from_list([{k1, 1}, {k2, 2}, {k3, 3}]),dict:fold(fun(_Key,Val, Acc) -> Val * Val + Acc end, 0, D).

map(Fun, Dict1) -> Dict2：对字典里的每一个键(Key)或值(Value)遍历调用函数(Fun)并返回一个新的字典

D = dict:from_list([{k1, 1}, {k2, 2}, {k3, 3}]),dict:map(fun(_Key, Val) -> Val * Val end, D).

merge(Fun, Dict1, Dict2) -> Dict3：把2个字典合并成为一个新的字典，原来字典的键值都有保留，如果存在相同的键，则调用函数Fun处理返回一个新值

L1 = [{k1, 1}, {k2, 2}, {k3, 3}],L2 = [{k1, 1}, {k2, 2}, {k3, 3}, {k4, 4}],%% 这里如果有键相同时，则把值相加MergeFun = fun(_Key, V1, V2) -> V1 + V2 end,D1 = dict:from_list(L1),D2 = dict:from_list(L2),dict:to_list(dict:merge(MergeFun, D1, D2)).

update(Key, Fun, Dict1) -> Dict2：通过调用一个函数(Fun)来更新跟给出的键相关的值，如果指定的键在字典里不存在则报错

D = dict:from_list([{k1, 1}, {k2, 2}]),dict:to_list(D),D1 = dict:update(k1, fun(V)-> V * 2 end, D),dict:to_list(D1).

update(Key, Fun, Initial, Dict1) -> Dict2：跟上面update一样，都是通过调用一个函数(Fun)来更新跟给出的键相关的值，不过如果指定的键在字典里不存在，则用给出的指定初始值（Initial）替换

D = dict:from_list([{k1, 1}, {k2, 2}]),dict:to_list(D),D1 = dict:update(k3, fun(V)-> V * 2 end, 3, D),dict:to_list(D1).

update_counter(Key, Increment, Dict1) -> Dict2：对跟给出的键相关的值进行累加(Increment)，如果字典里没有给出的相关的键，则用累加的值替换

D = dict:from_list([{k,1}]),D1 = dict:update_counter(k, 1, D),dict:to_list(D1).%% 字典不存在键值则新加D1 = dict:update_counter(k1, 1, D),dict:to_list(D1).