代码片段,秒就可精晓

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

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

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

亚洲必赢官网 1

谷歌 数据主导管道 — 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,总和除以数COO度。

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,总和除以数CEO度。

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地图