代码片段,秒就可见晓

制服 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
代码都传达出了什么样啊!

作者:Chalarangelo

作者:Chalarangelo

Anagrams of string(带有重复项)

译者:IT168  www.toutiao.com/i6498962961288135182

译者:IT168  www.toutiao.com/i6498962961288135182

行使递归。对于给定字符串中的每个字母,为字母成立字谜。使用map()将字母与每部分字谜组合,然后使用reduce()将享有字谜组合到一个数组中,最要旨情形是字符串长度等于2或1。

 

 

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];

 

 

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

美高梅开户网址 3

美高梅开户网址 4

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

Anagrams of string(带有重复项)

Anagrams of string(带有重复项)

};

 

 

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

应用递归。对于给定字符串中的每个字母,为字母创造字谜。使用map()将字母与每部分字谜组合,然后选择reduce()将具备字谜组合到一个数组中,最中央景况是字符串长度等于2或1。

应用递归。对于给定字符串中的每个字母,为字母创制字谜。使用map()将字母与每部分字谜组合,然后采取reduce()将享有字谜组合到一个数组中,最焦点情状是字符串长度等于2或1。

数组平均数

 

 

利用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;

 

 

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

数组平均数

数组平均数

大写每个单词的首字母

 

 

应用replace()匹配每个单词的率先个字符,并利用toUpperCase()来将其大写。

行使reduce()将每个值添加到累加器,开头值为0,总和除以数总监度。

使用reduce()将每个值添加到累加器,早先值为0,总和除以数首席营业官度。

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

 

 

// 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

首字母大写

 

 

选拔slice(0,1)和toUpperCase()大写第四个字母,slice(1)获取字符串的其他部分。
省略lowerRest参数以维持字符串的其余部分不变,或将其安装为true以变换为小写。(注意:那和上一个演示不是一样件工作)

大写每个单词的首字母

大写每个单词的首字母

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

 

 

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

利用replace()匹配每个单词的第三个字符,并采取toUpperCase()来将其大写。

动用replace()匹配每个单词的首先个字符,并拔取toUpperCase()来将其大写。

// capitalize(‘myName’, true) -> ‘Myname’

 

 

自我批评回文

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()。

 

 

const palindrome = str => {

首字母大写

首字母大写

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

 

 

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

使用slice(0,1)和toUpperCase()大写第二个假名,slice(1)获取字符串的其他部分。
省略lowerRest参数以保全字符串的其他部分不变,或将其设置为true以转移为小写。(注意:那和上一个示范不是同样件业务)

应用slice(0,1)和toUpperCase()大写首个字母,slice(1)获取字符串的其余部分。
省略lowerRest参数以保险字符串的其他部分不变,或将其安装为true以转移为小写。(注意:那和上一个示范不是如出一辙件业务)

}

 

 

// 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’

计数数组中值的产出次数

 

 

每一回蒙受数组中的特定值时,使用reduce()来递增计数器。

自我批评回文

反省回文

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

 

 

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

将字符串转换为toLowerCase(),并利用replace()从中删除非字母的字符。然后,将其转移为tolowerCase(),将(”)拆分为独立字符,reverse(),join(”),与原有的非反转字符串举办相比较,然后将其转移为tolowerCase()。

将字符串转换为toLowerCase(),并动用replace()从中删除非字母的字符。然后,将其转移为tolowerCase(),将(”)拆分为独立字符,reverse(),join(”),与原有的非反转字符串进行比较,然后将其更换为tolowerCase()。

当前URL

 

 

行使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;

 

 

// currentUrl() -> ”

计数数组中值的面世次数

计数数组中值的产出次数

Curry

 

 

拔取递归。若是提供的参数(args)数量丰盛,则调用传递函数f,否则重返一个curried函数f。

老是遭逢数组中的特定值时,使用reduce()来递增计数器。

老是蒙受数组中的特定值时,使用reduce()来递增计数器。

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

 

 

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)

 

 

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

当前URL

当前URL

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

 

 

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

采纳window.location.href来赢得当前URL。

应用window.location.href来博取当前URL。

Deep flatten array

 

 

采取递归,使用reduce()来得到具有不是数组的因素,flatten每个元素都是数组。

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

// currentUrl() -> ”

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

// currentUrl() -> ”

const deepFlatten = arr =>

 

 

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

Curry

Curry

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

 

 

数组之间的界别

利用递归。假如提供的参数(args)数量丰盛,则调用传递函数f,否则重回一个curried函数f。

动用递归。假设提供的参数(args)数量丰盛,则调用传递函数f,否则重临一个curried函数f。

从b成立一个Set,然后在a上行使Array.filter(),只保留b中不分包的值。

 

 

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

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]

 

 

