nvary

nv-array ============ - simple array tools - only install which you needed

Usage no npm install needed!

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

README

nv-array

  • simple array tools
  • only install which you needed

install

all

npm install nvary

splitted

usage

const ary_init = require("nv-array-init")
const ary_bsc = require("nv-array-basic")
const ary_findiv = require("nv-array-findiv")
const ary_findi = require("nv-array-find-index")
const ary_findv = require("nv-array-find-value")
const ary_indexof = require("nv-array-index-of")
const ary_prop = require("nv-array-proposition")
const ary_fpop = require("nv-array-pop-with-function")
const ary_ipop  = require("nv-array-pop-with-index")
const ary_vpop  = require("nv-array-pop-with-value")
const ary_frm = require("nv-array-remove-with-function")
const ary_irm = require("nv-array-remove-with-index")
const ary_vrm = require("nv-array-remove-with-value")
const ary_map = require("nv-array-map")
const ary_sort = require("nv-array-sort")
const ary_fslc  = require("nv-array-slice-with-function")
const ary_vslc = require("nv-array-slice-with-value")
const ary_swap = require("nv-array-swap")
const ary_irplc = require("nv-array-replace-with-index")
const ary_frplc = require("nv-array-replace-with-function")
const ary_vrplc = require("nv-array-replace-with-value")
const ary_grp = require("nv-array-group")
const ary_desc = require("nv-array-desc")
const ary_cll = require("nv-array-collection")
const ary_com = require("nv-array-combo")
const ary_sld = require("nv-array-slide")
const ary_cmp = require("nv-array-compare")
const ary_loc = require("nv-array-location")
const ary_uniq = require("nv-array-uniq")
const ary_trans = require("nv-array-transform")
const ary_span = require("nv-array-span")
const ary_ftrim = require("nv-array-trim-with-function")
const ary_vtrim = require("nv-array-trim-with-value")
const ary_dvd = require("nv-array-divide")
const ary_setter = require("nv-array-setter")
const ary_fast = require("nv-array-fast")
const ary_callable = require("nv-array-callable")
const ary_sec = require("nv-array-section")
const ary_clu = require("nv-array-include")
const ary_mole = require("nv-array-more-less")
const ary_defrag = require("nv-array-defrag")
const ary_sp = require("nv-array-split")
const ary_mch = require("nv-array-match")
const ary_opt = require("nv-array-optional")
const ary_lrq = require("nv-array-lrq")
const ary_op = require("nv-array-oper") 
const ary_rng = require("nv-array-range")
const ary_rdx = require("nv-array-radix")
const ary_fit = require("nv-array-fit")
const ary_lcs = require("nv-array-lcs") 
const ary_vst = require("nv-array-visitor")

