澳门新萄京官方网站-www.8455.com-澳门新萄京赌场网址

澳门新萄京官方网站:代码片段,精心搜聚的

2019-07-07 作者:澳门新萄京赌场网址   |   浏览(174)

征服 JavaScript 面试:什么是函数组合

2017/01/30 · JavaScript · 2 评论 · 函数

原文出处: Eric Elliott   译文出处:众成翻译   

澳门新萄京官方网站 1

Google 数据中心管道 — Jorge Jorquera — (CC-BY-NC-ND-2.0)

“征服 JavaScript 面试”是我写的一系列文章,来帮助面试者准备他们在面试 JavaScript 中、高级职位中将可能会遇到的一些问题。这些问题我自己在面试中也经常会问。

函数式编程正在接管 JavaScript 世界。就在几年前,只有少数 JavaScript 程序员知道函数式编程是什么。然而,在过去 3 年内,我所看到的每个大型应用程序代码库都大量用到了函数式编程理念。

函数组合就是组合两到多个函数来生成一个新函数的过程。将函数组合在一起,就像将一连串管道扣合在一起,让数据流过一样。

简而言之,函数 fg 的组合可以被定义为 f(g(x)),从内到外(从右到左)求值。也就是说,求值顺序是:

  1. x
  2. g
  3. f

下面我们在代码中更近距离观察一下这个概念。假如你想把用户的全名转换为 URL Slug,给每个用户一个个人信息页面。为了实现此需求,你需要经历一连串的步骤:

  1. 将姓名根据空格分拆(split)到一个数组中
  2. 将姓名映射(map)为小写
  3. 用破折号连接(join)
  4. 编码 URI 组件

如下是一个简单的实现:

JavaScript

const toSlug = input => encodeURIComponent( input.split(' ') .map(str => str.toLowerCase()) .join('-') );

1
2
3
4
5
const toSlug = input => encodeURIComponent(
  input.split(' ')
    .map(str => str.toLowerCase())
    .join('-')
);

还不赖…但是假如我告诉你可读性还可以更强一点会怎么样呢?

假设每个操作都有一个对应的可组合的函数。上述代码就可以被写为:

JavaScript

const toSlug = input => encodeURIComponent( join('-')( map(toLowerCase)( split(' ')( input ) ) ) ); console.log(toSlug('JS Cheerleader')); // 'js-cheerleader'

1
2
3
4
5
6
7
8
9
10
11
const toSlug = input => encodeURIComponent(
  join('-')(
    map(toLowerCase)(
      split(' ')(
        input
      )
    )
  )
);
 
console.log(toSlug('JS Cheerleader')); // 'js-cheerleader'

这看起来比我们的第一次尝试更难读懂,但是先忍一下,我们就要解决。

为了实现上述代码,我们将组合几种常用的工具,比如 split()join()map()。如下是实现:

JavaScript

const curry = fn => (...args) => fn.bind(null, ...args); const map = curry((fn, arr) => arr.map(fn)); const join = curry((str, arr) => arr.join(str)); const toLowerCase = str => str.toLowerCase(); const split = curry((splitOn, str) => str.split(splitOn));

1
2
3
4
5
6
7
8
9
const curry = fn => (...args) => fn.bind(null, ...args);
 
const map = curry((fn, arr) => arr.map(fn));
 
const join = curry((str, arr) => arr.join(str));
 
const toLowerCase = str => str.toLowerCase();
 
const split = curry((splitOn, str) => str.split(splitOn));

除了 toLowerCase() 外,所有这些函数经产品测试的版本都可以从 Lodash/fp 中得到。可以像这样导入它们:

JavaScript

import { curry, map, join, split } from 'lodash/fp';

1
import { curry, map, join, split } from 'lodash/fp';

也可以像这样导入:

JavaScript

const curry = require('lodash/fp/curry'); const map = require('lodash/fp/map'); //...

1
2
3
const curry = require('lodash/fp/curry');
const map = require('lodash/fp/map');
//...

这里我偷了点懒。注意这个 curry 从技术上来说,并不是一个真正的柯里化函数。真正的柯里化函数总会生成一个一元函数。这里的 curry 只是一个偏函数应用。请参考“柯里化和偏函数应用之间的区别是什么?”这篇文章。不过,这里只是为了演示用途,我们就把它当作一个真正的柯里化函数好了。

回到我们的 toSlug() 实现,这里有一些东西真的让我很烦:

JavaScript

const toSlug = input => encodeURIComponent( join('-')( map(toLowerCase)( split(' ')( input ) ) ) ); console.log(toSlug('JS Cheerleader')); // 'js-cheerleader'

1
2
3
4
5
6
7
8
9
10
11
const toSlug = input => encodeURIComponent(
  join('-')(
    map(toLowerCase)(
      split(' ')(
        input
      )
    )
  )
);
 
console.log(toSlug('JS Cheerleader')); // 'js-cheerleader'

对我来说,这里的嵌套太多了,读起来有点让人摸不着头脑。我们可以用一个会自动组合这些函数的函数来扁平化嵌套,就是说,这个函数会从一个函数得到输出,并自动将它传递给下一个函数作为输入,直到得到最终值为止。

细想一下,好像数组中有一个函数可以做差不多的事情。这个函数就是 reduce(),它用一系列值为参数,对每个值应用一个函数,最后累加成一个结果。值本身也可以函数。但是 reduce() 是从左到右递减,为了匹配上面的组合行为,我们需要它从右到左缩减。

好事情是刚好数组也有一个 reduceRight() 方法可以干这事:

JavaScript

const compose = (...fns) => x => fns.reduceRight((v, f) => f(v), x);

1
const compose = (...fns) => x => fns.reduceRight((v, f) => f(v), x);

.reduce() 一样,数组的 .reduceRight() 方法带有一个 reducer 函数和一个初始值(x)为参数。我们可以用它从右到左迭代数组,将函数依次应用到每个数组元素上,最后得到累加值(v)。

compose,我们就可以不需要嵌套来重写上面的组合:

JavaScript

const toSlug = compose( encodeURIComponent, join('-'), map(toLowerCase), split(' ') ); console.log(toSlug('JS Cheerleader')); // 'js-cheerleader'

1
2
3
4
5
6
7
8
const toSlug = compose(
  encodeURIComponent,
  join('-'),
  map(toLowerCase),
  split(' ')
);
 
console.log(toSlug('JS Cheerleader')); // 'js-cheerleader'

当然,lodash/fp 也提供了 compose()

JavaScript

import { compose } from 'lodash/fp';

1
import { compose } from 'lodash/fp';

或者:

JavaScript

const compose = require('lodash/fp/compose');

1
const compose = require('lodash/fp/compose');

当以数学形式的组合从内到外的角度来思考时,compose 是不错的。不过,如果想以从左到右的顺序的角度来思考,又该怎么办呢?

还有另外一种形式,通常称为 pipe()。Lodash 称之为 flow():

JavaScript

const pipe = (...fns) => x => fns.reduce((v, f) => f(v), x); const fn1 = s => s.toLowerCase(); const fn2 = s => s.split('').reverse().join(''); const fn3 = s => s '!' const newFunc = pipe(fn1, fn2, fn3); const result = newFunc('Time'); // emit!

1
2
3
4
5
6
7
8
const pipe = (...fns) => x => fns.reduce((v, f) => f(v), x);
 
const fn1 = s => s.toLowerCase();
const fn2 = s => s.split('').reverse().join('');
const fn3 = s => s '!'
 
const newFunc = pipe(fn1, fn2, fn3);
const result = newFunc('Time'); // emit!

可以看到,这个实现与 compose() 几乎完全一样。唯一的不同之处是,这里是用 .reduce(),而不是 .reduceRight(),即是从左到右缩减,而不是从右到左。

下面我们来看看用 pipe() 实现的 toSlug() 函数:

JavaScript

