30-seconds-of-code-Zh-CN

你可以在30秒或更短的时间内理解的有用的javascript片段的精选集。

• 使用 Ctrl + F or command + F 来搜索一个片段.
• 您可以在本页面全览所有代码，也可以点击下面的目录到对应的子界面。

目录

🔌 Adapter

📚 Array

🌐 Browser

⏱️ Date

🎛️ Function

➗ Math

📦 Node

🗃️ Object

📜 String

📃 Type

🔧 Utility

🔌 Adapter

ary

创建一个可以接收n个参数的函数, 忽略其他额外的参数。

调用提供的函数fn,参数最多为n个, 使用 Array.prototype.slice(0,n) 和展开操作符 (...)。

const ary = (fn, n) => (...args) => fn(...args.slice(0, n));

const firstTwoMax = ary(Math.max, 2);
[[2, 6, 'a'], [8, 4, 6], [10]].map(x => firstTwoMax(...x)); // [6, 8, 10]

⬆ 回到顶部

call

给定一个key和一组参数，给定一个上下文时调用它们。主要用于合并。

使用闭包调用上下文中key对应的值，�即带有存储参数的函数。

const call = (key, ...args) => context => context[key](...args);

Promise.resolve([1, 2, 3])
  .then(call('map', x => 2 * x))
  .then(console.log); // [ 2, 4, 6 ]
const map = call.bind(null, 'map');
Promise.resolve([1, 2, 3])
  .then(map(x => 2 * x))
  .then(console.log); // [ 2, 4, 6 ]

⬆ 回到顶部

collectInto

将一个接收数组参数的函数改变为可变参数的函数。

给定一个函数，返回一个闭包，该闭包将所有输入收集到一个数组接受函数中。

const collectInto = fn => (...args) => fn(args);

const Pall = collectInto(Promise.all.bind(Promise));
let p1 = Promise.resolve(1);
let p2 = Promise.resolve(2);
let p3 = new Promise(resolve => setTimeout(resolve, 2000, 3));
Pall(p1, p2, p3).then(console.log); // [1, 2, 3] (after about 2 seconds)

⬆ 回到顶部

flip

�Flip以一个函数作为参数，然后把第一个参数作为最后一个参数。

返回一个可变参数的闭包，在应用其他参数前，先把第一个以外的其他参数作为第一个参数。

const flip = fn => (first, ...rest) => fn(...rest, first);

let a = { name: 'John Smith' };
let b = {};
const mergeFrom = flip(Object.assign);
let mergePerson = mergeFrom.bind(null, a);
mergePerson(b); // == b
b = {};
Object.assign(b, a); // == b

⬆ 回到顶部

over

创建一个函数，这个函数可以调用每一个被传入的并且才有参数的函数，然后返回结果。

使用 Array.prototype.map() 和 Function.prototype.apply()将每个函数应用给定的参数。

const over = (...fns) => (...args) => fns.map(fn => fn.apply(null, args));

const minMax = over(Math.min, Math.max);
minMax(1, 2, 3, 4, 5); // [1,5]

⬆ 回到顶部

overArgs

创建一个函数，它可以调用提供的被转换参数的函数。

使用Array.prototype.map()将transforms应用于args，并结合扩展运算符(…)将转换后的参数传递给fn。

const overArgs = (fn, transforms) => (...args) => fn(...args.map((val, i) => transforms[i](val)));

const square = n => n * n;
const double = n => n * 2;
const fn = overArgs((x, y) => [x, y], [square, double]);
fn(9, 3); // [81, 6]

⬆ 回到顶部

pipeAsyncFunctions

为异步函数执行从左到右的函数组合。

在扩展操作符(…)中使用Array.prototype.reduce() 来使用Promise.then()执行从左到右的函数组合。 这些函数可以返回简单值、Promise的组合，也可以定义为通过await返回的async值。 所有函数必须是一元的。

const pipeAsyncFunctions = (...fns) => arg => fns.reduce((p, f) => p.then(f), Promise.resolve(arg));

const sum = pipeAsyncFunctions(
  x => x + 1,
  x => new Promise(resolve => setTimeout(() => resolve(x + 2), 1000)),
  x => x + 3,
  async x => (await x) + 4
);
(async() => {
  console.log(await sum(5)); // 15 (after one second)
})();

⬆ 回到顶部

pipeFunctions

执行从左到右的函数组合。

在展开操作符(…)中使用Array.prototype.reduce()来执行从左到右的函数组合。 第一个(最左边的)函数可以接受一个或多个参数; 其余的函数必须是一元的。

const pipeFunctions = (...fns) => fns.reduce((f, g) => (...args) => g(f(...args)));

const add5 = x => x + 5;
const multiply = (x, y) => x * y;
const multiplyAndAdd5 = pipeFunctions(multiply, add5);
multiplyAndAdd5(5, 2); // 15

⬆ 回到顶部

promisify

把一个异步函数转换成返回promise的。

使用局部套用返回一个函数，该函数返回一个调用原始函数的Promise。 使用的...操作符来传入所有参数。

const promisify = func => (...args) =>
  new Promise((resolve, reject) =>
    func(...args, (err, result) => (err ? reject(err) : resolve(result)))
  );

const delay = promisify((d, cb) => setTimeout(cb, d));
delay(2000).then(() => console.log('Hi!')); // // Promise resolves after 2s

⬆ 回到顶部

