函数 功能 30-seconds-of-code

函数 功能

原文：https://github.com/Chalarangelo/30-seconds-of-code

作者：Chalarangelo

翻译：http://caibaojian.com/30-seconds-of-code.html

译者：蔡宝坚

收集有用的 Javascript 片段, 你可以在30秒或更少的时间里理解。

chainAsync:链异步函数

循环遍历包含异步事件的函数数组，当每个异步事件完成调用next

const chainAsync = fns => { let curr = 0; const next = () => fns[curr++](next); next(); };
/*
chainAsync([
  next => { console.log('0 seconds'); setTimeout(next, 1000); },
  next => { console.log('1 second');  setTimeout(next, 1000); },
  next => { console.log('2 seconds'); }
])
*/

compose:执行从右向左的函数组合。

使用Array.reduce()执行从右向左的函数组合。最后一个 (最右边) 的函数可以接受一个或多个参数;其余的函数必须是一元的。

const compose = (...fns) => fns.reduce((f,g)=> (...args) => f(g(...args)))
/*
const add5 = x => x + 5
const multiply = (x, y) => x * y
const multiplyAndAdd5 = compose(add5, multiply)
multiplyAndAdd5(5, 2) -> 15
*/

pipe:执行从左向右的函数组合

使用Array.reduce()与扩展运算符(...)执行从左向右的函数组合，第一个（最左边的）函数可以接受一个或多个参数；其余的函数必须是一元的

//(...fns)==>剩余运算符，它将成为一个由剩余参数组成的真数组[5,6]
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
*/

curry:Curries a function. /*********************************/

使用递归。如果提供的参数 (变量) 的数量足够, 请调用传递的函数args f。否则, 返回需要其余参数的扩充函数f。如果你想咖喱一个函数, 接受可变数目的参数 (如Math.min()), 可以选择将参数的个数传递到第二个参数arity(可变函数).

const curry = (fn, arity = fn.length, ...args) =>
arity <= args.length
? fn(...args)
: curry.bind(null, fn, arity, ...args);
// curry(Math.pow)(2)(10) -> 1024
// curry(Math.min, 3)(10)(50)(2) -> 2

functionName:记录函数的名称

使用console.debug()和传递的方法的name属性将方法的名称记录到控制台的debug通道中。

const functionName = fn => (console.debug(fn.name), fn);
// functionName(Math.max) -> max (logged in debug channel of console)

runPromisesInSeries:运行一系列的承诺系列。

使用Array.reduce()创建一个承诺链, 每个承诺在解决时返回下一个承诺。

const runPromisesInSeries = ps => ps.reduce((p, next) => p.then(next), Promise.resolve());
// const delay = (d) => new Promise(r => setTimeout(r, d))
// runPromisesInSeries([() => delay(1000), () => delay(2000)]) -> executes each promise sequentially, taking a total of 3 seconds to complete

sleep:延迟异步函数的执行

延迟执行async的函数的一部分，将其放入休眠状态，返回Promise

const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
/*
async function sleepyWork() {
  console.log('I\'m going to sleep for 1 second.');
  await sleep(1000);
  console.log('I woke up after 1 second.');
}
*/

arrayAverage:返回数字数组的平均值。

使用Array.reduce()将每个值添加到累加器中, 并以0的值初始化, 除以数组的length。

const arrayAverage = arr => arr.reduce((acc,curVal)=>acc + curVal) /arr.length
// arrayAverage([1,2,3]) -> 2

arraySum:返回一个数字数组的总和

使用 Array.reduce()将每个值添加到累加器中，并以0值初始化

const arraySum = arr => arr.reduce((acc,curVal)=>acc+curVal,0)
// arraySum([1,2,3,4]) -> 10

collatz:应用 Collatz 算法。

如果n是偶数, 则返回n/2。否则返回3n+1.

const collatz = n => (n % 2 == 0) ? (n / 2) : (3 * n + 1);
// collatz(8) --> 4
// collatz(5) --> 16

collatz:将数字转换为数字数组

将数字转换为字符串，在ES6([...string])中使用扩展运算符生成数组，使用Array.map()和parseInt()将每个值转换为整数

const colltaz = n => [...'' +n ].map(i=>parseInt(i))
// digitize(2334) -> [2, 3, 3, 4]

digitize

返回两点之间的距离。