const toSlug = pipe( split(' '), map(toLowerCase), join('-'), encodeURIComponent ); console.log(toSlug('JS Cheerleader')); // 'js-cheerleader'

1
2
3
4
5
6
7
8
const toSlug = pipe(
  split(' '),
  map(toLowerCase),
  join('-'),
  encodeURIComponent
);
 
console.log(toSlug('JS Cheerleader')); // 'js-cheerleader'

对于我来说,这要更容易读懂一些。

骨灰级的函数式程序员用函数组合定义他们的整个应用程序。而我经常用它来消除临时变量。仔细看看 pipe() 版本的 toSlug(),你会发现一些特殊之处。

在命令式编程中,在一些变量上执行转换时,在转换的每个步骤中都会找到对变量的引用。而上面的 pipe() 实现是用无点的风格写的,就是说完全找不到它要操作的参数。

我经常将管道(pipe)用在像单元测试和 Redux 状态 reducer 这类事情上,用来消除中间变量。中间变量的存在只用来保存一个操作到下一个操作之间的临时值。

这玩意开始听起来会比较古怪,不过随着你用它练习,会发现在函数式编程中,你是在和相当抽象、广义的函数打交道,而在这样的函数中,事物的名称没那么重要。名称只会碍事。你会开始把变量当作是多余的样板。

就是说,我认为无点风格可能会被用过头。它可能会变得太密集,较难理解。但是如果你搞糊涂了,这里有一个小窍门…你可以利用 flow 来跟踪是怎么回事:

JavaScript

const trace = curry((label, x) => { console.log(`== ${ label }: ${ x }`); return x; });

1
2
3
4
const trace = curry((label, x) => {
  console.log(`== ${ label }:  ${ x }`);
  return x;
});

如下是你用它来跟踪的方法:

JavaScript

const toSlug = pipe( trace('input'), split(' '), map(toLowerCase), trace('after map'), join('-'), encodeURIComponent ); console.log(toSlug('JS Cheerleader')); // '== input: JS Cheerleader' // '== after map: js,cheerleader' // 'js-cheerleader'

1
2
3
4
5
6
7
8
9
10
11
12
13
const toSlug = pipe(
  trace('input'),
  split(' '),
  map(toLowerCase),
  trace('after map'),
  join('-'),
  encodeURIComponent
);
 
console.log(toSlug('JS Cheerleader'));
// '== input:  JS Cheerleader'
// '== after map:  js,cheerleader'
// 'js-cheerleader'

trace() 只是更通用的 tap() 的一种特殊形式,它可以让你对流过管道的每个值执行一些行为。明白了么?管道(Pipe)?水龙头(Tap)?可以像下面这样编写 tap()

JavaScript

const tap = curry((fn, x) => { fn(x); return x; });

1
2
3
4
const tap = curry((fn, x) => {
  fn(x);
  return x;
});

现在你可以看到为嘛 trace() 只是一个特殊情况下的 tap() 了:

JavaScript

const trace = label => { return tap(x => console.log(`== ${ label }: ${ x }`)); };

1
2
3
const trace = label => {
  return tap(x => console.log(`== ${ label }:  ${ x }`));
};

你应该开始对函数式编程是什么样子,以及偏函数应用柯里化如何与函数组合协作,来帮助你编写可读性更强的程序有点感觉了。

1 赞 9 收藏 2 评论

澳门新萄京官方网站 2

原文:

原文:

该项目来自于 Github 用户 Chalarangelo,目前已在 Github 上获得了 5000 多Star,精心收集了多达 48 个有用的 JavaScript 代码片段,该用户的代码可以让程序员在 30 秒甚至更少的时间内理解这些经常用到的基础算法,来看看这些 JavaScript 代码都传达出了什么吧!

Anagrams of string(带有重复项)

作者:Chalarangelo

作者:Chalarangelo

Anagrams of string(带有重复项)

使用递归。对于给定字符串中的每个字母,为字母创建字谜。使用map()将字母与每部分字谜组合,然后使用reduce()将所有字谜组合到一个数组中,最基本情况是字符串长度等于2或1。

译者:IT168  www.toutiao.com/i6498962961288135182

译者:IT168  www.toutiao.com/i6498962961288135182

使用递归。对于给定字符串中的每个字母,为字母创建字谜。使用map()将字母与每部分字谜组合,然后使用reduce()将所有字谜组合到一个数组中,最基本情况是字符串长度等于2或1。

const anagrams = str => {

  if (str.length <= 2) return str.length === 2 ? [str, str[1] str[0]] : [str];

  return str.split('').reduce((acc, letter, i) =>

    acc.concat(anagrams(str.slice(0, i) str.slice(i 1)).map(val => letter val)), []);

};

// anagrams('abc') -> ['abc','acb','bac','bca','cab','cba']

 

 

const anagrams = str => {

数组平均数

该项目来自于 Github 用户 Chalarangelo,目前已在 Github 上获得了 5000 多Star,精心收集了多达 48 个有用的 JavaScript 代码片段,该用户的代码可以让程序员在 30 秒甚至更少的时间内理解这些经常用到的基础算法,来看看这些 JavaScript 代码都传达出了什么吧!

该项目来自于 Github 用户 Chalarangelo,目前已在 Github 上获得了 5000 多Star,精心收集了多达 48 个有用的 JavaScript 代码片段,该用户的代码可以让程序员在 30 秒甚至更少的时间内理解这些经常用到的基础算法,来看看这些 JavaScript 代码都传达出了什么吧!

if (str.length <= 2) return str.length === 2 ? [str, str[1] str[0]] : [str];

使用reduce()将每个值添加到累加器,初始值为0,总和除以数组长度。

 

 

return str.split('').reduce((acc, letter, i) =>

const average = arr => arr.reduce((acc, val) => acc val, 0) / arr.length;

// average([1,2,3]) -> 2

澳门新萄京官方网站 3

澳门新萄京官方网站 4

acc.concat(anagrams(str.slice(0, i) str.slice(i 1)).map(val => letter val)), []);

大写每个单词的首字母

Anagrams of string(带有重复项)

Anagrams of string(带有重复项)

};

使用replace()匹配每个单词的第一个字符,并使用toUpperCase()来将其大写。

 

 

// anagrams('abc') -> ['abc','acb','bac','bca','cab','cba']

const capitalizeEveryWord = str => str.replace(/b[a-z]/g, char => char.toUpperCase());

使用递归。对于给定字符串中的每个字母,为字母创建字谜。使用map()将字母与每部分字谜组合,然后使用reduce()将所有字谜组合到一个数组中,最基本情况是字符串长度等于2或1。

使用递归。对于给定字符串中的每个字母,为字母创建字谜。使用map()将字母与每部分字谜组合,然后使用reduce()将所有字谜组合到一个数组中,最基本情况是字符串长度等于2或1。

数组平均数

// capitalizeEveryWord('hello world!') -> 'Hello World!'

 

 

使用reduce()将每个值添加到累加器,初始值为0,总和除以数组长度。

首字母大写

const anagrams = str => {

  if (str.length <= 2) return str.length === 2 ? [str, str[1] str[0]] : [str];

  return str.split('').reduce((acc, letter, i) =>

    acc.concat(anagrams(str.slice(0, i) str.slice(i 1)).map(val => letter val)), []);

};

// anagrams('abc') -> ['abc','acb','bac','bca','cab','cba']

const anagrams = str => {

  if (str.length <= 2) return str.length === 2 ? [str, str[1] str[0]] : [str];

  return str.split('').reduce((acc, letter, i) =>

    acc.concat(anagrams(str.slice(0, i) str.slice(i 1)).map(val => letter val)), []);

};

// anagrams('abc') -> ['abc','acb','bac','bca','cab','cba']

const average = arr => arr.reduce((acc, val) => acc val, 0) / arr.length;