rearg

创建一个调用提供的函数的函数，该函数的参数按照指定的索引排列。

利用 Array.prototype.map() 根据 indexes 和展开操作符 (...) 对参数进行重新排序，将转换后的参数传递给 fn。

const rearg = (fn, indexes) => (...args) => fn(...indexes.map(i => args[i]));

var rearged = rearg(
  function(a, b, c) {
    return [a, b, c];
  },
  [2, 0, 1]
);
rearged('b', 'c', 'a'); // ['a', 'b', 'c']

⬆ 回到顶部

spreadOver

接受一个可变参数函数并返回一个闭包，该闭包接受一个参数数组以映射到函数的输入。

使用闭包和扩展操作符(…)将参数数组映射到函数的输入。

const spreadOver = fn => argsArr => fn(...argsArr);

const arrayMax = spreadOver(Math.max);
arrayMax([1, 2, 3]); // 3

⬆ 回到顶部

unary

创建一个最多接受一个参数的函数，忽略任何其他参数。

只把第一个参数传递给要调用的函数fn。

const unary = fn => val => fn(val);

['6', '8', '10'].map(unary(parseInt)); // [6, 8, 10]

⬆ 回到顶部

📚 Array

all

如果被提供的断言函数接收数组中每个元素作为参数都返回true，则返回true，否则返回false。

使用 Array.prototype.every()来测试是否第二个参数fn以集合中每个元素作为参数都返回true，使用Boolean作为默认值。

const all = (arr, fn = Boolean) => arr.every(fn);

all([4, 2, 3], x => x > 1); // true
all([1, 2, 3]); // true

⬆ 回到顶部

allEqual

检查是否数组中所有的元素都是相等的。

使用 Array.prototype.every() 来检测是否数组中的所有元素都和第一个元素相等。

const allEqual = arr => arr.every(val => val === arr[0]);

allEqual([1, 2, 3, 4, 5, 6]); // false
allEqual([1, 1, 1, 1]); // true

⬆ 回到顶部

any

如果被提供的断言函数接收数组中任意一个元素作为参数都返回true，则返回true，否则返回false。

使用 Array.prototype.every()来测试是否第二个参数fn以集合中任意一个元素作为参数都返回true，使用Boolean作为默认值。

const any = (arr, fn = Boolean) => arr.some(fn);

any([0, 1, 2, 0], x => x >= 2); // true
any([0, 0, 1, 0]); // true

⬆ 回到顶部

arrayToCSV

将2D数组转换为逗号分隔值(CSV)字符串。

使用 Array.prototype.map() 和 Array.prototype.join(delimiter) 将一个一维数组转换为字符串。

使用 Array.prototype.join('\n') 将所有行合并成CSV字符串, 用换行符分割每一行。

如果没有第二哥参数, delimiter会使用一个默认分隔符 ,.

const arrayToCSV = (arr, delimiter = ',') =>
  arr.map(v => v.map(x => `"${x}"`).join(delimiter)).join('\n');

arrayToCSV([['a', 'b'], ['c', 'd']]); // '"a","b"\n"c","d"'
arrayToCSV([['a', 'b'], ['c', 'd']], ';'); // '"a";"b"\n"c";"d"'

⬆ 回到顶部

bifurcate

将数据分为两组，如果元素在 filter数组中对应的是true，集合中相应的元素应加入第一个数组，否则加入第二个数组。

基于filter使用Array.prototype.reduce() 和 Array.prototype.push()将元素分组。

const bifurcate = (arr, filter) =>
  arr.reduce((acc, val, i) => (acc[filter[i] ? 0 : 1].push(val), acc), [[], []]);

bifurcate(['beep', 'boop', 'foo', 'bar'], [true, true, false, true]); // [ ['beep', 'boop', 'bar'], ['foo'] ]

⬆ 回到顶部

bifurcateBy

根据断言函数将数据分成两组，断言函数将指定集合中的元素属于哪个组。如果断言函数返回true，元素加入第一个数组，否则加入第二个数组。

给予fn接收元素的返回值，使用Array.prototype.reduce() 和 Array.prototype.push()将元素分组。

const bifurcateBy = (arr, fn) =>
  arr.reduce((acc, val, i) => (acc[fn(val, i) ? 0 : 1].push(val), acc), [[], []]);

bifurcateBy(['beep', 'boop', 'foo', 'bar'], x => x[0] === 'b'); // [ ['beep', 'boop', 'bar'], ['foo'] ]

⬆ 回到顶部

chunk

将数组分成指定大小的较小数组。

使用 Array.from()创建一个新的数组，该数组与将要生成的块的数量相匹配。 使用 Array.prototype.slice() 将新数组的每个元素映射到长度为size的块。 如果原始的数组不能被均匀的分割，最后的一块将包含剩余的元素。

const chunk = (arr, size) =>
  Array.from({ length: Math.ceil(arr.length / size) }, (v, i) =>
    arr.slice(i * size, i * size + size)
  );

chunk([1, 2, 3, 4, 5], 2); // [[1,2],[3,4],[5]]

⬆ 回到顶部

compact

删除数组中错误的元素

使用 Array.prototype.filter() 过滤掉错误的元素 (false, null, 0, "", undefined, NaN).

const compact = arr => arr.filter(Boolean);

compact([0, 1, false, 2, '', 3, 'a', 'e' * 23, NaN, 's', 34]); // [ 1, 2, 3, 'a', 's', 34 ]