两点时期的偏离

Deep flatten array

Deep flatten array

运用Math.hypot()计算两点之间的欧几Reade距离。

 

 

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

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

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

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

 

 

能够按数字整除

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。

 

 

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

数组之间的界别

数组之间的区分

// isDivisible(6,3) -> true

 

 

转义正则表明式

从b成立一个Set,然后在a上选拔Array.filter(),只保留b中不带有的值。

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

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

 

 

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

 

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\\)

 

 

偶数或奇数

两点时期的离开

两点之间的偏离

动用Math.abs()将逻辑伸张为负数,使用模(%)运算符举行自我批评。
就算数字是偶数,则赶回true;假诺数字是奇数,则赶回false。

 

 

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

选择Math.hypot()统计两点之间的欧几Reade距离。

行使Math.hypot()计算两点时期的欧几Reade距离。

// isEven(3) -> false

 

 

阶乘

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的阶乘的乘积。

 

 

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

可以按数字整除

可以按数字整除

// factorial(6) -> 720

 

 

斐波那契数组生成器

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

利用模运算符(%)来检查余数是还是不是等于0。

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

 

 

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

 

 

  • 1] + acc[i – 2] : i), []);

转义正则说明式

转义正则表明式

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

 

 

过滤数组中的非唯一值

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

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

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

 

 

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

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数组

偶数或奇数

偶数或奇数

选择reduce()来赢得数组中的所有因素,并应用concat()来使它们flatten。

 

 

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]

 

 

从数组中赢得最大值

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

阶乘

阶乘

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

 

 

从数组中得到最小值

动用递归。如果n小于或等于1,则赶回1。否则重临n和n – 1的阶乘的乘积。

利用递归。即使n小于或等于1,则赶回1。否则再次来到n和n – 1的阶乘的乘积。

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

 

 

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的默许值。

 

 

const getScrollPos = (el = window) =>

创办一个特定长度的空数组,开头化前多少个值(0和1)。使用Array.reduce()向数组中添加值,前边的一个数等于前边三个数相加之和(前四个除外)。

创设一个特定长度的空数组,起先化前三个值(0和1)。使用Array.reduce()向数组中添加值,后边的一个数等于前边多少个数相加之和(前多个除外)。

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

 

 

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}

 

 

最大公约数(GCD)

过滤数组中的非唯一值

过滤数组中的非唯一值

利用递归。基本情形是当y等于0时。在这种状态下,再次回到x。否则,再次来到y的GCD和x
/ y的其他部分。

 

 

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

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

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

// gcd (8, 36) -> 4

 

 

Head of list

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]

 

 

const head = arr => arr[0];

Flatten数组

Flatten数组

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

 

 

list初始化

接纳reduce()来取得数组中的所有因素,并运用concat()来使它们flatten。

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

返回arr.slice(0,-1)

 

 

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

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]

 

 

用range起先化数组

从数组中得到最大值

从数组中赢得最大值

选用Array(end-start)创设所需长度的数组,使用map()来填充范围中的所需值,可以简单start使用默许值0。

 

 

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

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

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

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

 

 

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

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

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

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

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

用值早先化数组

 

 

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

从数组中取得最小值

从数组中获得最小值

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

 

 

// 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];

 

 

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

赢得滚动地方

获取滚动地点

测试成效所开支的时间

 

 

采用performance.now()获取函数的初阶和终结时间,console.log()所费用的光阴。首个参数是函数名,随后的参数传递给函数。

万一已定义,请使用pageXOffset和pageYOffset,否则使用scrollLeft和scrollTop,可以省略el来利用window的默许值。

只要已定义,请使用pageXOffset和pageYOffset,否则使用scrollLeft和scrollTop,可以省略el来利用window的默许值。

const timeTaken = callback => {

 

 

console.time(‘timeTaken’);

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

 

 

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

 

 

// (logged): timeTaken: 0.02099609375ms

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]

管道

 

 

拔取Array.reduce()通过函数传递值。

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

 

 

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

list初始化

list初始化

Powerset

 

 

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

返回arr.slice(0,-1)

返回arr.slice(0,-1)

const powerset = arr =>

 

 

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

 

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]]

 

 

限制内的自由整数

用range开首化数组

用range发轫化数组

行使Math.random()生成一个自由数并将其映射到所需的限制,使用Math.floor()使其成为一个整数。

 

 

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

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

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

// randomIntegerInRange(0, 5) -> 2

 

 

限制内的肆意数

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()生成一个随意值,使用乘法将其映射到所需的限定。

 

 

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

用值开端化数组

用值初阶化数组

// 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上查看英文原版。

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图