使用slice(0,1)和toUpperCase()大写第一个字母,slice(1)获取字符串的其余部分。 省略lowerRest参数以保持字符串的其余部分不变,或将其设置为true以转换为小写。(注意:这和上一个示例不是同一件事情)

 

 

// average([1,2,3]) -> 2

const capitalize = (str, lowerRest = false) =>

  str.slice(0, 1).toUpperCase() (lowerRest ? str.slice(1).toLowerCase() : str.slice(1));

// capitalize('myName', true) -> 'Myname'

数组平均数

数组平均数

大写每个单词的首字母

检查回文

 

 

使用replace()匹配每个单词的第一个字符,并使用toUpperCase()来将其大写。

将字符串转换为toLowerCase(),并使用replace()从中删除非字母的字符。然后,将其转换为tolowerCase(),将('')拆分为单独字符,reverse(),join(''),与原始的非反转字符串进行比较,然后将其转换为tolowerCase()。

使用reduce()将每个值添加到累加器,初始值为0,总和除以数组长度。

使用reduce()将每个值添加到累加器,初始值为0,总和除以数组长度。

const capitalizeEveryWord = str => str.replace(/b[a-z]/g, char => char.toUpperCase());

const palindrome = str => {

  const s = str.toLowerCase().replace(/[W_]/g,'');

  return s === s.split('').reverse().join('');

}

// palindrome('taco cat') -> true

 

 

// capitalizeEveryWord('hello world!') -> 'Hello World!'

计数数组中值的出现次数

const average = arr => arr.reduce((acc, val) => acc val, 0) / arr.length;

// average([1,2,3]) -> 2

const average = arr => arr.reduce((acc, val) => acc val, 0) / arr.length;

// average([1,2,3]) -> 2

首字母大写

每次遇到数组中的特定值时,使用reduce()来递增计数器。

 

 

使用slice(0,1)和toUpperCase()大写第一个字母,slice(1)获取字符串的其余部分。 省略lowerRest参数以保持字符串的其余部分不变,或将其设置为true以转换为小写。(注意:这和上一个示例不是同一件事情)

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

// countOccurrences([1,1,2,1,2,3], 1) -> 3

大写每个单词的首字母

大写每个单词的首字母

const capitalize = (str, lowerRest = false) =>

当前URL

 

 

str.slice(0, 1).toUpperCase() (lowerRest ? str.slice(1).toLowerCase() : str.slice(1));

使用window.location.href来获取当前URL。

使用replace()匹配每个单词的第一个字符,并使用toUpperCase()来将其大写。

使用replace()匹配每个单词的第一个字符,并使用toUpperCase()来将其大写。

// capitalize('myName', true) -> 'Myname'

const currentUrl = _ => window.location.href;

// currentUrl() -> ''

 

 

检查回文

Curry

const capitalizeEveryWord = str => str.replace(/[a-z]/g, char => char.toUpperCase());

// capitalizeEveryWord('hello world!') -> 'Hello World!'

const capitalizeEveryWord = str => str.replace(/[a-z]/g, char => char.toUpperCase());

// capitalizeEveryWord('hello world!') -> 'Hello World!'

将字符串转换为toLowerCase(),并使用replace()从中删除非字母的字符。然后,将其转换为tolowerCase(),将('')拆分为单独字符,reverse(),join(''),与原始的非反转字符串进行比较,然后将其转换为tolowerCase()。

使用递归。如果提供的参数(args)数量足够,则调用传递函数f,否则返回一个curried函数f。

 

 

const palindrome = str => {

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

首字母大写

首字母大写

const s = str.toLowerCase().replace(/[W_]/g,'');

Deep flatten array

 

 

return s === s.split('').reverse().join('');

使用递归,使用reduce()来获取所有不是数组的元素,flatten每个元素都是数组。

使用slice(0,1)和toUpperCase()大写第一个字母,slice(1)获取字符串的其余部分。 省略lowerRest参数以保持字符串的其余部分不变,或将其设置为true以转换为小写。(注意:这和上一个示例不是同一件事情)

使用slice(0,1)和toUpperCase()大写第一个字母,slice(1)获取字符串的其余部分。 省略lowerRest参数以保持字符串的其余部分不变,或将其设置为true以转换为小写。(注意:这和上一个示例不是同一件事情)

}

const deepFlatten = arr =>

  arr.reduce((a, v) => a.concat(Array.isArray(v) ? deepFlatten(v) : v), []);

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

 

 

// palindrome('taco cat') -> true

数组之间的区别

const capitalize = (str, lowerRest = false) =>

  str.slice(0, 1).toUpperCase() (lowerRest ? str.slice(1).toLowerCase() : str.slice(1));

// capitalize('myName', true) -> 'Myname'

const capitalize = (str, lowerRest = false) =>

  str.slice(0, 1).toUpperCase() (lowerRest ? str.slice(1).toLowerCase() : str.slice(1));

// capitalize('myName', true) -> 'Myname'

计数数组中值的出现次数

从b创建一个Set,然后在a上使用Array.filter(),只保留b中不包含的值。

 

 

每次遇到数组中的特定值时,使用reduce()来递增计数器。

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

// difference([1,2,3], [1,2]) -> [3]

检查回文

检查回文

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

两点之间的距离

 

 

// countOccurrences([1,1,2,1,2,3], 1) -> 3

使用Math.hypot()计算两点之间的欧几里德距离。

将字符串转换为toLowerCase(),并使用replace()从中删除非字母的字符。然后,将其转换为tolowerCase(),将('')拆分为单独字符,reverse(),join(''),与原始的非反转字符串进行比较,然后将其转换为tolowerCase()。

将字符串转换为toLowerCase(),并使用replace()从中删除非字母的字符。然后,将其转换为tolowerCase(),将('')拆分为单独字符,reverse(),join(''),与原始的非反转字符串进行比较,然后将其转换为tolowerCase()。

当前URL

const distance = (x0, y0, x1, y1) => Math.hypot(x1 - x0, y1 - y0);

// distance(1,1, 2,3) -> 2.23606797749979

 

 

使用window.location.href来获取当前URL。

可以按数字整除

const palindrome = str => {

  const s = str.toLowerCase().replace(/[W_]/g,'');

  return s === s.split('').reverse().join('');

}

// palindrome('taco cat') -> true

const palindrome = str => {

  const s = str.toLowerCase().replace(/[W_]/g,'');

  return s === s.split('').reverse().join('');

}

// palindrome('taco cat') -> true

const currentUrl = _ => window.location.href;

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

 

 

// currentUrl() -> ''

const isDivisible = (dividend, divisor) => dividend % divisor === 0;

// isDivisible(6,3) -> true

计数数组中值的出现次数

计数数组中值的出现次数

Curry

转义正则表达式

 

 

使用递归。如果提供的参数(args)数量足够,则调用传递函数f,否则返回一个curried函数f。

使用replace()来转义特殊字符。

每次遇到数组中的特定值时,使用reduce()来递增计数器。

每次遇到数组中的特定值时,使用reduce()来递增计数器。

const curry = (fn, arity = fn.length, ...args) =>

const escapeRegExp = str => str.replace(/[.* ?^${}()|[]\]/g, '\$&');

// escapeRegExp('(test)') -> \(test\)

 

 

arity <= args.length

偶数或奇数

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

// countOccurrences([1,1,2,1,2,3], 1) -> 3

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

// countOccurrences([1,1,2,1,2,3], 1) -> 3

? fn(...args)

使用Math.abs()将逻辑扩展为负数,使用模(%)运算符进行检查。 如果数字是偶数,则返回true;如果数字是奇数,则返回false。

 

 

: curry.bind(null, fn, arity, ...args);

const isEven = num => num % 2 === 0;

// isEven(3) -> false

当前URL

当前URL

// curry(Math.pow)(2)(10) -> 1024

阶乘

 

 

// curry(Math.min, 3)(10)(50)(2) -> 2

使用递归。如果n小于或等于1,则返回1。否则返回n和n - 1的阶乘的乘积。