API

  • ary_init.use(lngth,v)

  • ary_init.range(si,ei,interval)

  • ary_init.mul(arr,lgth)

  • ary_bsc.head(arr)

  • ary_bsc.tail(arr)

  • ary_bsc.mid(arr)

  • ary_bsc.init(arr)

  • ary_bsc.lst(arr)

  • ary_bsc.some(arr,...whiches)

  • ary_bsc.some_not(arr,...whiches)

  • ary_bsc.clear(arr)

  • ary_bsc.uniform_index(arr,index)

  • ary_bsc.validate_index(arr,index)

  • ary_bsc.validate_value(arr,value)

  • ary_bsc.validate_vi(arr,d) //d = {i:index,v:value}

  • ary_bsc.odd(arr)

  • ary_bsc.even(arr)

  • ary_bsc.interval(arr,interval)

  • ary_bsc.bin(n,lngth,head=true)

  • ary_bsc.eq(arr0,arr1)

  • ary_bsc.combine(...lists)

  • ary_bsc.mid_index_pair(arr)

  • ary_bsc.mid_index_left(arr)

  • ary_bsc.mid_index_right(arr)

  • ary_bsc.mid_value_pair(arr)

  • ary_bsc.mid_value_left(arr)

  • ary_bsc.mid_value_right(arr)

  • ary_findiv.fst(arr,cond_func,...other_params)

  • ary_findiv.fst_not(arr,cond_func,...other_params)

  • ary_findiv.lst(arr,cond_func,...other_params)

  • ary_findiv.fst_not(arr,cond_func,...other_params)

  • ary_findiv.which(arr,which,cond_func,...other_params)

  • ary_findiv.which_not(arr,which,cond_func,...other_params)

  • ary_findiv.which_from_lst(arr,which,cond_func,...other_params)

  • ary_findiv.which_not_from_lst(arr,which,cond_func,...other_params)

  • ary_findiv.some(arr,whiches,cond_func,...other_params)

  • ary_findiv.some_not(arr,whiches,cond_func,...other_params)

  • ary_findiv.some_from_lst(arr,whiches,cond_func,...other_params)

  • ary_findiv.some_not_from_lst(arr,whiches,cond_func,...other_params)

  • ary_findiv.all(arr,cond_func,...other_params)

  • ary_findiv.all_not(arr,cond_func,...other_params)

  • ary_findi.fst(arr,cond_func,...other_params)

  • ary_findi.fst_not(arr,cond_func,...other_params)

  • ary_findi.lst(arr,cond_func,...other_params)

  • ary_findi.fst_not(arr,cond_func,...other_params)

  • ary_findi.which(arr,which,cond_func,...other_params)

  • ary_findi.which_not(arr,which,cond_func,...other_params)

  • ary_findi.which_from_lst(arr,which,cond_func,...other_params)

  • ary_findi.which_not_from_lst(arr,which,cond_func,...other_params)

  • ary_findi.some(arr,whiches,cond_func,...other_params)

  • ary_findi.some_not(arr,whiches,cond_func,...other_params)

  • ary_findi.some_from_lst(arr,whiches,cond_func,...other_params)

  • ary_findi.some_not_from_lst(arr,whiches,cond_func,...other_params)

  • ary_findi.all(arr,cond_func,...other_params)

  • ary_findi.all_not(arr,cond_func,...other_params)

  • ary_findv.fst(arr,cond_func,...other_params)

  • ary_findv.fst_not(arr,cond_func,...other_params)

  • ary_findv.lst(arr,cond_func,...other_params)

  • ary_findv.fst_not(arr,cond_func,...other_params)

  • ary_findv.which(arr,which,cond_func,...other_params)

  • ary_findv.which_not(arr,which,cond_func,...other_params)

  • ary_findv.which_from_lst(arr,which,cond_func,...other_params)

  • ary_findv.which_not_from_lst(arr,which,cond_func,...other_params)

  • ary_findv.some(arr,whiches,cond_func,...other_params)

  • ary_findv.some_not(arr,whiches,cond_func,...other_params)

  • ary_findv.some_from_lst(arr,whiches,cond_func,...other_params)

  • ary_findv.some_not_from_lst(arr,whiches,cond_func,...other_params)

  • ary_findv.all(arr,cond_func,...other_params)

  • ary_findv.all_not(arr,cond_func,...other_params)

  • ary_indexof.fst(arr,value)

  • ary_indexof.lst(arr,value)

  • ary_indexof.which(arr,value,which)

  • ary_indexof.which_from_lst(arr,value,which)

  • ary_indexof.some(arr,value,...whiches)

  • ary_indexof.some_from_lst(arr,value,...whiches)

  • ary_indexof.all(arr,value)

  • ary_prop.all(arr,cond_func,...other_params)

  • ary_prop.every(arr,cond_func,...other_params)

  • ary_prop.all_not(arr,cond_func,...other_params)

  • ary_prop.every_not(arr,cond_func,...other_params)

  • ary_prop.any(arr,cond_func,...other_params)

  • ary_prop.any_not(arr,cond_func,...other_params)

  • ary_prop.at_most_several(arr,n,cond_func,...other_params)

  • ary_prop.at_most_several_not(arr,n,cond_func,...other_params)

  • ary_prop.several(arr,n,cond_func,...other_params)

  • ary_prop.several_not(arr,n,cond_func,...other_params)

  • ary_prop.at_least_several(arr,n,cond_func,...other_params)

  • ary_prop.at_least_several_not(arr,n,cond_func,...other_params)

  • ary_prop.fst(arr,cond_func,...other_params)

  • ary_prop.fst_not(arr,cond_func,...other_params)

  • ary_prop.which(arr,which,cond_func,...other_params)

  • ary_prop.which_not(arr,which,cond_func,...other_params)

  • ary_prop.lst(arr,cond_func,...other_params)

  • ary_prop.lst_not(arr,cond_func,...other_params)

  • ary_prop.at_most_some(arr,whiches,cond_func,...other_params)

  • ary_prop.at_most_some_not(arr,whiches,cond_func,...other_params)

  • ary_prop.some(arr,whiches,cond_func,...other_params)

  • ary_prop.some_not(arr,whiches,cond_func,...other_params)

  • ary_prop.at_least_some(arr,whiches,cond_func,...other_params)

  • ary_prop.at_least_some_not(arr,whiches,cond_func,...other_params)

  • ary_fpop.fst(arr,cond_func,...cond_other_func_params)

  • ary_fpop.fst_not(arr,cond_func,...cond_other_func_params)

  • ary_fpop.which(arr,index,cond_func,...cond_other_func_params)

  • ary_fpop.which_not(arr,index,cond_func,...cond_other_func_params)

  • ary_fpop.which_from_lst(arr,index,cond_func,...cond_other_func_params)

  • ary_fpop.which_not_from_lst(arr,index,cond_func,...cond_other_func_params)

  • ary_fpop.lst(arr,cond_func,...cond_other_func_params)

  • ary_fpop.lst_not(arr,cond_func,...cond_other_func_params)

  • ary_fpop.some(arr,whiches,cond_func,...cond_other_func_params)

  • ary_fpop.some_not(arr,whiches,cond_func,...cond_other_func_params)

  • ary_fpop.some_from_lst(arr,whiches,cond_func,...cond_other_func_params)

  • ary_fpop.some_not_from_lst(arr,whiches,cond_func,...cond_other_func_params)

  • ary_fpop.all(arr,cond_func,...cond_other_func_params)

  • ary_fpop.all_not(arr,cond_func,...cond_other_func_params)

  • ary_ipop(arr,index)

  • ary_vpop.all(arr,value)

  • ary_vpop.all_not(arr,value)

  • ary_vpop.which(arr,value,which)

  • ary_vpop.which_not(arr,value,which)

  • ary_vpop.which_from_lst(arr,value,which)

  • ary_vpop.which_not_from_lst(arr,value,which)

  • ary_vpop.fst(arr,value)

  • ary_vpop.fst_not(arr,value)

  • ary_vpop.lst(arr,value)

  • ary_vpop.lst_not(arr,value)

  • ary_vpop.some(arr,value,...whiches)

  • ary_vpop.some_not(arr,value,...whiches)

  • ary_vpop.some_from_lst(arr,value,...whiches)

  • ary_vpop.some_not_from_lst(arr,value,...whiches)

  • ary_frm.fst(arr,cond_func,...cond_other_func_params)

  • ary_frm.fst_not(arr,cond_func,...cond_other_func_params)

  • ary_frm.which(arr,index,cond_func,...cond_other_func_params)

  • ary_frm.which_not(arr,index,cond_func,...cond_other_func_params)

  • ary_frm.which_from_lst(arr,index,cond_func,...cond_other_func_params)

  • ary_frm.which_not_from_lst(arr,index,cond_func,...cond_other_func_params)

  • ary_frm.lst(arr,cond_func,...cond_other_func_params)

  • ary_frm.lst_not(arr,cond_func,...cond_other_func_params)

  • ary_frm.some(arr,whiches,cond_func,...cond_other_func_params)

  • ary_frm.some_not(arr,whiches,cond_func,...cond_other_func_params)

  • ary_frm.some_from_lst(arr,whiches,cond_func,...cond_other_func_params)

  • ary_frm.some_not_from_lst(arr,whiches,cond_func,...cond_other_func_params)

  • ary_frm.all(arr,cond_func,...cond_other_func_params)

  • ary_frm.all_not(arr,cond_func,...cond_other_func_params)

  • ary_irm(arr,index)

  • ary_vrm.all(arr,value)

  • ary_vrm.all_not(arr,value)

  • ary_vrm.which(arr,value,which)

  • ary_vrm.which_not(arr,value,which)

  • ary_vrm.which_from_lst(arr,value,which)

  • ary_vrm.which_not_from_lst(arr,value,which)

  • ary_vrm.fst(arr,value)

  • ary_vrm.fst_not(arr,value)

  • ary_vrm.lst(arr,value)

  • ary_vrm.lst_not(arr,value)

  • ary_vrm.some(arr,value,...whiches)

  • ary_vrm.some_not(arr,value,...whiches)

  • ary_vrm.some_from_lst(arr,value,...whiches)

  • ary_vrm.some_not_from_lst(arr,value,...whiches)

  • ary_map.fviomap(arr,diff_map_func_arr,diff_other_args_arr)

  • ary_map.fvimap(arr,diff_map_func_arr,...cmmn_other_args)

  • ary_map.fvomap(arr,diff_map_func_arr,diff_other_args_arr)

  • ary_map.fiomap(arr,diff_map_func_arr,diff_other_args_arr)

  • ary_map.viomap(arr,cmmn_map_func,diff_other_args_arr)

  • ary_map.fvmap(arr,diff_map_func_arr,...cmmn_other_args)

  • ary_map.fimap(arr,diff_map_func_arr,...cmmn_other_args)

  • ary_map.fomap(arr,diff_map_func_arr,diff_other_args_arr)

  • ary_map.vimap(arr,cmmn_map_func,...cmmn_other_args)

  • ary_map.vomap(arr,cmmn_map_func,diff_other_args_arr)

  • ary_map.iomap(arr,cmmn_map_func,diff_other_args_arr)

  • ary_map.fmap(arr,diff_map_func_arr,...cmmn_other_args)

  • ary_map.vmap(arr,cmmn_map_func,...cmmn_other_args)

  • ary_map.imap(arr,cmmn_map_func,...cmmn_other_args)

  • ary_map.omap(arr,cmmn_map_func,diff_other_args_arr)

  • ary_sort.num(arr)

  • ary_sort.ref(arr,refer,cmp_func)

  • ary_sort.bat(lists,refer,cmp_func)

  • ary_sort.slice(arr,si,ei,cmp_func)

  • ary_sort.some(arr,whiches,cmp_func)

  • ary_sort.wherev(sorted_arr,v)

  • ary_sort.wherei(sorted_arr,v)

  • ary_sort.lbv(sorted_arr,v)

  • ary_sort.lbi(sorted_arr,v)

  • ary_sort.ubv(sorted_arr,v)

  • ary_sort.ubi(sorted_arr,v)

  • ary_fslc.fst(arr,cond_func,...cond_other_func_params)

  • ary_fslc.fst_not(arr,cond_func,...cond_other_func_params)

  • ary_fslc.which(arr,index,cond_func,...cond_other_func_params)

  • ary_fslc.which_not(arr,index,cond_func,...cond_other_func_params)

  • ary_fslc.which_from_lst(arr,index,cond_func,...cond_other_func_params)

  • ary_fslc.which_not_from_lst(arr,index,cond_func,...cond_other_func_params)

  • ary_fslc.lst(arr,cond_func,...cond_other_func_params)

  • ary_fslc.lst_not(arr,cond_func,...cond_other_func_params)

  • ary_fslc.some(arr,whiches,cond_func,...cond_other_func_params)

  • ary_fslc.some_not(arr,whiches,cond_func,...cond_other_func_params)

  • ary_fslc.some_from_lst(arr,whiches,cond_func,...cond_other_func_params)

  • ary_fslc.some_not_from_lst(arr,whiches,cond_func,...cond_other_func_params)

  • ary_fslc.all(arr,cond_func,...cond_other_func_params)

  • ary_fslc.all_not(arr,cond_func,...cond_other_func_params)

  • ary_vslc.fst(arr,v)

  • ary_vslc.fst_not(arr,v)

  • ary_vslc.which(arr,v,index)

  • ary_vslc.which_not(arr,v,index)

  • ary_vslc.which_from_lst(arr,v,index)

  • ary_vslc.which_not_from_lst(arr,v,index)

  • ary_vslc.lst(arr,v)

  • ary_vslc.lst_not(arr,v)

  • ary_vslc.some(arr,v,...whiches)

  • ary_vslc.some_not(arr,v,...whiches)

  • ary_vslc.some_from_lst(arr,v,...whiches)

  • ary_vslc.some_not_from_lst(arr,...whiches)

  • ary_vslc.all(arr,v)

  • ary_vslc.all_not(arr,v)

  • ary_swap.iswap(arr,i0,i1)

  • ary_swap.vswap(arr,v0,v1)

  • ary_swap.viswap(arr,d0,d1) // d={i:index,v:value}

  • ary_swap.reindex(arr,...whiches)

  • ary_irplc(arr,replace_by,...indexes)

  • ary_frplc.fst(arr,rplc_by,cond_func,...cond_other_func_params)

  • ary_frplc.fst_not(arr,rplc_by,cond_func,...cond_other_func_params)

  • ary_frplc.which(arr,rplc_by,index,cond_func,...cond_other_func_params)

  • ary_frplc.which_not(arr,rplc_by,index,cond_func,...cond_other_func_params)

  • ary_frplc.which_from_lst(arr,rplc_by,index,cond_func,...cond_other_func_params)

  • ary_frplc.which_not_from_lst(arr,rplc_by,index,cond_func,...cond_other_func_params)

  • ary_frplc.lst(arr,rplc_by,cond_func,...cond_other_func_params)

  • ary_frplc.lst_not(arr,rplc_by,cond_func,...cond_other_func_params)

  • ary_frplc.some(arr,rplc_by,whiches,cond_func,...cond_other_func_params)

  • ary_frplc.some_not(arr,rplc_by,whiches,cond_func,...cond_other_func_params)

  • ary_frplc.some_from_lst(arr,rplc_by,whiches,cond_func,...cond_other_func_params)

  • ary_frplc.some_not_from_lst(arr,rplc_by,whiches,cond_func,...cond_other_func_params)

  • ary_frplc.all(arr,rplc_by,cond_func,...cond_other_func_params)

  • ary_frplc.all_not(arr,rplc_by,cond_func,...cond_other_func_params)

  • ary_vrplc.all(arr,rplc_by,value)

  • ary_vrplc.all_not(arr,rplc_by,value)

  • ary_vrplc.which(arr,rplc_by,value,which)

  • ary_vrplc.which_not(arr,rplc_by,value,which)

  • ary_vrplc.which_from_lst(arr,rplc_by,value,which)

  • ary_vrplc.which_not_from_lst(arr,rplc_by,value,which)

  • ary_vrplc.fst(arr,rplc_by,value)

  • ary_vrplc.fst_not(arr,rplc_by,value)

  • ary_vrplc.lst(arr,rplc_by,value)

  • ary_vrplc.lst_not(arr,rplc_by,value)

  • ary_vrplc.some(arr,rplc_by,value,...whiches)

  • ary_vrplc.some_not(arr,rplc_by,value,...whiches)

  • ary_vrplc.some_from_lst(arr,rplc_by,value,...whiches)

  • ary_vrplc.some_not_from_lst(arr,rplc_by,value,...whiches)

  • ary_grp.fgrpvi(arr,func,...func_params)

  • ary_grp.fgrpi(arr,func,...func_params)

  • ary_grp.fgrpv(arr,func,...func_params)

  • ary_grp.vgrpvi(arr,...func_params)

  • ary_grp.vgrpi(arr,...func_params)

  • ary_grp.vgrpv(arr,...func_params)

  • ary_grp.lgrpvi(arr)

  • ary_grp.lgrpi(arr)

  • ary_grp.lgrpv(arr)

  • ary_vldict(arr)

  • ary_vidict(arr)

  • ary_ivdict(arr)

  • ary_mdict(arr,pri_key="i")

  • ary_cll.union(arr0,arr1)

  • ary_cll.diff(arr0,arr1)

  • ary_cll.inter(arr0,arr1)

  • ary_cll.align(arr0,arr1)

  • ary_com.comb(arr)

  • ary_com.perm(arr)

  • ary_sld.slide_from_fst(basearr,slider)

  • ary_sld.slide_from_lst(basearr,slider)

  • ary_sld.has(basearr,slider)

  • ary_cmp.samei(arr0,arr1)

  • ary_cmp.samev(arr0,arr1)

  • ary_cmp.samevi(arr0,arr1)

  • ary_cmp.diffi(arr0,arr1)

  • ary_cmp.diffv(arr0,arr1)

  • ary_cmp.diffvi(arr0,arr1)

  • ary_loc.fst(basearr,slider)

  • ary_loc.which(basearr,slider,1)

  • ary_loc.which_from_lst(basearr,slider,0)

  • ary_loc.lst(basearr,slider)

  • ary_loc.some(basearr,slider,0,1)

  • ary_loc.some_from_lst(basearr,slider,0,1)

  • ary_loc.all(basearr,slider)

  • ary_uniq.uniq(arr,until=Infinity)

  • ary_uniq.recycle(arr,until=Infinity)

  • ary_uniq.ref_uniq(arr,ref,until=Infinity)

  • ary_uniq.ref_recycle(arr,ref,until=Infinity)

  • ary_trans.dummy

  • ary_trans.fmt(...lists)

  • ary_trans.transpose(m)

  • ary_trans.interleave(...lists)

  • ary_trans.mat(arr,n)

  • ary_trans.uninterleave(arr,n)

  • ary_span.pair(arr)

  • ary_span.interval(arr,interval)

  • ary_span.range(max_length,...indexes)

  • ary_span.fullfill(spans)

  • ary_span.supplement(spans)

  • ary_span.compress(arr)

  • ary_span.uncompress(spans)

  • ary_ftrim.left(arr,n,cond_func,...cond_func_params)

  • ary_ftrim.right(arr,n,cond_func,...cond_func_params)

  • ary_ftrim.both(arr,n,cond_func,...cond_func_params)

  • ary_ftrim.lall(arr,cond_func,...cond_func_params)

  • ary_ftrim.rall(arr,cond_func,...cond_func_params)

  • ary_ftrim.ball(arr,cond_func,...cond_func_params)

  • ary_vtrim.left(arr,value,n)

  • ary_vtrim.right(arr,value,n)

  • ary_vtrim.both(arr,value,n)

  • ary_vtrim.lall(arr,value)

  • ary_vtrim.rall(arr,value)

  • ary_vtrim.ball(arr,value)

  • ary_dvd.chunk(arr,interval)

  • ary_dvd.cut(arr,...pts)

  • ary_setter.interval(arr,start,interval,val)

  • ary_setter.odd(arr,val)

  • ary_setter.even(arr,val)

  • ary_setter.all(arr,val)

  • ary_setter.some(arr,val,...whiches)

  • ary_setter.some_not(arr,val,...whiches)

  • ary_setter.filter_map(arr,val_map_func,index_cond_func,...other_args)

  • ary_setter.filter(arr,val,index_cond_func,...other_args)

  • ary_setter.ifilter(arr,val,index_cond_func,...other_args)

  • ary_setter.vfilter(arr,val,index_cond_func,...other_args)

  • ary_fast.ipop(arr,index);

  • ary_fast.concat(arr0,arr1);

  • ary_fast.splice(arr,index,delete_count,push_arr)

  • ary_fast.fst_index_of(arr,v)

  • ary_callable.creat_carr(f);

  • ary_sec.merge(arr,si,ei)

  • ary_sec.get_sec_with_num(arr,n)

  • ary_sec.get_sec_with_seq(arr,seq)

  • ary_sec.get_seq_with_sec(arr,sec)

  • ary_clu.start_with(arr,l)

  • ary_clu.end_with(arr,l)

  • ary_clu.strict_include(arr,l)

  • ary_clu.loose_include(arr,l)

  • ary_mole.from_fst(ary)

  • ary_mole.from_lst(ary)

  • ary_mole.more_less(ary,start=0)

  • more(offset=1)

  • current()

  • less(offset=1)

  • ary_defrag.defrag(arr,empty=undefined)

  • ary_defrag.defrag_with_st(arr,empty_set,empty=undefined)

  • ary_sp.all(arr,sps)

  • ary_sp.cond(arr,sps)

  • ary_sp.slc(arr,sps)

  • ary_sp.rng(arr,sps)

  • ary_sp.join(arr,sps,delimeter='')

  • ary_mch.po_all_pos(data:Array,matches:Array):Array<Array>

  • ary_mch.po_all_match(data:Array,matches:Array):Array<Array>

  • ary_mch.po_gen_pos(data:Array,matches:Array):Generator

  • ary_mch.po_gen_match(data:Array,matches:Array):Generator

  • ary_mch.po_is_match(data:Array,matches:Array):Boolean

  • ary_opt.gen_ordered(ary,opt_idxs,with_placeholder=false,placeholder=null)

  • ary_opt.ordered(ary,opt_idxs,with_placeholder=false,placeholder=null)

  • ary_opt.gen_unordered(ary,opt_idxs,with_placeholder=false,placeholder=null)

  • ary_opt.unordered(ary,opt_idxs,with_placeholder=false,placeholder=null)

  • ary_lrq.parse(ary,cfg)

LICENSE

  • ISC