nvdict

simple dict tools - only install which you needed

Usage no npm install needed!

<script type="module">
  import nvdict from 'https://cdn.skypack.dev/nvdict';
</script>

README

nvdict

  • simple dict tools
  • only install which you needed

install

all

npm install nvdict

splitted

usage

const dict_bsc = require("nv-dict-basic")
const dict_init = require("nv-dict-init")
const dict_cll = require("nv-dict-collection")
const dict_com = require("nv-dict-combo")
const dict_cmp = require("nv-dict-compare")
const dict_desc = require("nv-dict-desc")
const dict_find = require("nv-dict-find")
const dict_findi = require("nv-dict-find-index")
const dict_findk = require("nv-dict-find-key")
const dict_findv = require("nv-dict-find-value")
const dict_findik = require("nv-dict-findik")
const dict_findiv = require("nv-dict-findiv")
const dict_findkv = require("nv-dict-findkv")
const dict_findikv = require("nv-dict-findikv")
const dict_indexof = require("nv-dict-index-of")
const dict_keyof = require("nv-dict-key-of")
const dict_swap = require("nv-dict-swap")
const dict_sort = require("nv-dict-sort")
const dict_setter = require("nv-dict-setter")
const dict_map = require("nv-dict-map");
const dict_fpop = require("nv-dict-pop-with-function");
const dict_vpop = require("nv-dict-pop-with-value");
const dict_frm = require("nv-dict-remove-with-function");
const dict_vrm = require("nv-dict-remove-with-value");
const dict_frplc = require("nv-dict-replace-with-function");
const dict_vrplc = require("nv-dict-replace-with-value");
const dict_prop = require("nv-dict-proposition");
const dict_grp = require("nv-dict-group");
const dict_smirr = require("nv-dict-smirr");
const dict_opt   = require("nv-dict-optional")
const dict_asgn  = require("nv-dict-assign")