使用window.location.href来获取当前URL。

使用window.location.href来获取当前URL。

Deep flatten array

const factorial = n => n <= 1 ? 1 : n * factorial(n - 1);

// factorial(6) -> 720

 

 

使用递归,使用reduce()来获取所有不是数组的元素,flatten每个元素都是数组。

斐波那契数组生成器

const currentUrl = _ => window.location.href;

// currentUrl() -> ''

const currentUrl = _ => window.location.href;

// currentUrl() -> ''

const deepFlatten = arr =>

创建一个特定长度的空数组,初始化前两个值(0和1)。使用Array.reduce()向数组中添加值,后面的一个数等于前面两个数相加之和(前两个除外)。

 

 

arr.reduce((a, v) => a.concat(Array.isArray(v) ? deepFlatten(v) : v), []);

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]

Curry

Curry

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

过滤数组中的非唯一值

 

 

数组之间的区别

将Array.filter()用于仅包含唯一值的数组。

使用递归。如果提供的参数(args)数量足够,则调用传递函数f,否则返回一个curried函数f。

使用递归。如果提供的参数(args)数量足够,则调用传递函数f,否则返回一个curried函数f。

从b创建一个Set,然后在a上使用Array.filter(),只保留b中不包含的值。

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

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

 

 

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

Flatten数组

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

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

// difference([1,2,3], [1,2]) -> [3]

使用reduce()来获取数组中的所有元素,并使用concat()来使它们flatten。

 

 

两点之间的距离

const flatten = arr => arr.reduce((a, v) => a.concat(v), []);

// flatten([1,[2],3,4]) -> [1,2,3,4]

Deep flatten array

Deep flatten array

使用Math.hypot()计算两点之间的欧几里德距离。

从数组中获取最大值

 

 

const distance = (x0, y0, x1, y1) => Math.hypot(x1 - x0, y1 - y0);

使用Math.max()与spread运算符(...)结合得到数组中的最大值。

使用递归,使用reduce()来获取所有不是数组的元素,flatten每个元素都是数组。

使用递归,使用reduce()来获取所有不是数组的元素,flatten每个元素都是数组。

// distance(1,1, 2,3) -> 2.23606797749979

const arrayMax = arr => Math.max(...arr);

// arrayMax([10, 1, 5]) -> 10

 

 

可以按数字整除

从数组中获取最小值

const deepFlatten = arr =>

  arr.reduce((a, v) => a.concat(Array.isArray(v) ? deepFlatten(v) : v), []);

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

const deepFlatten = arr =>

  arr.reduce((a, v) => a.concat(Array.isArray(v) ? deepFlatten(v) : v), []);

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

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

使用Math.min()与spread运算符(...)结合得到数组中的最小值。

 

 

const isDivisible = (dividend, divisor) => dividend % divisor === 0;

const arrayMin = arr => Math.min(...arr);

// arrayMin([10, 1, 5]) -> 1

数组之间的区别

数组之间的区别

// isDivisible(6,3) -> true

获取滚动位置

 

 

转义正则表达式

如果已定义,请使用pageXOffset和pageYOffset,否则使用scrollLeft和scrollTop,可以省略el来使用window的默认值。

从b创建一个Set,然后在a上使用Array.filter(),只保留b中不包含的值。

从b创建一个Set,然后在a上使用Array.filter(),只保留b中不包含的值。

使用replace()来转义特殊字符。

const getScrollPos = (el = window) =>

  ({x: (el.pageXOffset !== undefined) ? el.pageXOffset : el.scrollLeft,

    y: (el.pageYOffset !== undefined) ? el.pageYOffset : el.scrollTop});

// getScrollPos() -> {x: 0, y: 200}

 

 

const escapeRegExp = str => str.replace(/[.* ?^${}()|[]\]/g, '\$&');

最大公约数(GCD)

 

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

// difference([1,2,3], [1,2]) -> [3]

 

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

// difference([1,2,3], [1,2]) -> [3]

// escapeRegExp('(test)') -> \(test\澳门新萄京官方网站:代码片段,精心搜聚的。)

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

 

 

偶数或奇数

const gcd = (x, y) => !y ? x : gcd(y, x % y);

// gcd (8, 36) -> 4

两点之间的距离

两点之间的距离

使用Math.abs()将逻辑扩展为负数,使用模(%)运算符进行检查。 如果数字是偶数,则返回true;如果数字是奇数,则返回false。

Head of list

 

 

const isEven = num => num % 2 === 0;

返回ARR[0]

使用Math.hypot()计算两点之间的欧几里德距离。

使用Math.hypot()计算两点之间的欧几里德距离。

// isEven(3) -> false

const head = arr => arr[0];

// head([1,2,3]) -> 1

 

 

阶乘

list初始化

const distance = (x0, y0, x1, y1) => Math.hypot(x1 - x0, y1 - y0);

// distance(1,1, 2,3) -> 2.23606797749979

const distance = (x0, y0, x1, y1) => Math.hypot(x1 - x0, y1 - y0);

// distance(1,1, 2,3) -> 2.23606797749979

使用递归。如果n小于或等于1,则返回1。否则返回n和n - 1的阶乘的乘积。

返回arr.slice(0,-1)

 

 

const factorial = n => n <= 1 ? 1 : n * factorial(n - 1);

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

// initial([1,2,3]) -> [1,2]

可以按数字整除

可以按数字整除

// factorial(6) -> 720

用range初始化数组

 

 

斐波那契数组生成器

使用Array(end-start)创建所需长度的数组,使用map()来填充范围中的所需值,可以省略start使用默认值0。

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

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

创建一个特定长度的空数组,初始化前两个值(0和1)。使用Array.reduce()向数组中添加值,后面的一个数等于前面两个数相加之和(前两个除外)。

const initializeArrayRange = (end, start = 0) =>

  Array.apply(null, Array(end - start)).map((v, i) => i start);

// initializeArrayRange(5) -> [0,1,2,3,4]

 

 

const fibonacci = n =>

用值初始化数组

const isDivisible = (dividend, divisor) => dividend % divisor === 0;

// isDivisible(6,3) -> true

const isDivisible = (dividend, divisor) => dividend % divisor === 0;

// isDivisible(6,3) -> true

Array(n).fill(0).reduce((acc, val, i) => acc.concat(i > 1 ? acc[i

使用Array(n)创建所需长度的数组,fill(v)以填充所需的值,可以忽略value使用默认值0。

 

 

  • 1] acc[i - 2] : i), []);

 

转义正则表达式

转义正则表达式

// fibonacci(5) -> [0,1,1,2,3]

const initializeArray = (n, value = 0) => Array(n).fill(value);

// initializeArray(5, 2) -> [2,2,2,2,2]

 

 

过滤数组中的非唯一值

列表的最后

使用replace()来转义特殊字符。

使用replace()来转义特殊字符。

将Array.filter()用于仅包含唯一值的数组。

返回arr.slice(-1)[0]

 

 

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

const last = arr => arr.slice(-1)[0];

// last([1,2,3]) -> 3

const escapeRegExp = str => str.replace(/[.* ?^${}()|[]]/g, '$&');

// escapeRegExp('(test)') -> (test)

const escapeRegExp = str => str.replace(/[.* ?^${}()|[]]/g, '$&');

// escapeRegExp('(test)') -> (test)

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

测试功能所花费的时间

 

 

Flatten数组

使用performance.now()获取函数的开始和结束时间,console.log()所花费的时间。第一个参数是函数名,随后的参数传递给函数。

偶数或奇数

偶数或奇数

使用reduce()来获取数组中的所有元素,并使用concat()来使它们flatten。

const timeTaken = callback => {

  console.time('timeTaken');

  const r = callback();

  console.timeEnd('timeTaken');

  return r;

};

// timeTaken(() => Math.pow(2, 10)) -> 1024

