com-tools/dist/array.d.ts

com-tools 提供了一些通用的工具函数；

export type TestFun<Value> = (a: Value, b: Value) => any;
export type ArrayCallbackFun<ThisValue, Value, ReturnType> = (this: ThisValue, value: Value, index: number, array: Value[]) => ReturnType;
/**
 * 移动数组的元素，会改变原数组
 * @remarks
 * 将数组中的元素 从 from 移动到 to
 * @param arr
 * @param from
 * @param to
 * @returns 原数组对象
 */
export declare function moveItemInArray<Item>(arr: Item[], from: number, to: number): Item[];
/**
 * 移动数组的元素，不改变原数组
 * @remarks
 * 将数组中的元素 从 from 移动到 to
 * @param arr
 * @param from
 * @param to
 * @returns 新的数组
 */
export declare function moveItemInNewArray<Item>(arr: Item[], from: number, to: number): Item[];
/**
 * 批量移动数组的元素，会改变原数组
 * @remarks
 * 将数组中的元素 从 from 移动到 to
 * from 与 to 中的索引一一对应
 * @param arr
 * @param froms
 * @param tos
 * @returns 原数组对象
 */
export declare function moveItemsInArray<Item>(arr: Item[], froms: number[], tos: number[]): Item[];
/**
 * 在新数组中批量移动数组的元素，不会改变原数组
 * @remarks
 * 将数组中的元素 从 from 移动到 to
 * from 与 to 中的索引一一对应
 *
 * 该方法会比 moveItemsInArray 性能更高一些
 * @param arr
 * @param froms
 * @param tos
 * @returns 新数组
 */
export declare function moveItemsInNewArray<Item>(arr: Item[], froms: number[], tos: number[]): Item[];
/**
 * 将可迭代的对象转成 JSON 数组片断
 * @param items
 * @param space
 * @returns
 */
export declare function toJSONArrayFragment(items: Iterable<any>, space?: string | number): string;
/**
 * 将 项目转成 JSON 的数组中的 item 片断
 * @param item
 * @param space
 * @param itemSeparator - 两个 item 之间的分隔符；默认情况下，如果 space 有值且不为0，则 itemSeparator 默认为 \n 否则 为 空
 * @returns
 */
export declare function toJSONItemFragment(item: any, space?: string | number, itemSeparator?: string): string;
/**
 * array_safelyOperateIndexs(indexList, operation, thisValue)
 * 安全操作指定的索引
 * @param indexList : [Index]   需要被操作的索引数组
 * @param operation : (currentValue,currentIndex,currentArray)=>Void     执行的操作
 * @param thisValue ? : any   可选，默认值是被操作的数组，即调用者；操作 operation 的 this 值
 * @returns [Item]   被操作的元素列表
 *
 *
 * operation(currentValue,currentIndex,currentArray)=>Void
 * @param currentValue : any   调用 operation 时的元素的值；
 * @param currentIndex : number     调用 operation 时 currentValue 对应的最新状态的索引值；
 * @param currentArray : Array   调用 operation 时 被操作时最新状态的数组；
 *
 */
export declare function array_safelyOperateIndexs<T, ThisValue = T[]>(array: T[], indexList: number[], operation: ArrayCallbackFun<ThisValue, T, void>, thisValue?: ThisValue): T[];
/**
 * array_safelyOperateItems(itemList, operation, thisValue)
 * 安全操作指定的元素
 * @param itemList : [Item]   需要被操作的元素的数组
 * @param operation : (currentValue,currentIndex,currentArray)=>Void     执行的操作
 * @param thisValue ? : any   可选，默认值是被操作的数组，即调用者；操作 operation 的 this 值
 * @returns [Index]   被操作的元素的索引的列表；
 *
 *
 * operation(currentValue,currentIndex,currentArray)=>Void
 * @param currentValue : any   调用 operation 时的元素的值；
 * @param currentIndex : number     调用 operation 时 currentValue 对应的最新状态的索引值；
 * @param currentArray : Array   调用 operation 时 被操作时最新状态的数组；
 *
 */
export declare function array_safelyOperateItems<T, ThisValue = T[]>(array: T[], itemList: T[], operation: ArrayCallbackFun<ThisValue, T, void>, thisValue?: ThisValue): number[];
/**
 * array_safelyFilter(operation, thisValue)
 * 安全地操作并过滤所有元素；与 forEach 和 filter 的区别是： safelyFilter 能保证会遍历数组中所有已存在的元素，不会受 operation 中的行为的影响；
 * @param operation : (currentValue,currentIndex,currentArray)=>boolean | undefined     执行的操作， 该函数的返回值表示是否要过滤出该元素
 * @param thisValue ? : any   可选，默认值是被操作的数组，即调用者；操作 operation 的 this 值
 * @returns [Item]  返回被 operation 过滤出的元素
 *
 *
 * operation(currentValue,currentIndex,currentArray)=>boolean | undefined
 * @param currentValue : any   调用 operation 时的元素的值；
 * @param currentIndex : number     调用 operation 时 currentValue 对应的最新状态的索引值；
 * @param currentArray : Array   调用 operation 时 被操作时最新状态的数组；
 * @returns boolean | undefined  表示是否要过滤出 currentValue ；
 *
 */
export declare function array_safelyFilter<T, ThisValue = T[]>(array: T[], operation: ArrayCallbackFun<ThisValue, T, any>, thisValue?: ThisValue): T[];
/**
 * move(fromIndex, toIndex, length = 1)
 * 根据索引移动数组的元素
 * @param fromIndex : number   被移动的元素的开始索引
 * @param toIndex : number    元素被移动到的新位置的索引
 * @param length ? : number   可选，默认值：1 ； 被移动的元素的长度；
 * @returns Array   被移动的元素的数组
 */
export declare function array_move<T>(array: T[], fromIndex: number, toIndex: number, length?: number): T[];
/**
 * moveTo(toIndex, ...fromIndexs)
 * 根据索引批量移动数组的元素
 * @param toIndex : number    元素被移动到的新位置的索引
 * @param fromIndex : number   被移动的元素的索引
 * @returns Array<Item>   被移动的元素的数组
 */
export declare function array_moveTo<T>(array: T[], toIndex: number, ...fromIndexs: number[]): T[];
/**
 * moveItemsTo(toIndex, ...items)
 * 批量移动数组的指定元素
 * @param toIndex : number    元素被移动到的新位置的索引
 * @param item : any   被移动的元素
 * @returns Array<number>   被移动的元素的索引的数组
 */
export declare function array_moveItemsTo<T>(array: T[], toIndex: number, ...items: T[]): number[];
/**
 * moveToUseTest(toIndex, needMoveTest)
 * 根据测试函数批量移动数组的元素
 * @param toIndex : number    元素被移动到的新位置的索引
 * @param needMoveTest : (currentValue,index,arr)=>boolean    测试数组元素是否需要被移动的函数，返回 boolean 值，表示当前元素 currentValue 是否需要被移动；
 * @returns Array<Item>   被移动的元素的数组
 */
export declare function array_moveToUseTest<T, ThisValue = T[]>(array: T[], toIndex: number, needMoveTest: ArrayCallbackFun<ThisValue, T, any>, thisValue?: ThisValue): T[];
/**
 * insertItem(item, toIndex = 0, equalTest)
 * 将指定元素插入到调用者数组中指定索引处，并且会删除调用者数组中与 item 相同的元素
 * @param item : any    被插入的元素
 * @param toIndex : number    元素被插入到的位置的索引
 * @param equalTest ? : (a,b)=>boolean    可选， 默认是通过全等 === 来判断元素是否相等的；测试数组元素是否相同的函数，返回 boolean 值，表示 元素a 和 元素b  相同；
 * @returns Array<Item>   被删除的元素
 */
export declare function array_insertItem<T>(array: T[], item: T, toIndex?: number, equalTest?: TestFun<T>): T[];
/**
 * insertItemList(itemList, toIndex = 0, equalTest)
 * 将指定数组itemList中的元素插入到调用者数组的指定索引处，并且会删除调用者数组中 与 itemList中元素 相同的元素
 * @param itemList : [any]    被插入的元素数组
 * @param toIndex ? : number    可靠；默认值：0 ； 元素被插入到的位置的索引；
 * @param equalTest ? : (a,b)=>boolean    可选， 默认是通过全等 === 来判断元素是否相等的；测试数组元素是否相同的函数，返回 boolean 值，表示 元素a 和 元素b  相同；
 * @returns Array<Item>   被删除的元素
 */
export declare function array_insertItemList<T>(array: T[], itemList: T[], toIndex?: number, equalTest?: TestFun<T>): T[];
/**
 * delete(start, end)
 * 根据索引删除数组的元素
 * @param start : number   被删除的元素的开始索引
 * @param end ? : number   可选，默认值：start ； 被删除的元素的结束索引；
 * @returns Array   被删除的元素的数组
 */
/**
 * delete(start, end)
 * 根据索引删除数组的元素
 * @param start : number   被删除的元素的开始索引
 * @param end ? : number   可选，默认值：start ； 被删除的元素的结束索引；
 * @returns Array   被删除的元素的数组
 */
export declare function array_delete<T>(array: T[], start: number, end?: number): T[];
/**
 * deleteIndexs(...indexs)
 * 删除数组中指定的元素
 * @param index : number   被删除的元素的索引
 * @returns Array<Item>   被删除的元素的数组
 */
export declare function array_deleteIndexs<T>(array: T[], ...indexs: number[]): T[];
/**
 * deleteItems(...items)
 * 删除数组中指定的元素
 * @param item : any   被删除的元素
 * @returns Array<number>   被删除的元素的索引数组
 */
export declare function array_deleteItems<T>(array: T[], ...items: T[]): number[];
/**
 * deleteUseTest(needDeleteTest)
 * 根据测试函数批量删除数组的元素
 * @param needDeleteTest : (currentValue,index,arr)=>boolean    测试数组元素是否需要被删除的函数，返回 boolean 值，表示当前元素 currentValue 是否需要被删除；
 * @returns Array<Item>   被删除的元素的数组
 */
export declare function array_deleteUseTest<T, ThisValue = T[]>(array: T[], needDeleteTest: ArrayCallbackFun<ThisValue, T, any>, thisValue?: ThisValue): T[];
/**
 * filterIndexs(filterTest,thisArg)
 * 该方法创建一个新的数组，新数组中的元素是通过检查指定数组中符合条件的所有元素的索引。
 * @param filterTest : (currentValue,index,arr)=>boolean    用来测试数组的每个元素的函数。调用时使用参数 (currentValue,index,arr)。返回true表示保留该元素（通过测试），false则不保留
 * @param thisArg ? : any 可选。执行 callback 时的用于 this 的值。
 * @returns Array<Index>   通过测试的元素的索引
 */
export declare function array_filterIndexs<T, ThisValue = T[]>(array: T[], filterTest: ArrayCallbackFun<ThisValue, T, any>, thisValue?: ThisValue): number[];
/**
 * 比较两个数组是否相等
 * @remarks
 * 两个数组相等的充要条件是：
 * 元素个数相等 且 元素顺序相等
 * @param arr1
 * @param arr2
 * @param equalTest
 * @returns
 */
export declare function array_isEqual<T>(arr1: T[], arr2: T[], equalTest?: TestFun<T>): boolean;
//# sourceMappingURL=array.d.ts.map