⬆ 回到顶部

countBy

基于给定的函数将数组中的元素进行分组，并返回每个组中的元素数。

使用Array.prototype.map()来将数组中的每个元素映射到函数或属性名。 使用 Array.prototype.reduce() 创建一个对象，其中的键是从映射结果生成的。

const countBy = (arr, fn) =>
  arr.map(typeof fn === 'function' ? fn : val => val[fn]).reduce((acc, val) => {
    acc[val] = (acc[val] || 0) + 1;
    return acc;
  }, {});

countBy([6.1, 4.2, 6.3], Math.floor); // {4: 1, 6: 2}
countBy(['one', 'two', 'three'], 'length'); // {3: 2, 5: 1}

⬆ 回到顶部

countOccurrences

计算数组中某个元素出现的次数。

Use Array.prototype.reduce()在每次遇到数组中的特定值时递增计数器。

const countOccurrences = (arr, val) => arr.reduce((a, v) => (v === val ? a + 1 : a), 0);

countOccurrences([1, 1, 2, 1, 2, 3], 1); // 3

⬆ 回到顶部

deepFlatten

将一个多层嵌套的数组转转换成一个一元数组。

使用递归. Use Array.prototype.concat() with an empty array ([]) and the spread operator (...) to flatten an array. 使用 Array.prototype.concat() 和一个空数组([])以及展开运算符(...)来平铺一个数组。 当每个元素还是一个数字时，递归铺平他。

const deepFlatten = arr => [].concat(...arr.map(v => (Array.isArray(v) ? deepFlatten(v) : v)));

deepFlatten([1, [2], [[3], 4], 5]); // [1,2,3,4,5]

⬆ 回到顶部

difference

返回两个数组间的差异值。

从数组b中创建一个 Set ，然后用使用另一个数组a的Array.prototype.filter() 方法过滤掉b中的元素。

const difference = (a, b) => {
  const s = new Set(b);
  return a.filter(x => !s.has(x));
};

difference([1, 2, 3], [1, 2, 4]); // [3]

⬆ 回到顶部

differenceBy

将提供的函数应用于两个数组的每个数组元素后，返回两个数组中不同的元素。

通过b中的每个元素调用 fn后创建一个 Set ，然后将Array.prototype.filter() 与fn调用后的a结合使用，只保留先前创建的集合中不包含的值。

const differenceBy = (a, b, fn) => {
  const s = new Set(b.map(fn));
  return a.filter(x => !s.has(fn(x)));
};

differenceBy([2.1, 1.2], [2.3, 3.4], Math.floor); // [1.2]
differenceBy([{ x: 2 }, { x: 1 }], [{ x: 1 }], v => v.x); // [ { x: 2 } ]

⬆ 回到顶部

differenceWith

筛选出比较器函数不返回true的数组中的所有值。

使用 Array.prototype.filter() 和 Array.prototype.findIndex() 查找合适的值。

const differenceWith = (arr, val, comp) => arr.filter(a => val.findIndex(b => comp(a, b)) === -1);

differenceWith([1, 1.2, 1.5, 3, 0], [1.9, 3, 0], (a, b) => Math.round(a) === Math.round(b)); // [1, 1.2]

⬆ 回到顶部

drop

返回一个新数组，从原数组左边删除n个元素。

使用 Array.prototype.slice() 从左侧删除指定数量的元素。

const drop = (arr, n = 1) => arr.slice(n);

slice(n) 表示取数组下标n以后的元素（含n）

drop([1, 2, 3]); // [2,3]
drop([1, 2, 3], 2); // [3]
drop([1, 2, 3], 42); // []

⬆ 回到顶部

dropRight

返回一个新数组，从原数组右边删除n个元素。

使用 Array.prototype.slice()从右边删除指定数目的元素。

const dropRight = (arr, n = 1) => arr.slice(0, -n);

slice(0, -n) 表示取数组第一个到倒数第n个元素（不含-n）

dropRight([1, 2, 3]); // [1,2]
dropRight([1, 2, 3], 2); // [1]
dropRight([1, 2, 3], 42); // []

⬆ 回到顶部

dropRightWhile

从数组尾部移除数组中的元素，直到传递的函数返回true。返回数组中剩余的元素。

遍历数组，使用Array.prototype.slice()删除数组的最后一个元素，直到函数的返回值为true。返回剩余的元素。

const dropRightWhile = (arr, func) => {
  while (arr.length > 0 && !func(arr[arr.length - 1])) arr = arr.slice(0, -1);
  return arr;
};

dropRightWhile([1, 2, 3, 4], n => n < 3); // [1, 2]

⬆ 回到顶部

dropWhile

移除数组中的元素，直到传递的函数返回true。返回数组中剩余的元素。

遍历数组，使用Array.prototype.slice()删除数组的第一个元素，直到函数的返回值为true。返回剩余的元素。

const dropWhile = (arr, func) => {
  while (arr.length > 0 && !func(arr[0])) arr = arr.slice(1);
  return arr;
};

dropWhile([1, 2, 3, 4], n => n >= 3); // [3,4]

⬆ 回到顶部

everyNth

返回数组中所有下标是n的倍数的元素。

使用 Array.prototype.filter() 创建包含给定数组中所有下标是n的倍数的元素的新数组。

const everyNth = (arr, nth) => arr.filter((e, i) => i % nth === nth - 1);