// (logged): timeTaken: 0.02099609375ms

 

 

const flatten = arr => arr.reduce((a, v) => a.concat(v), []);

来自键值对的对象

使用Math.abs()将逻辑扩展为负数,使用模(%)运算符进行检查。 如果数字是偶数,则返回true;如果数字是奇数,则返回false。

使用Math.abs()将逻辑扩展为负数,使用模(%)运算符进行检查。 如果数字是偶数,则返回true;如果数字是奇数,则返回false。

// flatten([1,[2],3,4]) -> [1,2,3,4]

使用Array.reduce()来创建和组合键值对。

 

 

从数组中获取最大值

const objectFromPairs = arr => arr.reduce((a, v) => (a[v[0]] = v[1], a), {});

// objectFromPairs([['a',1],['b',2]]) -> {a: 1, b: 2}

const isEven = num => num % 2 === 0;

// isEven(3) -> false

const isEven = num => num % 2 === 0;

// isEven(3) -> false

使用Math.max()与spread运算符(...)结合得到数组中的最大值。

管道

 

 

const arrayMax = arr => Math.max(...arr);

使用Array.reduce()通过函数传递值。

阶乘

阶乘

// arrayMax([10, 1, 5]) -> 10

const pipe = (...funcs) => arg => funcs.reduce((acc, func) => func(acc), arg);

// pipe(btoa, x => x.toUpperCase())("Test") -> "VGVZDA=="

Powerset

 

 

从数组中获取最小值

使用reduce()与map()结合来遍历元素,并将其组合成包含所有组合的数组。

使用递归。如果n小于或等于1,则返回1。否则返回n和n - 1的阶乘的乘积。

使用递归。如果n小于或等于1,则返回1。否则返回n和n - 1的阶乘的乘积。

使用Math.min()与spread运算符(...)结合得到数组中的最小值。

const powerset = arr =>

  arr.reduce((a, v) => a.concat(a.map(r => [v].concat(r))), [[]]);

// powerset([1,2]) -> [[], [1], [2], [2,1]]

 

 

const arrayMin = arr => Math.min(...arr);

 

const factorial = n => n <= 1 ? 1 : n * factorial(n - 1);

// factorial(6) -> 720

const factorial = n => n <= 1 ? 1 : n * factorial(n - 1);

// factorial(6) -> 720

// arrayMin([10, 1, 5]) -> 1

范围内的随机整数

 

 

获取滚动位置

 

斐波那契数组生成器

斐波那契数组生成器

如果已定义,请使用pageXOffset和pageYOffset,否则使用scrollLeft和scrollTop,可以省略el来使用window的默认值。

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

 

 

const getScrollPos = (el = window) =>

const randomIntegerInRange = (min, max) => Math.floor(Math.random() * (max - min 1)) min;

创建一个特定长度的空数组,初始化前两个值(0和1)。使用Array.reduce()向数组中添加值,后面的一个数等于前面两个数相加之和(前两个除外)。

创建一个特定长度的空数组,初始化前两个值(0和1)。使用Array.reduce()向数组中添加值,后面的一个数等于前面两个数相加之和(前两个除外)。

({x: (el.pageXOffset !== undefined) ? el.pageXOffset : el.scrollLeft,

// randomIntegerInRange(0, 5) -> 2

 

 

y: (el.pageYOffset !== undefined) ? el.pageYOffset : el.scrollTop});

范围内的随机数

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]

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]

// getScrollPos() -> {x: 0, y: 200}

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

 

 

最大公约数(GCD)

const randomInRange = (min, max) => Math.random() * (max - min) min;

// randomInRange(2,10) -> 6.0211363285087005

过滤数组中的非唯一值

过滤数组中的非唯一值

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

随机化数组的顺序

 

 

const gcd = (x, y) => !y ? x : gcd(y, x % y);

使用sort()重新排序元素,利用Math.random()来随机排序。

将Array.filter()用于仅包含唯一值的数组。

将Array.filter()用于仅包含唯一值的数组。

// gcd (8, 36) -> 4

const shuffle = arr => arr.sort(() => Math.random() - 0.5);

// shuffle([1,2,3]) -> [2,3,1]

 

 

Head of list

重定向到URL

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

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

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

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

返回ARR[0]

使用window.location.href或window.location.replace()重定向到url。 传递第二个参数来模拟链接点击(true - default)或HTTP重定向(false)。

 

 

const head = arr => arr[0];

const redirect = (url, asLink = true) =>

  asLink ? window.location.href = url : window.location.replace(url);

// redirect('')

Flatten数组

Flatten数组

// head([1,2,3]) -> 1

反转一个字符串

 

 

list初始化

使用数组解构和Array.reverse()来颠倒字符串中的字符顺序。合并字符以使用join('')获取字符串。

使用reduce()来获取数组中的所有元素,并使用concat()来使它们flatten。

使用reduce()来获取数组中的所有元素,并使用concat()来使它们flatten。

返回arr.slice(0,-1)

const reverseString = str => [...str].reverse().join('');

// reverseString('foobar') -> 'raboof'

 

 

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

RGB到十六进制

const flatten = arr => arr.reduce((a, v) => a.concat(v), []);

// flatten([1,[2],3,4]) -> [1,2,3,4]

const flatten = arr => arr.reduce((a, v) => a.concat(v), []);

// flatten([1,[2],3,4]) -> [1,2,3,4]

// initial([1,2,3]) -> [1,2]

使用按位左移运算符(<<)和toString(16),然后padStart(6,“0”)将给定的RGB参数转换为十六进制字符串以获得6位十六进制值。

 

 

用range初始化数组

const rgbToHex = (r, g, b) => ((r << 16) (g << 8) b).toString(16).padStart(6, '0');

// rgbToHex(255, 165, 1) -> 'ffa501'

从数组中获取最大值

从数组中获取最大值

使用Array(end-start)创建所需长度的数组,使用map()来填充范围中的所需值,可以省略start使用默认值0。

滚动到顶部

 

 

const initializeArrayRange = (end, start = 0) =>

使用document.documentElement.scrollTop或document.body.scrollTop获取到顶部的距离。

使用Math.max()与spread运算符(...)结合得到数组中的最大值。

使用Math.max()与spread运算符(...)结合得到数组中的最大值。

Array.apply(null, Array(end - start)).map((v, i) => i start);

从顶部滚动一小部分距离。

 

 

// initializeArrayRange(5) -> [0,1,2,3,4]

使用window.requestAnimationFrame()来滚动。

const arrayMax = arr => Math.max(...arr);

// arrayMax([10, 1, 5]) -> 10

const arrayMax = arr => Math.max(...arr);

// arrayMax([10, 1, 5]) -> 10

用值初始化数组

const scrollToTop = _ => {

  const c = document.documentElement.scrollTop || document.body.scrollTop;

  if (c > 0) {

    window.requestAnimationFrame(scrollToTop);

    window.scrollTo(0, c - c / 8);

  }

};

// scrollToTop()

 

 

使用Array(n)创建所需长度的数组,fill(v)以填充所需的值,可以忽略value使用默认值0。

随机数组值

从数组中获取最小值

从数组中获取最小值

const initializeArray = (n, value = 0) => Array(n).fill(value);

使用Array.map()和Math.random()创建一个随机值的数组。使用Array.sort()根据随机值对原始数组的元素进行排序。

 

 

// initializeArray(5, 2) -> [2,2,2,2,2]

 

使用Math.min()与spread运算符(...)结合得到数组中的最小值。

使用Math.min()与spread运算符(...)结合得到数组中的最小值。

列表的最后

 数组之间的相似性

 

 

返回arr.slice(-1)[0]

 

const arrayMin = arr => Math.min(...arr);

// arrayMin([10, 1, 5]) -> 1

const arrayMin = arr => Math.min(...arr);

// arrayMin([10, 1, 5]) -> 1