API

  • dict_bsc.list(d)

  • dict_bsc.from_list(l)

  • dict_bsc.keyat(d,index)

  • dict_bsc.idxat(d,key)

  • dict_bsc.fstk(d)

  • dict_bsc.lstk(d)

  • dict_bsc.iget(d,index)

  • dict_bsc.iset(d,index,val)

  • dict_bsc.idel(d,index)

  • dict_bsc.ihas(d,index)

  • dict_bsc.assign(orig_dict,...dicts)

  • dict_bsc.concat(...dicts)

  • dict_bsc.clear(d)

  • dict_bsc.clear_and_tolist(d)

  • dict_bsc.clear_and_toklist(d)

  • dict_bsc.clear_and_cp(d)

  • dict_bsc.rm(d,...keys)

  • dict_bsc.rm_not(d,...keys)

  • dict_bsc.rm_before(d,end_key_or_index)

  • dict_bsc.rm_after(d,key_or_index) //not-included

  • dict_bsc.rm_from(d,key_or_index) //included

  • dict_bsc.rm_between(d,start_key_or_index,end_key_or_index)

  • dict_bsc.pop(d,count=1,from_index)

  • dict_bsc.pop_before(d,end_key_or_index)

  • dict_bsc.pop_after(d,key_or_index) //not-included

  • dict_bsc.pop_from(d,key_or_index) //included

  • dict_bsc.pop_between(d,start_key_or_index,end_key_or_index)

  • dict_bsc.insert_before(d,_key_or_index,nd)

  • dict_bsc.insert_after(d,_key_or_index,nd)

  • dict_bsc.kvlist(d)

  • dict_bsc.from_kvlist(kl,vl)

  • dict_bsc.klist(d,...keys)

  • dict_bsc.klist_not(d,...keys)

  • dict_bsc.vlist(d,...keys)

  • dict_bsc.vlist_not(d,...keys)

  • dict_bsc.some(d,...keys)

  • dict_bsc.some_not(d,...keys)

  • dict_bsc.update(d0,d1)

  • dict_bsc.update_only_exist_in_own(d0,d1)

  • dict_bsc.update_only_non_exist_in_own(d0,d1)

  • dict_bsc.length(d)

  • dict_bsc.eq(d0,d1)

  • dict_bsc.to_map(d)

  • dict_bsc.to_wmap(d)

  • dict_bsc.cp(d)

  • dict_bsc.gen_from_fst(d)

  • dict_bsc.gen_from_lst(d)

  • dict_bsc.rekey(d,...ks)

  • dict_bsc.reval(d,...vs)

  • dict_bsc.krekey(d,ok,nk)

  • dict_bsc.vrekey(d,v,nk)

  • dict_bsc.getset(d,k,v)

  • dict_bsc.setnx(d,k,v)

  • dict_bsc.mset(d,...kvs)

  • dict_bsc.msetnx(d,...kvs)

  • dict_init.use(val,...keys)

  • dict_init.undef(...keys)

  • dict_init.nul(...keys)

  • dict_init.zero(...keys)

  • dict_init.tru(...keys)

  • dict_init.fls(...keys)

  • dict_init.empty_str(...keys)

  • dict_init.empty_arr(...keys)

  • dict_init.empty_dict(...keys)

  • dict_cll.get_union_klist(d0,d1)

  • dict_cll.get_diff_klist(d0,d1)

  • dict_cll.get_inter_klist(d0,d1)

  • dict_cll.union(d0,d1)

  • dict_cll.diff(d0,d1)

  • dict_cll.inter(d0,d1)

  • dict_com.get_klist_combos(d)

  • dict_com.get_klist_perms(d)

  • dict_com.comb(d)

  • dict_com.perm(d)

  • dict_com.get_all_combs(d)

  • dict_com.get_all_perms(d)

  • dict_cmp.samek(d0,d1)

  • dict_cmp.samek_engine(cond_func,d0,d1)

  • dict_cmp.samekv(d0,d1)

  • dict_cmp.samek_diffv(d0,d1)

  • dict_cmp.diffk(d0,d1)

  • dict_cmp.diffk_both(d0,d1)

  • dict_desc.copy(d)

  • dict_desc.mirror(d)

  • dict_desc.KFIRST

  • dict_desc.VFIRST

  • dict_desc.mdict(d,pri_key="k")

  • dict_desc.desc(d)

  • dict_desc.from_desc(desc)

  • dict_find.fst(d,cond_func,...other_params)

  • dict_find.fst_not(d,cond_func,...other_params)

  • dict_find.lst(d,cond_func,...other_params)

  • dict_find.fst_not(d,cond_func,...other_params)

  • dict_find.which(d,which,cond_func,...other_params)

  • dict_find.which_not(d,which,cond_func,...other_params)

  • dict_find.which_from_lst(d,which,cond_func,...other_params)

  • dict_find.which_not_from_lst(d,which,cond_func,...other_params)

  • dict_find.some(d,whiches,cond_func,...other_params)

  • dict_find.some_not(d,whiches,cond_func,...other_params)

  • dict_find.some_from_lst(d,whiches,cond_func,...other_params)

  • dict_find.some_not_from_lst(d,whiches,cond_func,...other_params)

  • dict_find.all(d,cond_func,...other_params)

  • dict_find.all_not(d,cond_func,...other_params)

  • dict_findi.fst(d,cond_func,...other_params)

  • dict_findi.fst_not(d,cond_func,...other_params)

  • dict_findi.lst(d,cond_func,...other_params)

  • dict_findi.fst_not(d,cond_func,...other_params)

  • dict_findi.which(d,which,cond_func,...other_params)

  • dict_findi.which_not(d,which,cond_func,...other_params)

  • dict_findi.which_from_lst(d,which,cond_func,...other_params)

  • dict_findi.which_not_from_lst(d,which,cond_func,...other_params)

  • dict_findi.some(d,whiches,cond_func,...other_params)

  • dict_findi.some_not(d,whiches,cond_func,...other_params)

  • dict_findi.some_from_lst(d,whiches,cond_func,...other_params)

  • dict_findi.some_not_from_lst(d,whiches,cond_func,...other_params)

  • dict_findi.all(d,cond_func,...other_params)

  • dict_findi.all_not(d,cond_func,...other_params)

  • dict_findk.fst(d,cond_func,...other_params)

  • dict_findk.fst_not(d,cond_func,...other_params)

  • dict_findk.lst(d,cond_func,...other_params)

  • dict_findk.fst_not(d,cond_func,...other_params)

  • dict_findk.which(d,which,cond_func,...other_params)

  • dict_findk.which_not(d,which,cond_func,...other_params)

  • dict_findk.which_from_lst(d,which,cond_func,...other_params)

  • dict_findk.which_not_from_lst(d,which,cond_func,...other_params)

  • dict_findk.some(d,whiches,cond_func,...other_params)

  • dict_findk.some_not(d,whiches,cond_func,...other_params)

  • dict_findk.some_from_lst(d,whiches,cond_func,...other_params)

  • dict_findk.some_not_from_lst(d,whiches,cond_func,...other_params)

  • dict_findk.all(d,cond_func,...other_params)

  • dict_findk.all_not(d,cond_func,...other_params)

  • dict_findv.fst(d,cond_func,...other_params)

  • dict_findv.fst_not(d,cond_func,...other_params)

  • dict_findv.lst(d,cond_func,...other_params)

  • dict_findv.fst_not(d,cond_func,...other_params)

  • dict_findv.which(d,which,cond_func,...other_params)

  • dict_findv.which_not(d,which,cond_func,...other_params)

  • dict_findv.which_from_lst(d,which,cond_func,...other_params)

  • dict_findv.which_not_from_lst(d,which,cond_func,...other_params)

  • dict_findv.some(d,whiches,cond_func,...other_params)

  • dict_findv.some_not(d,whiches,cond_func,...other_params)

  • dict_findv.some_from_lst(d,whiches,cond_func,...other_params)

  • dict_findv.some_not_from_lst(d,whiches,cond_func,...other_params)

  • dict_findv.all(d,cond_func,...other_params)

  • dict_findv.all_not(d,cond_func,...other_params)

  • dict_findik.fst(d,cond_func,...other_params)

  • dict_findik.fst_not(d,cond_func,...other_params)

  • dict_findik.lst(d,cond_func,...other_params)

  • dict_findik.fst_not(d,cond_func,...other_params)

  • dict_findik.which(d,which,cond_func,...other_params)

  • dict_findik.which_not(d,which,cond_func,...other_params)

  • dict_findik.which_from_lst(d,which,cond_func,...other_params)

  • dict_findik.which_not_from_lst(d,which,cond_func,...other_params)

  • dict_findik.some(d,whiches,cond_func,...other_params)

  • dict_findik.some_not(d,whiches,cond_func,...other_params)

  • dict_findik.some_from_lst(d,whiches,cond_func,...other_params)

  • dict_findik.some_not_from_lst(d,whiches,cond_func,...other_params)

  • dict_findik.all(d,cond_func,...other_params)

  • dict_findik.all_not(d,cond_func,...other_params)

  • dict_findiv.fst(d,cond_func,...other_params)

  • dict_findiv.fst_not(d,cond_func,...other_params)

  • dict_findiv.lst(d,cond_func,...other_params)

  • dict_findiv.fst_not(d,cond_func,...other_params)

  • dict_findiv.which(d,which,cond_func,...other_params)

  • dict_findiv.which_not(d,which,cond_func,...other_params)

  • dict_findiv.which_from_lst(d,which,cond_func,...other_params)

  • dict_findiv.which_not_from_lst(d,which,cond_func,...other_params)

  • dict_findiv.some(d,whiches,cond_func,...other_params)

  • dict_findiv.some_not(d,whiches,cond_func,...other_params)

  • dict_findiv.some_from_lst(d,whiches,cond_func,...other_params)

  • dict_findiv.some_not_from_lst(d,whiches,cond_func,...other_params)

  • dict_findiv.all(d,cond_func,...other_params)

  • dict_findiv.all_not(d,cond_func,...other_params)

  • dict_findkv.fst(d,cond_func,...other_params)

  • dict_findkv.fst_not(d,cond_func,...other_params)

  • dict_findkv.lst(d,cond_func,...other_params)

  • dict_findkv.fst_not(d,cond_func,...other_params)

  • dict_findkv.which(d,which,cond_func,...other_params)

  • dict_findkv.which_not(d,which,cond_func,...other_params)

  • dict_findkv.which_from_lst(d,which,cond_func,...other_params)

  • dict_findkv.which_not_from_lst(d,which,cond_func,...other_params)

  • dict_findkv.some(d,whiches,cond_func,...other_params)

  • dict_findkv.some_not(d,whiches,cond_func,...other_params)

  • dict_findkv.some_from_lst(d,whiches,cond_func,...other_params)

  • dict_findkv.some_not_from_lst(d,whiches,cond_func,...other_params)

  • dict_findkv.all(d,cond_func,...other_params)

  • dict_findkv.all_not(d,cond_func,...other_params)

  • dict_findikv.fst(d,cond_func,...other_params)

  • dict_findikv.fst_not(d,cond_func,...other_params)

  • dict_findikv.lst(d,cond_func,...other_params)

  • dict_findikv.fst_not(d,cond_func,...other_params)

  • dict_findikv.which(d,which,cond_func,...other_params)

  • dict_findikv.which_not(d,which,cond_func,...other_params)

  • dict_findikv.which_from_lst(d,which,cond_func,...other_params)

  • dict_findikv.which_not_from_lst(d,which,cond_func,...other_params)

  • dict_findikv.some(d,whiches,cond_func,...other_params)

  • dict_findikv.some_not(d,whiches,cond_func,...other_params)

  • dict_findikv.some_from_lst(d,whiches,cond_func,...other_params)

  • dict_findikv.some_not_from_lst(d,whiches,cond_func,...other_params)

  • dict_findikv.all(d,cond_func,...other_params)

  • dict_findikv.all_not(d,cond_func,...other_params)

  • dict_indexof.fst(d,value)

  • dict_indexof.lst(d,value)

  • dict_indexof.which(d,value,which)

  • dict_indexof.which_from_lst(d,value,which)

  • dict_indexof.some(d,value,...whiches)

  • dict_indexof.some_from_lst(d,value,...whiches)

  • dict_indexof.all(d,value)

  • dict_keyof.fst(d,value)

  • dict_keyof.lst(d,value)

  • dict_keyof.which(d,value,which)

  • dict_keyof.which_from_lst(d,value,which)

  • dict_keyof.some(d,value,...whiches)

  • dict_keyof.some_from_lst(d,value,...whiches)

  • dict_keyof.all(d,value)

  • dict_swap.kswap(d,k0,k1)

  • dict_swap.vswap(d,v0,v1,which0=0,which1=0)

  • dict_sort.DFLT_KSORT_FUNC

  • dict_sort.DFLT_VSORT_FUNC

  • dict_sort(d,sort_func)

  • dict_sort.ksort(d)

  • dict_sort.vsort(d)

  • dict_sort.reverse(d)

  • dict_setter.all(d,val)

  • dict_setter.some(d,val,...ks)

  • dict_setter.some_not(d,val,...ks)

  • dict_setter.filter_map(d,val_map_func,cond_func,...other_args)

  • dict_setter.filter(d,val,cond_func,...other_args)

  • dict_setter.kfilter(d,val,cond_func,...other_args)

  • dict_setter.vfilter(d,val,cond_func,...other_args)

  • dict_setter.ifilter(d,val,cond_func,...other_args)

  • dict_map.f_mapk

  • dict_map.fio_mapk

  • dict_map.fki_mapk

  • dict_map.fko_mapk

  • dict_map.fv_mapk

  • dict_map.fvio_mapk

  • dict_map.fvki_mapk

  • dict_map.fvko_mapk

  • dict_map.i_mapk

  • dict_map.k_mapk

  • dict_map.kio_mapk

  • dict_map.o_mapk

  • dict_map.vi_mapk

  • dict_map.vk_mapk

  • dict_map.vkio_mapk

  • dict_map.vo_mapk

  • dict_map.f_mapv

  • dict_map.fio_mapv

  • dict_map.fki_mapv

  • dict_map.fko_mapv

  • dict_map.fv_mapv

  • dict_map.fvio_mapv

  • dict_map.fvki_mapv

  • dict_map.fvko_mapv

  • dict_map.i_mapv

  • dict_map.k_mapv

  • dict_map.kio_mapv

  • dict_map.o_mapv

  • dict_map.vi_mapv

  • dict_map.vk_mapv

  • dict_map.vkio_mapv

  • dict_map.vo_mapv

  • dict_map.fi_mapk

  • dict_map.fk_mapk

  • dict_map.fkio_mapk

  • dict_map.fo_mapk

  • dict_map.fvi_mapk

  • dict_map.fvk_mapk

  • dict_map.fvkio_mapk

  • dict_map.fvo_mapk

  • dict_map.io_mapk

  • dict_map.ki_mapk

  • dict_map.ko_mapk

  • dict_map.v_mapk

  • dict_map.vio_mapk

  • dict_map.vki_mapk

  • dict_map.vko_mapk

  • dict_map.fi_mapv

  • dict_map.fk_mapv

  • dict_map.fkio_mapv

  • dict_map.fo_mapv

  • dict_map.fvi_mapv

  • dict_map.fvk_mapv

  • dict_map.fvkio_map

  • dict_map.fvo_mapv

  • dict_map.io_mapv

  • dict_map.ki_mapv

  • dict_map.ko_mapv

  • dict_map.v_mapv

  • dict_map.vio_mapv

  • dict_map.vki_mapv

  • dict_map.vko_mapv

  • dict_fpop.gen_from_fst(d)

  • dict_fpop.gen_from_lst(d)

  • dict_fpop.fst(d,cond_func,...cond_other_func_params)

  • dict_fpop.fst_not(d,cond_func,...cond_other_func_params)

  • dict_fpop.which(d,index,cond_func,...cond_other_func_params)

  • dict_fpop.which_not(d,index,cond_func,...cond_other_func_params)

  • dict_fpop.which_from_lst(d,index,cond_func,...cond_other_func_params)

  • dict_fpop.which_not_from_lst(d,index,cond_func,...cond_other_func_params)

  • dict_fpop.lst(d,cond_func,...cond_other_func_params)

  • dict_fpop.lst_not(d,cond_func,...cond_other_func_params)

  • dict_fpop.some(d,whiches,cond_func,...cond_other_func_params)

  • dict_fpop.some_not(d,whiches,cond_func,...cond_other_func_params)

  • dict_fpop.some_from_lst(d,whiches,cond_func,...cond_other_func_params)

  • dict_fpop.some_not_from_lst(d,whiches,cond_func,...cond_other_func_params)

  • dict_fpop.all(d,cond_func,...cond_other_func_params)

  • dict_fpop.all_not(d,cond_func,...cond_other_func_params)

  • dict_vpop.fst(d,v,...cond_other_func_params)

  • dict_vpop.fst_not(d,v,...cond_other_func_params)

  • dict_vpop.which(d,index,v,...cond_other_func_params)

  • dict_vpop.which_not(d,index,v,...cond_other_func_params)

  • dict_vpop.which_from_lst(d,index,v,...cond_other_func_params)

  • dict_vpop.which_not_from_lst(d,index,v,...cond_other_func_params)

  • dict_vpop.lst(d,v,...cond_other_func_params)

  • dict_vpop.lst_not(d,v,...cond_other_func_params)

  • dict_vpop.some(d,whiches,v,...cond_other_func_params)

  • dict_vpop.some_not(d,whiches,v,...cond_other_func_params)

  • dict_vpop.some_from_lst(d,whiches,v,...cond_other_func_params)

  • dict_vpop.some_not_from_lst(d,whiches,v,...cond_other_func_params)

  • dict_vpop.all(d,v,...cond_other_func_params)

  • dict_vpop.all_not(d,v,...cond_other_func_params)

  • dict_frm.fst(d,cond_func,...cond_other_func_params)

  • dict_frm.fst_not(d,cond_func,...cond_other_func_params)

  • dict_frm.which(d,index,cond_func,...cond_other_func_params)

  • dict_frm.which_not(d,index,cond_func,...cond_other_func_params)

  • dict_frm.which_from_lst(d,index,cond_func,...cond_other_func_params)

  • dict_frm.which_not_from_lst(d,index,cond_func,...cond_other_func_params)

  • dict_frm.lst(d,cond_func,...cond_other_func_params)

  • dict_frm.lst_not(d,cond_func,...cond_other_func_params)

  • dict_frm.some(d,whiches,cond_func,...cond_other_func_params)

  • dict_frm.some_not(d,whiches,cond_func,...cond_other_func_params)

  • dict_frm.some_from_lst(d,whiches,cond_func,...cond_other_func_params)

  • dict_frm.some_not_from_lst(d,whiches,cond_func,...cond_other_func_params)

  • dict_frm.all(d,cond_func,...cond_other_func_params)

  • dict_frm.all_not(d,cond_func,...cond_other_func_params)

  • dict_vrm.fst(d,v,...cond_other_func_params)

  • dict_vrm.fst_not(d,v,...cond_other_func_params)

  • dict_vrm.which(d,index,v,...cond_other_func_params)

  • dict_vrm.which_not(d,index,v,...cond_other_func_params)

  • dict_vrm.which_from_lst(d,index,v,...cond_other_func_params)

  • dict_vrm.which_not_from_lst(d,index,v,...cond_other_func_params)

  • dict_vrm.lst(d,v,...cond_other_func_params)

  • dict_vrm.lst_not(d,v,...cond_other_func_params)

  • dict_vrm.some(d,whiches,v,...cond_other_func_params)

  • dict_vrm.some_not(d,whiches,v,...cond_other_func_params)

  • dict_vrm.some_from_lst(d,whiches,v,...cond_other_func_params)

  • dict_vrm.some_not_from_lst(d,whiches,v,...cond_other_func_params)

  • dict_vrm.all(d,v,...cond_other_func_params)

  • dict_vrm.all_not(d,v,...cond_other_func_params)

  • dict_frplc.fst(d,new_val,cond_func,...cond_other_func_params)

  • dict_frplc.fst_not(d,new_val,cond_func,...cond_other_func_params)

  • dict_frplc.which(d,new_val,index,cond_func,...cond_other_func_params)

  • dict_frplc.which_not(d,new_val,index,cond_func,...cond_other_func_params)

  • dict_frplc.which_from_lst(d,new_val,index,cond_func,...cond_other_func_params)

  • dict_frplc.which_not_from_lst(d,new_val,index,cond_func,...cond_other_func_params)

  • dict_frplc.lst(d,new_val,cond_func,...cond_other_func_params)

  • dict_frplc.lst_not(d,new_val,cond_func,...cond_other_func_params)

  • dict_frplc.some(d,new_val,whiches,cond_func,...cond_other_func_params)

  • dict_frplc.some_not(d,new_val,whiches,cond_func,...cond_other_func_params)

  • dict_frplc.some_from_lst(d,new_val,whiches,cond_func,...cond_other_func_params)

  • dict_frplc.some_not_from_lst(d,new_val,whiches,cond_func,...cond_other_func_params)

  • dict_frplc.all(d,new_val,cond_func,...cond_other_func_params)

  • dict_frplc.all_not(d,new_val,cond_func,...cond_other_func_params)

  • dict_vrplc.fst(d,new_val,...cond_other_func_params)

  • dict_vrplc.fst_not(d,new_val,...cond_other_func_params)

  • dict_vrplc.which(d,index,new_val,...cond_other_func_params)

  • dict_vrplc.which_not(d,index,new_val,...cond_other_func_params)

  • dict_vrplc.which_from_lst(d,index,new_val,...cond_other_func_params)

  • dict_vrplc.which_not_from_lst(d,index,new_val,...cond_other_func_params)

  • dict_vrplc.lst(d,new_val,...cond_other_func_params)

  • dict_vrplc.lst_not(d,new_val,...cond_other_func_params)

  • dict_vrplc.some(d,whiches,new_val,...cond_other_func_params)

  • dict_vrplc.some_not(d,whiches,new_val,...cond_other_func_params)

  • dict_vrplc.some_from_lst(d,whiches,new_val,...cond_other_func_params)

  • dict_vrplc.some_not_from_lst(d,whiches,new_val,...cond_other_func_params)

  • dict_vrplc.all(d,new_val,...cond_other_func_params)

  • dict_vrplc.all_not(d,new_val,...cond_other_func_params)

  • dict_prop.get_tuple_descs(d)

  • dict_prop.all(d,cond_func,...other_params)

  • dict_prop.every(d,cond_func,...other_params)

  • dict_prop.all_not(d,cond_func,...other_params)

  • dict_prop.every_not(d,cond_func,...other_params)

  • dict_prop.any(d,cond_func,...other_params)

  • dict_prop.any_not(d,cond_func,...other_params)

  • dict_prop.at_most_several(d,n,cond_func,...other_params)

  • dict_prop.at_most_several_not(d,n,cond_func,...other_params)

  • dict_prop.several(d,n,cond_func,...other_params)

  • dict_prop.several_not(d,n,cond_func,...other_params)

  • dict_prop.at_least_several(d,n,cond_func,...other_params)

  • dict_prop.at_least_several_not(d,n,cond_func,...other_params)

  • dict_prop.fst(d,cond_func,...other_params)

  • dict_prop.fst_not(d,cond_func,...other_params)

  • dict_prop.which(d,which,cond_func,...other_params)

  • dict_prop.which_not(d,which,cond_func,...other_params)

  • dict_prop.lst(d,cond_func,...other_params)

  • dict_prop.lst_not(d,cond_func,...other_params)

  • dict_prop.at_most_some(d,whiches,cond_func,...other_params)

  • dict_prop.at_most_some_not(d,whiches,cond_func,...other_params)

  • dict_prop.some(d,whiches,cond_func,...other_params)

  • dict_prop.some_not(d,whiches,cond_func,...other_params)

  • dict_prop.at_least_some(d,whiches,cond_func,...other_params)

  • dict_prop.at_least_some_not(d,whiches,cond_func,...other_params)

  • dict_grp.fgrp(d,fltr_func)

  • dict_grp.vgrp(d)

  • dict_grp.klgrp(d)

  • dict_grp.vlgrp(d)

  • dict_grp.fgrp_engine(rtrn_func,d,fltr_func)

  • dict_smirr.VMdict

  • dict_smirr.KVMdict

  • dict_smirr.is_vmirrable(d)

  • dict_smirr.is_kvmirrable(d)

  • dict_smirr.vmode_validate(d,key,value)

  • dict_smirr.kvmode_validate(d,key,value)

  • dict_opt.gen_ordered(tem,cfg,with_placeholder=false,placeholder=null)

  • dict_opt.ordered(tem,cfg,with_placeholder=false,placeholder=null)

  • dict_fltr.filter(d,condf=(v,k,i)=>{/.../})

  • dict_asgn.add(d0,d1)

  • dict_asgn.set(d0,d1)

  • dict_asgn.add_then_set_if_noexist(d0,d1)

  • dict_asgn.set_if_exist_else_add_then_set(d0,d1)

  • dict_asgn.assign(d0,d1)

  • dict_asgn.set_if_exist_else_add(d0,d1)

  • dict_asgn.del_if_exist(d0,d1)

  • dict_asgn.del_if_exist_else_add(d0,d1)

  • dict_asgn.del_if_exist_else_add_then_set(d0,d1)

LICENSE

  • ISC

RESTRICT