everyNth([1, 2, 3, 4, 5, 6], 2); // [ 2, 4, 6 ]

⬆ 回到顶部

filterFalsy

把数组中的虚值过滤掉。

使用 Array.prototype.filter()创建一个只包含真值的新数组。

const filterFalsy = arr => arr.filter(Boolean);

falsy(虚值)是在Boolean上下文中已认定可转换为‘假‘的值。例如：false，0，""，null，undefined 和 NaN 。

Truthy (真值)指的是在 布尔值 上下文中转换后的值为真的值。所有值都是真值，除非它们被定义为 falsy。

filterFalsy(['', true, {}, false, 'sample', 1, 0]); // [true, {}, 'sample', 1]

⬆ 回到顶部

filterNonUnique

过滤掉数组中重复的值。

使用 Array.prototype.filter()创建一个只包含谓唯一值的数组。

const filterNonUnique = arr => arr.filter(i => arr.indexOf(i) === arr.lastIndexOf(i));

filterNonUnique([1, 2, 2, 3, 4, 4, 5]); // [1, 3, 5]

⬆ 回到顶部

filterNonUniqueBy

基于给定的比较器函数，过滤掉数组中重复的元素。

使用Array.prototype.filter() 和 Array.prototype.every() 创建一个新数组，该数组只包含唯一值，基于给定的比较器函数 fn。

比较器函数接收四个参数：正在被比较的两个元素和他们的索引。

const filterNonUniqueBy = (arr, fn) =>
  arr.filter((v, i) => arr.every((x, j) => (i === j) === fn(v, x, i, j)));

filterNonUniqueBy(
  [
    { id: 0, value: 'a' },
    { id: 1, value: 'b' },
    { id: 2, value: 'c' },
    { id: 1, value: 'd' },
    { id: 0, value: 'e' }
  ],
  (a, b) => a.id == b.id
); // [ { id: 2, value: 'c' } ]

⬆ 回到顶部

findLast

返回所提供函数返回真值的最后一个元素。

使用 Array.prototype.filter() 将调用fn后返回虚值的元素过滤掉, 然后调用Array.prototype.pop() 来获取最后一个元素。

const findLast = (arr, fn) => arr.filter(fn).pop();

findLast([1, 2, 3, 4], n => n % 2 === 1); // 3

⬆ 回到顶部

findLastIndex

返回所提供函数返回真值的最后一个元素的索引。

使用 Array.prototype.map() 将每个元素映射到具有其索引和值的数组。 使用 Array.prototype.filter() 将调用fn后返回虚值的元素过滤掉, 然后调用Array.prototype.pop() 来获取最后一个元素的索引。

const findLastIndex = (arr, fn) =>
  arr
    .map((val, i) => [i, val])
    .filter(([i, val]) => fn(val, i, arr))
    .pop()[0];

findLastIndex([1, 2, 3, 4], n => n % 2 === 1); // 2 (index of the value 3)

⬆ 回到顶部

flatten

根据指定的深度展平一个数组。

使用递归，每层递归 depth 递减1。 使用 Array.prototype.reduce() 和 Array.prototype.concat() 来合并数组或者元素。 基本情况下，当depth 等于1时停止递归。 忽略第二个参数的情况下， depth 默认为1（单层展开）。

const flatten = (arr, depth = 1) =>
  arr.reduce((a, v) => a.concat(depth > 1 && Array.isArray(v) ? flatten(v, depth - 1) : v), []);

flatten([1, [2], 3, 4]); // [1, 2, 3, 4]
flatten([1, [2, [3, [4, 5], 6], 7], 8], 2); // [1, 2, 3, [4, 5], 6, 7, 8]

⬆ 回到顶部

forEachRight

对数组中的每个元素执行一次所提供的函数，从数组的最后一个元素开始。

使用 Array.prototype.slice(0) 克隆给定的数组，并使用Array.prototype.reverse() 将它反转，然后使用Array.prototype.forEach()遍历反转后的数组。

const forEachRight = (arr, callback) =>
  arr
    .slice(0)
    .reverse()
    .forEach(callback);

forEachRight([1, 2, 3, 4], val => console.log(val)); // '4', '3', '2', '1'

⬆ 回到顶部

groupBy

基于给定的函数将数组分组。

使用 Array.prototype.map() 将组数中的值映射到一个函数或者属性名。

使用 Array.prototype.reduce() 创建一个对象，其中的键由映射的结果生成。

const groupBy = (arr, fn) =>
  arr.map(typeof fn === 'function' ? fn : val => val[fn]).reduce((acc, val, i) => {
    acc[val] = (acc[val] || []).concat(arr[i]);
    return acc;
  }, {});

groupBy([6.1, 4.2, 6.3], Math.floor); // {4: [4.2], 6: [6.1, 6.3]}
groupBy(['one', 'two', 'three'], 'length'); // {3: ['one', 'two'], 5: ['three']}

⬆ 回到顶部

head

返回列表的头部

使用 arr[0] 返回传递数组的第一个元素。

const head = arr => arr[0];

head([1, 2, 3]); // 1

⬆ 回到顶部

indexOfAll

返回一个数组中所有 val 的索引。 如果 val 不存在，返回 [] 。

使用 Array.prototype.reduce() 遍历元素，将匹配的元素索引存储下来，返回索引数组。