const last = arr => arr.slice(-1)[0];

  使用filter()移除不是values的一部分值,使用includes()确定。

 

 

// last([1,2,3]) -> 3

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

// similarity([1,2,3], [1,2,4]) -> [1,2]

获取滚动位置

获取滚动位置

测试功能所花费的时间

 

 

 

使用performance.now()获取函数的开始和结束时间,console.log()所花费的时间。第一个参数是函数名,随后的参数传递给函数。

 按字符串排序(按字母顺序排列)

如果已定义,请使用pageXOffset和pageYOffset,否则使用scrollLeft和scrollTop,可以省略el来使用window的默认值。

如果已定义,请使用pageXOffset和pageYOffset,否则使用scrollLeft和scrollTop,可以省略el来使用window的默认值。

const timeTaken = callback => {

 

 

 

console.time('timeTaken');

  使用split('')分割字符串,sort()使用localeCompare(),使用join('')重新组合。

const getScrollPos = (el = window) =>

  ({x: (el.pageXOffset !== undefined) ? el.pageXOffset : el.scrollLeft,

    y: (el.pageYOffset !== undefined) ? el.pageYOffset : el.scrollTop});

// getScrollPos() -> {x: 0, y: 200}

const getScrollPos = (el = window) =>

  ({x: (el.pageXOffset !== undefined) ? el.pageXOffset : el.scrollLeft,

    y: (el.pageYOffset !== undefined) ? el.pageYOffset : el.scrollTop});

// getScrollPos() -> {x: 0, y: 200}

const r = callback();

const sortCharactersInString = str =>

  str.split('').sort((a, b) => a.localeCompare(b)).join('');

// sortCharactersInString('cabbage') -> 'aabbceg'

 

 

console.timeEnd('timeTaken');

 

最大公约数(GCD)

最大公约数(GCD)

return r;

数组总**

 

 

};

 

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

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

// timeTaken(() => Math.pow(2, 10)) -> 1024

使用reduce()将每个值添加到累加器,初始化值为0。

 

 

// (logged): timeTaken: 0.02099609375ms

const sum = arr => arr.reduce((acc, val) => acc val, 0);

// sum([1,2,3,4]) -> 10

const gcd = (x, y) => !y ? x : gcd(y, x % y);

// gcd (8, 36) -> 4

const gcd = (x, y) => !y ? x : gcd(y, x % y);

// gcd (8, 36) -> 4

来自键值对的对象

 

 

 

使用Array.reduce()来创建和组合键值对。

交换两个变量的值

Head of list

Head of list

const objectFromPairs = arr => arr.reduce((a, v) => (a[v[0]] = v[1], a), {});

 

 

 

// objectFromPairs([['a',1],['b',2]]) -> {a: 1, b: 2}

 使用数组解构来交换两个变量之间的值。

返回ARR[0]

返回ARR[0]

管道

[varA, varB] = [varB, varA];

// [x, y] = [y, x]

 

 

使用Array.reduce()通过函数传递值。

列表的tail

const head = arr => arr[0];

// head([1,2,3]) -> 1

const head = arr => arr[0];

// head([1,2,3]) -> 1

const pipe = (...funcs) => arg => funcs.reduce((acc, func) => func(acc), arg);

返回arr.slice(1)

 

 

// pipe(btoa, x => x.toUpperCase())("Test") -> "VGVZDA=="

const tail = arr => arr.length > 1 ? arr.slice(1) : arr;

// tail([1,2,3]) -> [2,3]

// tail([1]) -> [1]

list初始化

list初始化

Powerset

数组唯一值

 

 

使用reduce()与map()结合来遍历元素,并将其组合成包含所有组合的数组。

使用ES6 Set和... rest操作符去掉所有重复值。

返回arr.slice(0,-1)

返回arr.slice(0,-1)

const powerset = arr =>

const unique = arr => [...new Set(arr)];

// unique([1,2,2,3,4,4,5]) -> [1,2,3,4,5]

 

 

arr.reduce((a, v) => a.concat(a.map(r => [v].concat(r))), [[]]);

URL参数

 

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

// initial([1,2,3]) -> [1,2]

 

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

// initial([1,2,3]) -> [1,2]

// powerset([1,2]) -> [[], [1], [2], [2,1]]

使用match() 与适当的正则表达式来获得所有键值对,适当的map() 。使用Object.assign()和spread运算符(...)将所有键值对组合到一个对象中,将location.search作为参数传递给当前url。

 

 

范围内的随机整数

const getUrlParameters = url =>

  url.match(/([^?=&] )(=([^&]*))/g).reduce(

    (a, v) => (a[v.slice(0, v.indexOf('='))] = v.slice(v.indexOf('=') 1), a), {}

  );

// getUrlParameters('') -> {name: 'Adam', surname: 'Smith'}

用range初始化数组

用range初始化数组

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

UUID生成器

 

 

const randomIntegerInRange = (min, max) => Math.floor(Math.random() * (max - min 1)) min;

使用crypto API生成符合RFC4122版本4的UUID。

使用Array(end-start)创建所需长度的数组,使用map()来填充范围中的所需值,可以省略start使用默认值0。

使用Array(end-start)创建所需长度的数组,使用map()来填充范围中的所需值,可以省略start使用默认值0。

// randomIntegerInRange(0, 5) -> 2

const uuid = _ =>

  ([1e7] -1e3 -4e3 -8e3 -1e11).replace(/[018]/g, c =>

    (c ^ crypto.getRandomValues(new Uint8Array(1))[0] & 15 >> c / 4).toString(16)

  );

// uuid() -> '7982fcfe-5721-4632-bede-6000885be57d'

 

 

范围内的随机数

验证数字

const initializeArrayRange = (end, start = 0) =>

  Array.apply(null, Array(end - start)).map((v, i) => i start);

// initializeArrayRange(5) -> [0,1,2,3,4]

const initializeArrayRange = (end, start = 0) =>

  Array.apply(null, Array(end - start)).map((v, i) => i start);

// initializeArrayRange(5) -> [0,1,2,3,4]

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

使用!isNaN和parseFloat()来检查参数是否是一个数字,使用isFinite()来检查数字是否是有限的。

 

 

const randomInRange = (min, max) => Math.random() * (max - min) min;

const validateNumber = n => !isNaN(parseFloat(n)) && isFinite(n) && Number(n) == n;

// validateNumber('10') -> true

用值初始化数组

用值初始化数组

// randomInRange(2,10) -> 6.0211363285087005

 

 

随机化数组的顺序

使用Array(n)创建所需长度的数组,fill(v)以填充所需的值,可以忽略value使用默认值0。

使用Array(n)创建所需长度的数组,fill(v)以填充所需的值,可以忽略value使用默认值0。

使用sort()重新排序元素,利用Math.random()来随机排序。

 

 

const shuffle = arr => arr.sort(() => Math.random() - 0.5);

const initializeArray = (n, value = 0) => Array(n).fill(value);

// initializeArray(5, 2) -> [2,2,2,2,2]

const initializeArray = (n, value = 0) => Array(n).fill(value);

// initializeArray(5, 2) -> [2,2,2,2,2]

// shuffle([1,2,3]) -> [2,3,1]

 

 

重定向到URL

列表的最后

列表的最后

使用window.location.href或window.location.replace()重定向到url。 传递第二个参数来模拟链接点击(true - default)或HTTP重定向(false)。

 

 

const redirect = (url, asLink = true) =>

返回arr.slice(-1)[0]

返回arr.slice(-1)[0]

asLink ? window.location.href = url : window.location.replace(url);

 

 

// redirect('')

const last = arr => arr.slice(-1)[0];

// last([1,2,3]) -> 3

const last = arr => arr.slice(-1)[0];

// last([1,2,3]) -> 3

反转一个字符串

 

 

使用数组解构和Array.reverse()来颠倒字符串中的字符顺序。合并字符以使用join('')获取字符串。

测试功能所花费的时间