使用Math.hypot()计算两个点之间的欧氏距离。

const distance = (x0, y0, x1, y1) => Math.hypot(x1 - x0, y1 - y0);
// distance(1,1, 2,3) -> 2.23606797749979

distance:计算数字的阶乘

使用递归。如果n小于或等于1, 则返回1。否则, 返回n的乘积和n - 1的阶乘。如果n为负数, 则引发异常。

const distance  = n => n < 0 ? (() => { throw new TypeError('Negative numbers are not allowed!') })(): n <= 1 ? 1 : n * factorial(n - 1);
// factorial(6) -> 720

fibolacci:生成一个数组，包含斐波那契数列，知道第n个项

创建一个指定长度的空数组, 初始化前两个值 (0和1)。使用Array.reduce()可将值添加到数组中, 方法是使用前两个值的总和, 但前两个数值除外。

const fibonacci = n =>
Array(n).fill(0).reduce((acc, val, i) => acc.concat(i > 1 ? acc[i - 1] + acc[i - 2] : i), []);
// fibonacci(5) -> [0,1,1,2,3]

gcd

计算两个数字之间最大的公共除数。

使用递归。基本情况是当y等于0时。在这种情况下, 返回x。否则, 返回y的 GCD 和除法的其余部分x/y.

const gcd = (x, y) => !y ? x : gcd(y, x % y);
// gcd (8, 36) -> 4

isDivisible

检查第一个数值参数是否可被另一个数字变量整除。

使用模数运算符 (%) 检查余数是否等于0.

const isDivisible = (dividend, divisor) => dividend % divisor === 0;
// isDivisible(6,3) -> true

iseven

如果给定的数字为偶数, 则返回true, 否则为false。

检查一个数字是奇数还是使用模数 (%) 运算符。如果数字为偶数, 则返回true, 如果数字为奇数, 则为false。

const isEven = num => num % 2 === 0;
// isEven(3) -> false

median

返回数字数组的中间值。

找到数组的中间, 使用Array.sort()来对值进行排序。如果length为奇数, 则返回中点的数字, 否则为两个中间数的平均值。

const median = arr => {
const mid = Math.floor(arr.length / 2), nums = arr.sort((a, b) => a - b);
return arr.length % 2 !== 0 ? nums[mid] : (nums[mid - 1] + nums[mid]) / 2;
};
// median([5,6,50,1,-5]) -> 5
// median([0,10,-2,7]) -> 3.5

palindrome

如果给定字符串为回文, 则返回true, 否则为false。

转换字符串toLowerCase()并使用replace()从其中删除非字母数字字符。然后,split('')到各个字符,reverse(),join(''), 并将其与原始的、不可逆转的字符串进行比较, 然后将其转换为tolowerCase().

const palindrome = str => {
const s = str.toLowerCase().replace(/[\W_]/g,'');
return s === s.split('').reverse().join('');
}
// palindrome('taco cat') -> true

percentile

使用百分比公式计算给定数组中有多少个数小于或等于给定值。

使用Array.reduce()计算值的下面有多少, 有多少个数是相同的值, 并应用百分比公式。

const percentile = (arr, val) =>
100 * arr.reduce((acc,v) => acc + (v < val ? 1 : 0) + (v === val ? 0.5 : 0), 0) / arr.length;
// percentile([1,2,3,4,5,6,7,8,9,10], 6) -> 55

powerset

返回给定数字数组的 powerset。

使用Array.reduce()与Array.map()组合, 以循环访问元素并将其合并到包含所有组合的数组中。

const powerset = arr =>
arr.reduce((a, v) => a.concat(a.map(r => [v].concat(r))), [[]]);
// powerset([1,2]) -> [[], [1], [2], [2,1]]

randomIntegerInRange

返回指定范围内的随机整数。

使用Math.random()生成一个随机数并将其映射到所需的范围, 使用Math.floor()使其成为整数。

const randomIntegerInRange = (min, max) => Math.floor(Math.random() * (max - min + 1)) + min;
// randomIntegerInRange(0, 5) -> 2

randomNumberInRange

返回指定范围内的随机数。

使用Math.random()生成随机值, 并使用乘法将其映射到所需的范围。

const randomNumberInRange = (min, max) => Math.random() * (max - min) + min;
// randomNumberInRange(2,10) -> 6.0211363285087005