const indexOfAll = (arr, val) => arr.reduce((acc, el, i) => (el === val ? [...acc, i] : acc), []);

indexOfAll([1, 2, 3, 1, 2, 3], 1); // [0,3]
indexOfAll([1, 2, 3], 4); // []

⬆ 回到顶部

initial

返回数组中除最后一个元素外的所有元素。

使用 arr.slice(0,-1) 返回数组中除最后一个元素外的所有元素。

const initial = arr => arr.slice(0, -1);

initial([1, 2, 3]); // [1,2]

⬆ 回到顶部

initialize2DArray

根据给定的宽、高和值初始化一个二维数组。

使用 Array.prototype.map() 生成h行，其中每一行都是大小为w的新数组，并用值初始化。如果没有提供该值，则默认为null。

const initialize2DArray = (w, h, val = null) =>
  Array.from({ length: h }).map(() => Array.from({ length: w }).fill(val));

initialize2DArray(2, 2, 0); // [[0,0], [0,0]]

⬆ 回到顶部

initializeArrayWithRange

初始化一个数组，该数组包括从 start 到 end 指定范围的数字，并且包括共同的公差 step 。

使用 Array.from() 创建一个所需长度 (end - start + 1)/step 的数组，然后指定一个匹配函数将指定范围内的所需值填充到数组中。

你可以省略 start 使用默认值0; 你可以省略 step 使用默认值1;

const initializeArrayWithRange = (end, start = 0, step = 1) =>
  Array.from({ length: Math.ceil((end - start + 1) / step) }, (v, i) => i * step + start);

initializeArrayWithRange(5); // [0,1,2,3,4,5]
initializeArrayWithRange(7, 3); // [3,4,5,6,7]
initializeArrayWithRange(9, 0, 2); // [0,2,4,6,8]

⬆ 回到顶部

initializeArrayWithRangeRight

初始化一个数组，该数组包括从 start 到 end 指定范围的数字（反向的），并且包括共同的公差 step 。

使用 Array.from(Math.ceil((end+1-start)/step)) 创建一个期望长度的数组（为了兼容结束，元素的数量等同于(end-start)/step 或 (end+1-start)/step），使用Array.prototype.map()来填充期望范围内的值。

你可以省略 start 使用默认值0。 你可以省略 step 使用默认值1。

const initializeArrayWithRangeRight = (end, start = 0, step = 1) =>
  Array.from({ length: Math.ceil((end + 1 - start) / step) }).map(
    (v, i, arr) => (arr.length - i - 1) * step + start
  );

initializeArrayWithRangeRight(5); // [5,4,3,2,1,0]
initializeArrayWithRangeRight(7, 3); // [7,6,5,4,3]
initializeArrayWithRangeRight(9, 0, 2); // [8,6,4,2,0]

⬆ 回到顶部

initializeArrayWithValues

初始化一个数组，并且使用指定的值填充它。

使用 Array(n) 创建一个期望长度的数组，使用 fill(v) 用期望的值填充数组。

你可以省略参数 val 使用默认值0。

const initializeArrayWithValues = (n, val = 0) => Array(n).fill(val);

initializeArrayWithValues(5, 2); // [2, 2, 2, 2, 2]

⬆ 回到顶部

initializeNDArray

使用给定的值创建一个n维数组。

使用递归。使用 Array.prototype.map() 来生成行，这些行每一个都是使用initializeNDArray初始化的新数组。

const initializeNDArray = (val, ...args) =>
  args.length === 0
    ? val
    : Array.from({ length: args[0] }).map(() => initializeNDArray(val, ...args.slice(1)));

initializeNDArray(1, 3); // [1,1,1]
initializeNDArray(5, 2, 2, 2); // [[[5,5],[5,5]],[[5,5],[5,5]]]

⬆ 回到顶部

intersection

返回两个数组中都存在的元素列表。

从 b创建一个 Set ，然后在a上使用Array.prototype.filter()来只保留 b中包含的元素。

const intersection = (a, b) => {
  const s = new Set(b);
  return a.filter(x => s.has(x));
};

intersection([1, 2, 3], [4, 3, 2]); // [2, 3]

⬆ 回到顶部

intersectionBy

将提供的函数应应用到两个数组的每个元素上，然后返回两个数组中都存在的元素列表

通过将 fn 应用到 b的所有元素来创建一个 Set，然后在 a 上调用 Array.prototype.filter() 来只保留调用 fn 后 b 中包含的元素。

const intersectionBy = (a, b, fn) => {
  const s = new Set(b.map(fn));
  return a.filter(x => s.has(fn(x)));
};

intersectionBy([2.1, 1.2], [2.3, 3.4], Math.floor); // [2.1]

⬆ 回到顶部

intersectionWith

返回两个数组中都存在的元素列表，使用给定的比较函数。

结合使用Array.prototype.filter()和 Array.prototype.findIndex() 来确定交叉值。

const intersectionWith = (a, b, comp) => a.filter(x => b.findIndex(y => comp(x, y)) !== -1);

intersectionWith([1, 1.2, 1.5, 3, 0], [1.9, 3, 0, 3.9], (a, b) => Math.round(a) === Math.round(b)); // [1.5, 3, 0]

⬆ 回到顶部

isSorted

如果数组是升序排序的，返回 1 ，如果数组是降序排序的返回 -1，如果数组没有排序返回0 。