测试功能所花费的时间

const reverseString = str => [...str].reverse().join('');

 

 

// reverseString('foobar') -> 'raboof'

使用performance.now()获取函数的开始和结束时间,console.log()所花费的时间。第一个参数是函数名,随后的参数传递给函数。

使用performance.now()获取函数的开始和结束时间,console.log()所花费的时间。第一个参数是函数名,随后的参数传递给函数。

RGB到十六进制

 

 

使用按位左移运算符(<<)和toString(16),然后padStart(6,“0”)将给定的RGB参数转换为十六进制字符串以获得6位十六进制值。

const timeTaken = callback => {

  console.time('timeTaken');

  const r = callback();

  console.timeEnd('timeTaken');

  return r;

};

// timeTaken(() => Math.pow(2, 10)) -> 1024

// (logged): timeTaken: 0.02099609375ms

const timeTaken = callback => {

  console.time('timeTaken');

  const r = callback();

  console.timeEnd('timeTaken');

  return r;

};

// timeTaken(() => Math.pow(2, 10)) -> 1024

// (logged): timeTaken: 0.02099609375ms

const rgbToHex = (r, g, b) => ((r << 16) (g << 8) b).toString(16).padStart(6, '0');

 

 

// rgbToHex(255, 165, 1) -> 'ffa501'

来自键值对的对象

来自键值对的对象

滚动到顶部

 

 

使用document.documentElement.scrollTop或document.body.scrollTop获取到顶部的距离。

使用Array.reduce()来创建和组合键值对。

使用Array.reduce()来创建和组合键值对。

从顶部滚动一小部分距离。

 

 

使用window.requestAnimationFrame()来滚动。

const objectFromPairs = arr => arr.reduce((a, v) => (a[v[0]] = v[1], a), {});

// objectFromPairs([['a',1],['b',2]]) -> {a: 1, b: 2}

const objectFromPairs = arr => arr.reduce((a, v) => (a[v[0]] = v[1], a), {});

// objectFromPairs([['a',1],['b',2]]) -> {a: 1, b: 2}

const scrollToTop = _ => {

 

 

const c = document.documentElement.scrollTop || document.body.scrollTop;

管道

管道

if (c > 0) {

 

 

window.requestAnimationFrame(scrollToTop);

使用Array.reduce()通过函数传递值。

使用Array.reduce()通过函数传递值。

window.scrollTo(0, c - c / 8);

 

 

}

const pipe = (...funcs) => arg => funcs.reduce((acc, func) => func(acc), arg);

// pipe(btoa, x => x.toUpperCase())("Test") -> "VGVZDA=="

const pipe = (...funcs) => arg => funcs.reduce((acc, func) => func(acc), arg);

// pipe(btoa, x => x.toUpperCase())("Test") -> "VGVZDA=="

};

 

 

// scrollToTop()

Powerset

Powerset

随机数组值

 

 

使用Array.map()和Math.random()创建一个随机值的数组。使用Array.sort()根据随机值对原始数组的元素进行排序。

使用reduce()与map()结合来遍历元素,并将其组合成包含所有组合的数组。

使用reduce()与map()结合来遍历元素,并将其组合成包含所有组合的数组。

数组之间的相似性

 

 

使用filter()移除不是values的一部分值,使用includes()确定。

const powerset = arr =>

  arr.reduce((a, v) => a.concat(a.map(r => [v].concat(r))), [[]]);

// powerset([1,2]) -> [[], [1], [2], [2,1]]

const powerset = arr =>

  arr.reduce((a, v) => a.concat(a.map(r => [v].concat(r))), [[]]);

// powerset([1,2]) -> [[], [1], [2], [2,1]]

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

 

 

// similarity([1,2,3], [1,2,4]) -> [1,2]

范围内的随机整数

范围内的随机整数

按字符串排序(按字母顺序排列)

 

 

使用split('')分割字符串,sort()使用localeCompare(),使用join('')重新组合。

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

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

const sortCharactersInString = str =>

 

 

str.split('').sort((a, b) => a.localeCompare(b)).join('');

const randomIntegerInRange = (min, max) => Math.floor(Math.random() * (max - min 1)) min;

// randomIntegerInRange(0, 5) -> 2

const randomIntegerInRange = (min, max) => Math.floor(Math.random() * (max - min 1)) min;

// randomIntegerInRange(0, 5) -> 2

// sortCharactersInString('cabbage') -> 'aabbceg'

 

 

数组总和

范围内的随机数

范围内的随机数

使用reduce()将每个值添加到累加器,初始化值为0。

 

 

const sum = arr => arr.reduce((acc, val) => acc val, 0);

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

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

// sum([1,2,3,4]) -> 10

 

 

交换两个变量的值

const randomInRange = (min, max) => Math.random() * (max - min) min;

// randomInRange(2,10) -> 6.0211363285087005

const randomInRange = (min, max) => Math.random() * (max - min) min;

// randomInRange(2,10) -> 6.0211363285087005

使用数组解构来交换两个变量之间的值。

 

 

[varA, varB] = [varB, varA];

随机化数组的顺序

随机化数组的顺序

// [x, y] = [y, x]

 

 

列表的tail

使用sort()重新排序元素,利用Math.random()来随机排序。

使用sort()重新排序元素,利用Math.random()来随机排序。

返回arr.slice(1)

 

 

const tail = arr => arr.length > 1 ? arr.slice(1) : arr;

const shuffle = arr => arr.sort(() => Math.random() - 0.5);

// shuffle([1,2,3]) -> [2,3,1]

const shuffle = arr => arr.sort(() => Math.random() - 0.5);

// shuffle([1,2,3]) -> [2,3,1]

// tail([1,2,3]) -> [2,3]

 

 

// tail([1]) -> [1]

重定向到URL

重定向到URL

数组唯一值

 

 

使用ES6 Set和... rest操作符去掉所有重复值。

使用window.location.href或window.location.replace()重定向到url。 传递第二个参数来模拟链接点击(true - default)或HTTP重定向(false)。

使用window.location.href或window.location.replace()重定向到url。 传递第二个参数来模拟链接点击(true - default)或HTTP重定向(false)。

const unique = arr => [...new Set(arr)];

 

 

// unique([1,2,2,3,4,4,5]) -> [1,2,3,4,5]

const redirect = (url, asLink = true) =>

  asLink ? window.location.href = url : window.location.replace(url);

// redirect('')

const redirect = (url, asLink = true) =>

  asLink ? window.location.href = url : window.location.replace(url);

// redirect('')

URL参数

 

 

使用match() 与适当的正则表达式来获得所有键值对,适当的map() 。使用Object.assign()和spread运算符(...)将所有键值对组合到一个对象中,将location.search作为参数传递给当前url。

反转一个字符串

反转一个字符串

const getUrlParameters = url =>

 

 

url.match(/([^?=&] )(=([^&]*))/g).reduce(

使用数组解构和Array.reverse()来颠倒字符串中的字符顺序。合并字符以使用join('')获取字符串。

使用数组解构和Array.reverse()来颠倒字符串中的字符顺序。合并字符以使用join('')获取字符串。

(a, v) => (a[v.slice(0, v.indexOf('='))] = v.slice(v.indexOf('=') 1), a), {}

 

 

);

const reverseString = str => [...str].reverse().join('');

// reverseString('foobar') -> 'raboof'

const reverseString = str => [...str].reverse().join('');

// reverseString('foobar') -> 'raboof'

// getUrlParameters('') -> {name: 'Adam', surname: 'Smith'}

 

 

UUID生成器

RGB到十六进制

RGB到十六进制

使用crypto API生成符合RFC4122版本4的UUID。

 

 

const uuid = _ =>

使用按位左移运算符(<<)和toString(16),然后padStart(6,“0”)将给定的RGB参数转换为十六进制字符串以获得6位十六进制值。

