GitHub

@liuli-util/array

Install using

npm install @liuli-util/array

Exported Members

You can access these members by importing the module:

import { member } from '@liuli-util/array';

diffBy

function diffBy < L , R > (
   left : L[] ,
   right : R[] ,
   kFn : (item: L | R, index: number, arr: L[] | R[]) => any = (v) => v
) : ArrayDiff<L, R>

比较两个数组的差异

@param:

left 第一个数组

@param:

right 第二个数组

@param:

kFn 每个元素的唯一标识产生函数

@returns:

比较的差异结果

ArrayDiff

interface ArrayDiff < L , R >

数组之间的差异结果对象结构接口 left 第一个数组独有的元素列表 right 第二个数组独有的元素列表 common 两个数组共有的元素列表。注意: 这里的元素实质上是从第一个集合获取的

Properties

left

Type: L[]

No docs provided

right

Type: R[]

No docs provided

common

Type: L[]

No docs provided

groupBy

function undefined < T , K > (
   arr : T[] ,
   kFn : (item: T, index: number, arr: T[]) => K
) : Map<K, T[]>

将数组按照指定条件分组

@param:

arr 数组

@param:

kFn 元素分组的唯一标识函数,会将返回 key 作为键,将相同 key 的元素归类为一个数组作为值 注:这里不再包含 reduce 的功能,仅实现分组功能

function undefined < T , K , R : any[] > (
   arr : T[] ,
   kFn : (item: T, index: number, arr: T[]) => K ,
   vFn : (res: R, item: T, index: number, arr: T[]) => R
) : Map<K, R>

将数组按照指定条件分组

@param:

arr 要进行分组的数组

@param:

kFn 元素分组的唯一标识函数,会将返回 key 作为键,将相同 key 的元素归类为一个数组作为值

@param:

vFn 元素分组的值处理的函数。第一个参数是累计值,第二个参数是当前正在迭代的元素,如果你使用过 Array#reduce 函数的话应该对此很熟悉

@returns:

元素标识 => 数组映射 Map

function groupBy < T , K , R > (
   arr : T[] ,
   kFn : (item: T, index: number, arr: T[]) => K ,
   vFn : (res: R[], item: T, index: number, arr: T[]) => R[] = (res, item) => { res.push(item as any) return res }
) : Map<K, R[]>

No docs provided

segmentation

function segmentation < T > (
   arr : T[] ,
   num : number
) : T[][]

数组按照指定长度进行分段为二维数组 注: num 必须要大于 1

@param:

arr 要进行分段的数组

@param:

num 每段的长度

@returns:

分段后的二维数组

swap

function swap < T > (
   arr : T[] ,
   i : number ,
   k : number
) : T[]

交换数组两个位置的值

@param:

arr 数组

@param:

i 第一个下标

@param:

k 第二个下标

@returns:

交换后的数组

uniqueBy

function uniqueBy < T , K > (
   arr : T[] ,
   kFn : (item: T, index: number, arr: T[]) => K = (v) => v as any
) : T[]

js 的数组去重方法

@param:

arr 要进行去重的数组

@param:

kFn 唯一标识元素的方法,默认返回自身

@returns:

进行去重操作之后得到的新的数组 (原数组并未改变)

arrayToMap

function undefined < T , K > (
   arr : T[] ,
   kFn : (item: T, index: number, arr: T[]) => K
) : Map<K, T>

No docs provided

function undefined < T , K , V > (
   arr : T[] ,
   kFn : (item: T, index: number, arr: T[]) => K ,
   vFn : (item: T, index: number, arr: T[]) => V
) : Map<K, V>

No docs provided

function arrayToMap < T , K , V > (
   arr : T[] ,
   kFn : (item: T, index: number, arr: T[]) => K ,
   vFn : (item: T, index: number, arr: T[]) => V = (v) => v as any
) : Map<K, V>

将数组映射为 Map

@param:

arr 数组

@param:

kFn 产生 Map 元素唯一标识的函数

@param:

vFn 产生 Map 值的函数,默认为返回数组的元素

@returns:

映射产生的 map 集合

sortBy

function undefined < T : CompareType > (
   i : T[] ,
   kFn ? : (item: T, index: number, arr: T[]) => CompareType
) : T[]

No docs provided

function undefined < T : Exclude<any, CompareType> > (
   i : T[] ,
   kFn : (item: T, index: number, arr: T[]) => CompareType
) : T[]

No docs provided

function sortBy < T > (
   arr : T[] ,
   kFn : (item: T, index: number, arr: T[]) => CompareType = (v) => (v as unknown) as CompareType
) : T[]

对数组进行排序

@param:

arr 需要排序的数组

@param:

kFn 比较函数,默认是原值