计算前两个元素的顺序 direction。使用 Object.entries() 来遍历数组，病成对比较。如果 direction 改变，返回 0 ，如果到达最后一个元素，返回 direction 。

const isSorted = arr => {
  let direction = -(arr[0] - arr[1]);
  for (let [i, val] of arr.entries()) {
    direction = !direction ? -(arr[i - 1] - arr[i]) : direction;
    if (i === arr.length - 1) return !direction ? 0 : direction;
    else if ((val - arr[i + 1]) * direction > 0) return 0;
  }
};

isSorted([0, 1, 2, 2]); // 1
isSorted([4, 3, 2]); // -1
isSorted([4, 3, 5]); // 0

⬆ 回到顶部

join

将数组中所有的元素连接成一个字符串，并返回这个字符串。使用一个分隔符和结束分隔符。

使用 Array.prototype.reduce() 将元素合并成字符串。 忽略第二个参数，separator，默认情况下使用一个默认分隔符','。 忽略第三个参数， end，使用和separator相同的值作为默认值。

const join = (arr, separator = ',', end = separator) =>
  arr.reduce(
    (acc, val, i) =>
      i === arr.length - 2
        ? acc + val + end
        : i === arr.length - 1
          ? acc + val
          : acc + val + separator,
    ''
  );

join(['pen', 'pineapple', 'apple', 'pen'], ',', '&'); // "pen,pineapple,apple&pen"
join(['pen', 'pineapple', 'apple', 'pen'], ','); // "pen,pineapple,apple,pen"
join(['pen', 'pineapple', 'apple', 'pen']); // "pen,pineapple,apple,pen"

⬆ 回到顶部

JSONtoCSV

将对象数组转换为仅包含指定的columns的逗号分隔值(CSV)字符串。

使用 Array.prototype.join(delimiter) 合并columns中的所有名称以创建第一行。、

使用 Array.prototype.map() 和 Array.prototype.reduce() 为每个对象创建一行，用空字符串替换不存在的值，只映射“列”中的值。

使用Array.prototype.join('\n')将所有行组合成一个字符串。 忽略第三个参数 delimiter,使用默认分隔符 ,。

const JSONtoCSV = (arr, columns, delimiter = ',') =>
  [
    columns.join(delimiter),
    ...arr.map(obj =>
      columns.reduce(
        (acc, key) => `${acc}${!acc.length ? '' : delimiter}"${!obj[key] ? '' : obj[key]}"`,
        ''
      )
    )
  ].join('\n');

JSONtoCSV([{ a: 1, b: 2 }, { a: 3, b: 4, c: 5 }, { a: 6 }, { b: 7 }], ['a', 'b']); // 'a,b\n"1","2"\n"3","4"\n"6",""\n"","7"'
JSONtoCSV([{ a: 1, b: 2 }, { a: 3, b: 4, c: 5 }, { a: 6 }, { b: 7 }], ['a', 'b'], ';'); // 'a;b\n"1";"2"\n"3";"4"\n"6";""\n"";"7"'

⬆ 回到顶部

last

返回数组中最后一个元素。

使用 arr.length - 1 来计算给定数组最后一个元素的索引，然后返回它。

const last = arr => arr[arr.length - 1];

last([1, 2, 3]); // 3

⬆ 回到顶部

longestItem

获取任意数量的可迭代对象或具有 length 属性的对象，并返回其中最长的一个。

如果多个对象具有相同的长度，则返回第一个对象。 如果没有提供参数，则返回“undefined”。

使用Array.prototype.reduce()，比较对象的length以找到最长的对象。

const longestItem = (...vals) => vals.reduce((a, x) => (x.length > a.length ? x : a));

longestItem('this', 'is', 'a', 'testcase'); // 'testcase'
longestItem(...['a', 'ab', 'abc']); // 'abc'
longestItem(...['a', 'ab', 'abc'], 'abcd'); // 'abcd'
longestItem([1, 2, 3], [1, 2], [1, 2, 3, 4, 5]); // [1, 2, 3, 4, 5]
longestItem([1, 2, 3], 'foobar'); // 'foobar'

⬆ 回到顶部

mapObject

使用函数将数组的值映射到对象，其中键值对由作为键的原始值和映射的值组成。

使用匿名内部函数作用域声明未定义的内存空间，使用闭包存储返回值。使用一个新的 Array 来存储数组，其中包含函数在其数据集上的映射，并使用逗号操作符返回第二个步骤，而不需要从一个上下文移动到另一个上下文(由于闭包和操作顺序)。

const mapObject = (arr, fn) =>
  (a => (
    (a = [arr, arr.map(fn)]), a[0].reduce((acc, val, ind) => ((acc[val] = a[1][ind]), acc), {})
  ))();

const squareIt = arr => mapObject(arr, a => a * a);
squareIt([1, 2, 3]); // { 1: 1, 2: 4, 3: 9 }

⬆ 回到顶部

maxN

返回给定数组中前 n 大的元素。 如果 n 比给定的数组长度还要大，返回原始数组（按降序排列）。

使用 Array.prototype.sort() 结合展开操作符 (...) 创建一个数组的浅克隆，并按照降序排序。 使用 Array.prototype.slice() 获取指定数量的元素。 忽略第二个参数, n, 返回一个单元素数组。

const maxN = (arr, n = 1) => [...arr].sort((a, b) => b - a).slice(0, n);