使用按位左移运算符(<<)和toString(16),然后padStart(6,“0”)将给定的RGB参数转换为十六进制字符串以获得6位十六进制值。

([1e7] -1e3 -4e3 -8e3 -1e11).replace(/[018]/g, c =>

 

 

(c ^ crypto.getRandomValues(new Uint8Array(1))[0] & 15 >> c / 4).toString(16)

const rgbToHex = (r, g, b) => ((r << 16) (g << 8) b).toString(16).padStart(6, '0');

// rgbToHex(255, 165, 1) -> 'ffa501'

const rgbToHex = (r, g, b) => ((r << 16) (g << 8) b).toString(16).padStart(6, '0');

// rgbToHex(255, 165, 1) -> 'ffa501'

);

 

 

// uuid() -> '7982fcfe-5721-4632-bede-6000885be57d'

滚动到顶部

滚动到顶部

验证数字

 

 

使用!isNaN和parseFloat()来检查参数是否是一个数字,使用isFinite()来检查数字是否是有限的。

使用document.documentElement.scrollTop或document.body.scrollTop获取到顶部的距离。

使用document.documentElement.scrollTop或document.body.scrollTop获取到顶部的距离。

const validateNumber = n => !isNaN(parseFloat(n)) && isFinite(n) && Number(n) == n;

从顶部滚动一小部分距离。

从顶部滚动一小部分距离。

// validateNumber('10') -> true

 

 

翻译多有不准确之处,感兴趣的程序员可以自行到Github上查看英文原版。

使用window.requestAnimationFrame()来滚动。

使用window.requestAnimationFrame()来滚动。

 

 

const scrollToTop = _ => {

  const c = document.documentElement.scrollTop || document.body.scrollTop;

  if (c > 0) {

    window.requestAnimationFrame(scrollToTop);

    window.scrollTo(0, c - c / 8);

  }

};

// scrollToTop()

const scrollToTop = _ => {

  const c = document.documentElement.scrollTop || document.body.scrollTop;

  if (c > 0) {

    window.requestAnimationFrame(scrollToTop);

    window.scrollTo(0, c - c / 8);

  }

};

// scrollToTop()

 

 

随机数组值

随机数组值

 

 

使用Array.map()和Math.random()创建一个随机值的数组。使用Array.sort()根据随机值对原始数组的元素进行排序。

使用Array.map()和Math.random()创建一个随机值的数组。使用Array.sort()根据随机值对原始数组的元素进行排序。

 

 

澳门新萄京官方网站 5

澳门新萄京官方网站 6

 

 

数组之间的相似性

数组之间的相似性

 

 

使用filter()移除不是values的一部分值,使用includes()确定。

使用filter()移除不是values的一部分值,使用includes()确定。

 

 

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

// similarity([1,2,3], [1,2,4]) -> [1,2]

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

// similarity([1,2,3], [1,2,4]) -> [1,2]

 

 

按字符串排序(按字母顺序排列)

按字符串排序(按字母顺序排列)

 

 

使用split('')分割字符串,sort()使用localeCompare(),使用join('')重新组合。

使用split('')分割字符串,sort()使用localeCompare(),使用join('')重新组合。

 

 

const sortCharactersInString = str =>

  str.split('').sort((a, b) => a.localeCompare(b)).join('');

// sortCharactersInString('cabbage') -> 'aabbceg'

const sortCharactersInString = str =>

  str.split('').sort((a, b) => a.localeCompare(b)).join('');

// sortCharactersInString('cabbage') -> 'aabbceg'

 

 

数组总和

数组总和

 

 

使用reduce()将每个值添加到累加器,初始化值为0。

使用reduce()将每个值添加到累加器,初始化值为0。

 

 

const sum = arr => arr.reduce((acc, val) => acc val, 0);

// sum([1,2,3,4]) -> 10

const sum = arr => arr.reduce((acc, val) => acc val, 0);

// sum([1,2,3,4]) -> 10

 

 

交换两个变量的值

交换两个变量的值

 

 

使用数组解构来交换两个变量之间的值。

使用数组解构来交换两个变量之间的值。

 

 

[varA, varB] = [varB, varA];

// [x, y] = [y, x]

[varA, varB] = [varB, varA];

// [x, y] = [y, x]

 

 

列表的tail

列表的tail

 

 

返回arr.slice(1)

返回arr.slice(1)

 

 

const tail = arr => arr.length > 1 ? arr.slice(1) : arr;

// tail([1,2,3]) -> [2,3]

// tail([1]) -> [1]

const tail = arr => arr.length > 1 ? arr.slice(1) : arr;

// tail([1,2,3]) -> [2,3]

// tail([1]) -> [1]

 

 

数组唯一值

数组唯一值

 

 

使用ES6 Set和... rest操作符去掉所有重复值。

使用ES6 Set和... rest操作符去掉所有重复值。

 

 

const unique = arr => [...new Set(arr)];

// unique([1,2,2,3,4,4,5]) -> [1,2,3,4,5]

const unique = arr => [...new Set(arr)];

// unique([1,2,2,3,4,4,5]) -> [1,2,3,4,5]

 

 

URL参数

URL参数

 

 

使用match() 与适当的正则表达式来获得所有键值对,适当的map() 。使用Object.assign()和spread运算符(...)将所有键值对组合到一个对象中,将location.search作为参数传递给当前url。

使用match() 与适当的正则表达式来获得所有键值对,适当的map() 。使用Object.assign()和spread运算符(...)将所有键值对组合到一个对象中,将location.search作为参数传递给当前url。

 

 

const getUrlParameters = url =>

  url.match(/([^?=&] )(=([^&]*))/g).reduce(

    (a, v) => (a[v.slice(0, v.indexOf('='))] = v.slice(v.indexOf('=') 1), a), {}

  );

// getUrlParameters('') -> {name: 'Adam', surname: 'Smith'}

const getUrlParameters = url =>

  url.match(/([^?=&] )(=([^&]*))/g).reduce(

    (a, v) => (a[v.slice(0, v.indexOf('='))] = v.slice(v.indexOf('=') 1), a), {}

  );

// getUrlParameters('') -> {name: 'Adam', surname: 'Smith'}

 

 

UUID生成器

UUID生成器

 

 

使用crypto API生成符合RFC4122版本4的UUID。

使用crypto API生成符合RFC4122版本4的UUID。

 

 

const uuid = _ =>

  ([1e7] -1e3 -4e3 -8e3 -1e11).replace(/[018]/g, c =>

    (c ^ crypto.getRandomValues(new Uint8Array(1))[0] & 15 >> c / 4).toString(16)

  );

// uuid() -> '7982fcfe-5721-4632-bede-6000885be57d'

const uuid = _ =>

  ([1e7] -1e3 -4e3 -8e3 -1e11).replace(/[018]/g, c =>

    (c ^ crypto.getRandomValues(new Uint8Array(1))[0] & 15 >> c / 4).toString(16)

  );

// uuid() -> '7982fcfe-5721-4632-bede-6000885be57d'

 

 

验证数字

验证数字

 

 

使用!isNaN和parseFloat()来检查参数是否是一个数字,使用isFinite()来检查数字是否是有限的。

使用!isNaN和parseFloat()来检查参数是否是一个数字,使用isFinite()来检查数字是否是有限的。

 

 

const validateNumber = n => !isNaN(parseFloat(n)) && isFinite(n) && Number(n) == n;

// validateNumber('10') -> true

const validateNumber = n => !isNaN(parseFloat(n)) && isFinite(n) && Number(n) == n;

// validateNumber('10') -> true

 

 

翻译多有不准确之处,感兴趣的程序员可以自行到Github上查看英文原版。

翻译多有不准确之处,感兴趣的程序员可以自行到Github上查看英文原版。

本文由澳门新萄京官方网站发布于澳门新萄京赌场网址,转载请注明出处:澳门新萄京官方网站:代码片段,精心搜聚的

关键词: