30-seconds-of-code-Array-学习七

原始地址：https://github.com/30-seconds…

sample

随机返回给定数组中的元素。

使用 Math.random() 生成一个 0 ~ 1 之间的随机数，然后乘以数组的长度可以得到和数组索引接近的随机数，最后使用 Math.floor() 对随机数向下取整可得到最后结果的索引。

const sample = arr => arr[Math.floor(Math.random() * arr.length)];

// example
sample([3, 7, 9, 11]); // 9

sampleSize

返回给定数组中的 n 个值。

使用洗牌算法对数组的元素进行混洗。使用 Array.prototype.slice() 截取数组中的前 n 的元素作为最后的结果。

const sampleSize = ([...arr], n = 1) => {
    let m = arr.length;·
    while (m) {const i = Math.floor(Math.random() * m--);
        [arr[m], arr[i]] = [arr[i], arr[m]];
    }
    return arr.slice(0, n);
};

// example
sampleSize([1, 2, 3], 2); // [3,1]
sampleSize([1, 2, 3], 4); // [2,3,1]

shank

具有与 Array.prototype.splice() 相同的功能，但返回一个新数组而不是改变原始数组。

使用 Array.prototype.slice() 获取指定索引之内的数组，使用 Array.prototype.concat() 将截取到的数组与给定的元素拼接到一起，然后使用 Array.prototype.slice() 截取被移除的最后元素索引到结束位置，最后再使用 Array.prototype.concat() 进行拼接。

const shank = (arr, index = 0, delCount = 0, ...elements) =>
    arr
        .slice(0, index)
        .concat(elements)
        .concat(arr.slice(index + delCount));

// own understand
const shank = (arr, index = 0, delCount = 0, ...elements) => {return [...arr.slice(0, index), ...elements, ...arr.slice(index + delCount)];
};

// example
const names = ['alpha', 'bravo', 'charlie'];
const namesAndDelta = shank(names, 1, 0, 'delta'); // ['alpha', 'delta', 'bravo', 'charlie']
const namesNoBravo = shank(names, 1, 1); // ['alpha', 'charlie']
console.log(names); // ['alpha', 'bravo', 'charlie']

shuffle

随机化给定数组中的元素顺序，返回一个新的数组。使用洗牌算法重新排序数组中的数据。

const shuffle = ([...arr]) => {
    let m = arr.length;
    while (m) {const i = Math.floor(Math.random() * m--);
        [arr[m], arr[i]] = [arr[i], arr[m]];
    }
    return arr;
};

// example
shuffle([1, 2, 3]); // [2, 3, 1]

similarity

对两个数组进行取交集。

使用 Array.prototype.filter() 对数据进行过滤，使用 Array.prototype.includes() 校验数组的元素是否存在另一个数组。

const similarity = (arr, values) => arr.filter(v => values.includes(v));

// example
similarity([1, 2, 3], [1, 2, 4]); // [1, 2]

sortedIndex

返回将值插入已排序数组的最低索引，以便不影响其顺序。

首先需要校验数组是升序或降序，使用 Array.prototype.findIndex() 从数组中找出给定值插入的索引。

const sortedIndex = (arr, n) => {
    // 判断升序、降序
    const isDescending = arr[0] > arr[arr.length - 1];
    const index = arr.findIndex(el => (isDescending ? n >= el : n <= el));
    return index === -1 ? arr.length : index;
};

// example
sortedIndex([5, 3, 2, 1], 4); // 1
sortedIndex([30, 50], 40); // 1

sortedIndexBy

将值插入已排序数组的最低索引，以便不影响其应用给定迭代器函数后的顺序。

首先需要校验数组是升序或降序，然后对给定的值使用迭代器函数，使用 Array.prototype.findIndex() 从数组中找出给定值使用迭代器函数后得到的值插入的索引。

const sortedIndexBy = (arr, n, fn) => {const isDescending = fn(arr[0]) > fn(arr[arr.length - 1]);
    const val = fn(n);
    const index = arr.findIndex(el => (isDescending ? val >= fn(el) : val <= fn(el)));
    return index === -1 ? arr.length : index;
};

// example
sortedIndexBy([{x: 4}, {x: 5}], {x: 4}, o => o.x); // 0

sortedLastIndex

返回将值插入已排序数组的最高索引，以便不影响其顺序。

首先需要校验数组是升序或降序，使用 Array.prototype.reverse() 对数组的元素进行倒序排列，然后使用 Array.prototype.findIndex() 从数组中找出给定值插入的索引。

const sortedLastIndex = (arr, n) => {const isDescending = arr[0] > arr[arr.length - 1];
    const index = arr.reverse().findIndex(el => (isDescending ? n <= el : n >= el));
    return index === -1 ? 0 : arr.length - index;
};

// example
sortedLastIndex([10, 20, 30, 30, 40], 30); // 4

sortedLastIndexBy

将值插入已排序数组的最高索引，以便不影响其应用给定迭代器函数后的顺序。

首先需要校验数组是升序或降序，然后对给定的值使用迭代器函数，使用 Array.prototype.map() 对数组中的元素应用迭代器函数获取新的数组，然后使用 Array.prototype.reverse() 反转数组，最后使用 Array.prototype.findIndex() 找出数组给定给定值使用迭代器函数后得到的值插入的索引。

const sortedLastIndexBy = (arr, n, fn) => {const isDescending = fn(arr[0]) > fn(arr[arr.length - 1]);
    const val = fn(n);
    const index = arr
        .map(fn)
        .reverse()
        .findIndex(el => (isDescending ? val <= el : val >= el));
    return index === -1 ? 0 : arr.length - index;
};

// example
sortedLastIndexBy([{x: 4}, {x: 5}], {x: 4}, o => o.x); // 1

stableSort

对数组执行稳定排序，值相同的时候使用索引进行排序，这个方法不改变原始数组，而是返回一个新数组。

使用 Array.prototype.map() 获取出数组的值和索引，使用 Array.prototype.sort() 对数组使用比较器函数进行排序，最后对排序后的数组使用 Array.prototype.map() 获取出数组的值。

const stableSort = (arr, compare) =>
    arr
        .map((item, index) => ({item, index}))
        .sort((a, b) => compare(a.item, b.item) || a.index - b.index)
        .map(({item}) => item);

// example
const arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
const stable = stableSort([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10], () => 0); // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]