maxN([1, 2, 3]); // [3]
maxN([1, 2, 3], 2); // [3,2]

⬆ 回到顶部

minN

返回给定数组中前 n 小的元素。 如果 n 比给定的数组长度还要大，返回原始数组（按升序排列）。

使用 Array.prototype.sort() 结合展开操作符 (...) 创建一个数组的浅克隆，并按照升序排序。 使用 Array.prototype.slice() 获取指定数量的元素。 忽略第二个参数, n, 返回一个单元素数组。

const minN = (arr, n = 1) => [...arr].sort((a, b) => a - b).slice(0, n);

minN([1, 2, 3]); // [1]
minN([1, 2, 3], 2); // [1,2]

⬆ 回到顶部

none

如果对集合中所有的元素执行判定函数全部都返回false，那么函数返回true，否则返回false。

基于fn使用Array.prototype.some()来测试是否集合中有任意一个元素返回true。

忽略第二个参数，fn，使用Boolean作为默认值。

const none = (arr, fn = Boolean) => !arr.some(fn);

none([0, 1, 3, 0], x => x == 2); // true
none([0, 0, 0]); // true

⬆ 回到顶部

nthElement

返回数组中第n个元素(n可以是负数)。

使用Array.prototype.slice()获得在首位包含第n个元素的数组。

如果下标越界，返回undefined。

如果没有第二个参数，n，返回数组中第一个元素。

const nthElement = (arr, n = 0) => (n === -1 ? arr.slice(n) : arr.slice(n, n + 1))[0];

nthElement(['a', 'b', 'c'], 1); // 'b'
nthElement(['a', 'b', 'b'], -3); // 'a'

⬆ 回到顶部

offset

将指定数量的元素移动到数组的末尾。

使用 Array.prototype.slice() 两次来获取指定索引后面的元素和前面的元素。

使用扩展操作符(...)将两个数组合并成一个数组。

如果offset是负，元素将被从末尾移动到开始。

const offset = (arr, offset) => [...arr.slice(offset), ...arr.slice(0, offset)];

offset([1, 2, 3, 4, 5], 2); // [3, 4, 5, 1, 2]
offset([1, 2, 3, 4, 5], -2); // [4, 5, 1, 2, 3]

⬆ 回到顶部

partition

根据提供的函数对每个元素的真实性，将元素分组为两个数组。

使用Array.prototype.reduce()创建一个由两个数组组成的数组。

使用Array.prototype.push()将执行fn返回true的元素添加到第一个数组，执行fn返回false的元素添加到第二个数组。

const partition = (arr, fn) =>
  arr.reduce(
    (acc, val, i, arr) => {
      acc[fn(val, i, arr) ? 0 : 1].push(val);
      return acc;
    },
    [[], []]
  );

const users = [{ user: 'barney', age: 36, active: false }, { user: 'fred', age: 40, active: true }];
partition(users, o => o.active); // [[{ 'user': 'fred',    'age': 40, 'active': true }],[{ 'user': 'barney',  'age': 36, 'active': false }]]

⬆ 回到顶部

permutations

生成数组元素的所有排列(包括重复元素)

使用递归。

对于给定数组中的每个元素，为其其余元素创建所有部分排列。

使用Array.prototype.map()组合每个元素的部分排列，然后使用Array.prototype.reduce()组合一个数组中的所有排列。

基本情况是数组length 等于 2 或 1。

const permutations = arr => {
  if (arr.length <= 2) return arr.length === 2 ? [arr, [arr[1], arr[0]]] : arr;
  return arr.reduce(
    (acc, item, i) =>
      acc.concat(
        permutations([...arr.slice(0, i), ...arr.slice(i + 1)]).map(val => [item, ...val])
      ),
    []
  );
};

permutations([1, 33, 5]); // [ [ 1, 33, 5 ], [ 1, 5, 33 ], [ 33, 1, 5 ], [ 33, 5, 1 ], [ 5, 1, 33 ], [ 5, 33, 1 ] ]

⬆ 回到顶部

pull

修改原始数组以过滤掉指定的值。

使用Array.prototype.filter() 和 Array.prototype.includes()将不需要过滤的值提取出来。

使用Array.prototype。length = 0 通过将数组的长度重置为0来改变数组中传递的值，并使用array .prototype.push()仅用提取的值重新填充数组。

const pull = (arr, ...args) => {
  let argState = Array.isArray(args[0]) ? args[0] : args;
  let pulled = arr.filter((v, i) => !argState.includes(v));
  arr.length = 0;
  pulled.forEach(v => arr.push(v));
};

let myArray = ['a', 'b', 'c', 'a', 'b', 'c'];
pull(myArray, 'a', 'c'); // myArray = [ 'b', 'b' ]

⬆ 回到顶部

pullAtIndex

修改原始数组，以过滤指定索引处的值。

使用Array.prototype.filter() 和 Array.prototype.includes()将不需要过滤的值提取出来。

使用Array.prototype。length = 0 通过将数组的长度重置为0来改变数组中传递的值，并使用array .prototype.push()仅用提取的值重新填充数组。

const pullAtIndex = (arr, pullArr) => {
  let removed = [];
  let pulled = arr
    .map((v, i) => (pullArr.includes(i) ? removed.push(v) : v))
    .filter((v, i) => !pullArr.includes(i));
  arr.length = 0;
  pulled.forEach(v => arr.push(v));
  return removed;
};

let myArray = ['a', 'b', 'c', 'd'];
let pulled = pullAtIndex(myArray, [1, 3]); // myArray = [ 'a', 'c' ] , pulled = [ 'b', 'd' ]

⬆ 回到顶部

pullAtValue

修改原始数组，以过滤掉指定的值。返回移除后的元素。

使用Array.prototype.filter() 和 Array.prototype.includes()将不需要过滤的值提取出来。

使用Array.prototype。length = 0 通过将数组的长度重置为0来改变数组中传递的值，并使用array .prototype.push()仅用提取的值重新填充数组。

使用Array.prototype.push() 跟踪拉取出来的值。

const pullAtValue = (arr, pullArr) => {
  let removed = [],
    pushToRemove = arr.forEach((v, i) => (pullArr.includes(v) ? removed.push(v) : v)),
    mutateTo = arr.filter((v, i) => !pullArr.includes(v));
  arr.length = 0;
  mutateTo.forEach(v => arr.push(v));
  return removed;
};

let myArray = ['a', 'b', 'c', 'd'];
let pulled = pullAtValue(myArray, ['b', 'd']); // myArray = [ 'a', 'c' ] , pulled = [ 'b', 'd' ]

⬆ 回到顶部

reducedFilter

根据一个条件过滤对象数组，同时过滤掉未指定的键。

使用Array.prototype.filter()根据判定函数fn对数组进行过滤，返回条件返回true值的对象。

在过滤后的数组的基础上，使用 Array.prototype.map() 返回使用 Array.prototype.reduce() 将不在参数keys中的属性过滤掉后的新对象。

const reducedFilter = (data, keys, fn) =>
  data.filter(fn).map(el =>
    keys.reduce((acc, key) => {
      acc[key] = el[key];
      return acc;
    }, {})
  );

const data = [
  {
    id: 1,
    name: 'john',
    age: 24
  },
  {
    id: 2,
    name: 'mike',
    age: 50
  }
];

reducedFilter(data, ['id', 'name'], item => item.age > 24); // [{ id: 2, name: 'mike'}]

⬆ 回到顶部

reduceSuccessive

对累加器和数组中的每个元素应用一个函数(从左到右)，返回一个依次递减的值数组。

使用Array.prototype.reduce() 将给定函数应用于给定数组，存储每个新结果。

const reduceSuccessive = (arr, fn, acc) =>
  arr.reduce((res, val, i, arr) => (res.push(fn(res.slice(-1)[0], val, i, arr)), res), [acc]);

reduceSuccessive([1, 2, 3, 4, 5, 6], (acc, val) => acc + val, 0); // [0, 1, 3, 6, 10, 15, 21]

⬆ 回到顶部

reduceWhich

将给定的函数设置比较规则后，返回数组的最小/最大值。

结合使用Array.prototype.reduce() 和 comparator函数，以获取数组中的适当元素。

你可以省略第二个参数， comparator，使用返回数组中最小元素的默认值。

const reduceWhich = (arr, comparator = (a, b) => a - b) =>
  arr.reduce((a, b) => (comparator(a, b) >= 0 ? b : a));

reduceWhich([1, 3, 2]); // 1
reduceWhich([1, 3, 2], (a, b) => b - a); // 3
reduceWhich(
  [{ name: 'Tom', age: 12 }, { name: 'Jack', age: 18 }, { name: 'Lucy', age: 9 }],
  (a, b) => a.age - b.age
); // {name: "Lucy", age: 9}

⬆ 回到顶部

reject

接受一个判定函数和一个数组，像Array.prototype.filter()一样，但是仅仅当pred(x) === false才保留x 。

const reject = (pred, array) => array.filter((...args) => !pred(...args));

reject(x => x % 2 === 0, [1, 2, 3, 4, 5]); // [1, 3, 5]
reject(word => word.length > 4, ['Apple', 'Pear', 'Kiwi', 'Banana']); // ['Pear', 'Kiwi']

⬆ 回到顶部

remove

Removes elements from an array for which the given function returns false.

Use Array.prototype.filter() to find array elements that return truthy values and Array.prototype.reduce() to remove elements using Array.prototype.splice(). The func is invoked with three arguments (value, index, array).

const remove = (arr, func) =>
  Array.isArray(arr)
    ? arr.filter(func).reduce((acc, val) => {
      arr.splice(arr.indexOf(val), 1);
      return acc.concat(val);
    }, [])
    : [];

remove([1, 2, 3, 4], n => n % 2 === 0); // [2, 4]

⬆ 回到顶部

sample

Returns a random element from an array.

Use Math.random() to generate a random number, multiply it by length and round it off to the nearest whole number using Math.floor(). This method also works with strings.

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

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

⬆ 回到顶部

sampleSize

Gets n random elements at unique keys from array up to the size of array.

Shuffle the array using the Fisher-Yates algorithm. Use Array.prototype.slice() to get the first n elements. Omit the second argument, n to get only one element at random from the array.

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);
};

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

⬆ 回到顶部

shank

Has the same functionality as Array.prototype.splice(), but returning a new array instead of mutating the original array.

Use Array.prototype.slice() and Array.prototype.concat() to get a new array with the new contents after removing existing elements and/or adding new elements. Omit the second argument, index, to start at 0. Omit the third argument, delCount, to remove 0 elements. Omit the fourth argument, elements, in order to not add any new elements.

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