36 lines
1.8 KiB
TypeScript
36 lines
1.8 KiB
TypeScript
/**
|
|
* Computes the difference between two arrays after mapping their elements through a provided function.
|
|
*
|
|
* This function takes two arrays and a mapper function. It returns a new array containing the elements
|
|
* that are present in the first array but not in the second array, based on the identity calculated
|
|
* by the mapper function.
|
|
*
|
|
* Essentially, it filters out any elements from the first array that, when
|
|
* mapped, match an element in the mapped version of the second array.
|
|
*
|
|
* @template T, U
|
|
* @param {T[]} firstArr - The primary array from which to derive the difference.
|
|
* @param {U[]} secondArr - The array containing elements to be excluded from the first array.
|
|
* @param {(value: T | U) => unknown} mapper - The function to map the elements of both arrays. This function
|
|
* is applied to each element in both arrays, and the comparison is made based on the mapped values.
|
|
* @returns {T[]} A new array containing the elements from the first array that do not have a corresponding
|
|
* mapped identity in the second array.
|
|
*
|
|
* @example
|
|
* const array1 = [{ id: 1 }, { id: 2 }, { id: 3 }];
|
|
* const array2 = [{ id: 2 }, { id: 4 }];
|
|
* const mapper = item => item.id;
|
|
* const result = differenceBy(array1, array2, mapper);
|
|
* // result will be [{ id: 1 }, { id: 3 }] since the elements with id 2 are in both arrays and are excluded from the result.
|
|
*
|
|
* @example
|
|
* const array1 = [{ id: 1 }, { id: 2 }, { id: 3 }];
|
|
* const array2 = [2, 4];
|
|
* const mapper = item => (typeof item === 'object' ? item.id : item);
|
|
* const result = differenceBy(array1, array2, mapper);
|
|
* // result will be [{ id: 1 }, { id: 3 }] since 2 is present in both arrays after mapping, and is excluded from the result.
|
|
*/
|
|
declare function differenceBy<T, U>(firstArr: readonly T[], secondArr: readonly U[], mapper: (value: T | U) => unknown): T[];
|
|
|
|
export { differenceBy };
|