函數式編程：Ramda 函數庫參考教程

疫情嚴重，不能出門，但是可以在家裡學習，learn learn ,day day up

阮一峰：學習函數式編程的過程中，我接觸到了 Ramda.js。我發現，這是一個很重要的庫，提供了許多有用的方法，每個 JavaScript 程序員都應該掌握這個工具

你可能會問，Underscore 和 Lodash 已經這麼流行了，為什麼還要學習好像雷同的 Ramda 呢？

回答是，前兩者的參數位置不對，把處理的數據放到了第一個參數。

var square = n => n * n; _.map([4, 8], square) // [16, 64]

上面代碼中，_.map的第一個參數[4, 8]是要處理的數據，第二個參數square是數據要執行的運算。

Ramda 的數據一律放在最後一個參數，理念是"function first，data last"。

var R = require('ramda'); R.map(square, [4, 8]) // [16, 64]

為什麼 Underscore 和 Lodash 是錯的，而 Ramda 是對的？這放在下一篇文章詳細解釋，今天我主要介紹 Ramda 提供的幾十個方法。這是理解以後的內容所必須的。

除了數據放在最後一個參數，Ramda 還有一個特點：

也就是說，所有多參數的函數，默認都可以單參數使用。

// 寫法一R.map(square, [4, 8])// 寫法二R.map(square)([4, 8])// 或者var mapSquare = R.map(square);mapSquare([4, 8]);

上面代碼中，寫法一是多參數版本，寫法二是柯里化以後的單參數版本。Ramda 都支持，並且推薦使用第二種寫法。

由於這兩個特點，使得 Ramda 成為 JavaScript 函數式編程最理想的工具庫。今天，我先介紹它的 API，下一次再介紹這些方法如何用於實戰。我保證，一旦你理解了它的運算模型，就一定會認同這才是正確的計算方法。

API目錄

一、比較運算二、數學運算三、邏輯運算四、字符串五、函數- 5.1 函數的合成- 5.2 柯里化- 5.3 函數的執行六、數組- 6.1 數組的特徵判斷- 6.2 數組的截取和添加- 6.3 數組的過濾- 6.4 單數組運算- 6.5 雙數組運算- 6.6 複合數組七、對象- 7.1 對象的特徵判斷- 7.2 對象的過濾- 7.3 對象的截取- 7.4 對象的運算- 7.5 複合對象

一、比較運算

gt：判斷第一個參數是否大於第二個參數。

R.gt(2)(1) // true R.gt('a')('z') // false

gte：判斷第一個參數是否大於等於第二個參數。

R.gte(2)(2) // true R.gte('a')('z') // false

lt：判斷第一個參數是否小於第二個參數。

R.lt(2)(1) // false R.lt('a')('z') // true

lte：判斷第一個參數是否小於等於第二個參數。

R.lte(2)(2) // true R.lte('a')('z') // true

equals：比較兩個值是否相等（支持對象的比較）。

R.equals(1)(1) // true R.equals(1)('1') // false R.equals([1, 2, 3])([1, 2, 3]) // true var a = {}; a.v = a; var b = {}; b.v = b; R.equals(a)(b) // true

eqBy：比較兩個值傳入指定函數的運算結果是否相等。

R.eqBy(Math.abs, 5)(-5) // true

二、數學運算

add：返回兩個值的和。

R.add(7)(10) // 17

subtract：返回第一個參數減第二個參數的差。

R.subtract(10)(8) // 2

multiply：返回兩個值的積。

R.multiply(2)(5) // 10

divide：返回第一個參數除以第二個參數的商。

R.divide(71)(100) // 0.71

三、邏輯運算

either：接受兩個函數作為參數，只要有一個返回true，就返回true，否則返回false。相當於||運算。

var gt10 = x => x > 10; var even = x => x % 2 === 0; var f = R.either(gt10, even); f(101) // true f(8) // true

both：接受兩個函數作為參數，只有它們都返回true，才返回true，否則返回false，相當於&&運算。

 
var gt10 = x => x > 10; var even = x => x % 2 === 0; var f = R.both(gt10, even); f(15) // false f(30) // true

allPass：接受一個函數數組作為參數，只有它們都返回true，才返回true，否則返回false。

var gt10 = x => x > 10; var even = x => x % 2 === 0; var isEvenAndGt10 = R.allPass([gt10, even]); isEvenAndGt10(15) // false isEvenAndGt10(30) // true

四、字符串

split：按照指定分隔符將字符串拆成一個數組。

R.split('.')('a.b.c.xyz.d') // ['a', 'b', 'c', 'xyz', 'd']

test：判斷一個字符串是否匹配給定的正則表達式。

R.test(/^x/)('xyz') // true R.test(/^y/)('xyz') // false

match：返回一個字符串的匹配結果。

R.match(/([a-z]a)/g)('bananas') // ['ba', 'na', 'na'] R.match(/a/)('b') // [] R.match(/a/)(null) // TypeError: null does not have a method named "match"

五、函數

5.1 函數的合成

compose：將多個函數合併成一個函數，從右到左執行。

R.compose(Math.abs, R.add(1),           R.multiply(2))(-4) // 7 

pipe：將多個函數合併成一個函數，從左到右執行。

var negative = x => -1 * x; var increaseOne = x => x + 1; var f = R.pipe(Math.pow, negative, increaseOne); f(3, 4) // -80 => -(3^4) + 1

converge：接受兩個參數，第一個參數是函數，第二個參數是函數數組。傳入的值先使用第二個參數包含的函數分別處理以後，再用第一個參數處理前一步生成的結果。

var sumOfArr = arr => {

var sum = 0;

arr.forEach(i => sum += i);

return sum;

};

var lengthOfArr = arr => arr.length;

var average = R.converge(R.divide, [sumOfArr, lengthOfArr])

average([1, 2, 3, 4, 5, 6, 7]) // 4 // 相當於 28 除以 7

var toUpperCase = s => s.toUpperCase();

var toLowerCase = s => s.toLowerCase();

var strangeConcat = R.converge(R.concat, [toUpperCase, toLowerCase]) strangeConcat("Yodel") // "YODELyodel" // 相當於 R.concat('YODEL', 'yodel')

5.2 柯里化

curry：將多參數的函數，轉換成單參數的形式。

var addFourNumbers = (a, b, c, d) => a + b + c + d; var curriedAddFourNumbers = R.curry(addFourNumbers); var f = curriedAddFourNumbers(1, 2); var g = f(3); g(4) // 10

partial：允許多參數的函數接受一個數組，指定最左邊的部分參數。

var multiply2 = (a, b) => a * b; var double = R.partial(multiply2, [2]); double(2) // 4 var greet = (salutation, title, firstName, lastName) => salutation + ', ' + title + ' ' + firstName + ' ' + lastName + '!'; var sayHello = R.partial(greet, ['Hello']); var sayHelloToMs = R.partial(sayHello, ['Ms.']); sayHelloToMs('Jane', 'Jones'); //=> 'Hello, Ms. Jane Jones!'

partialRight：與partial類似，但數組指定的參數為最右邊的參數。

var greet = (salutation, title, firstName, lastName) => salutation + ', ' + title + ' ' + firstName + ' ' + lastName + '!'; var greetMsJaneJones = R.partialRight(greet, ['Ms.', 'Jane', 'Jones']); greetMsJaneJones('Hello') // 'Hello, Ms. Jane Jones!'

useWith：接受一個函數fn和一個函數數組fnList作為參數，返回fn的柯里化版本。該新函數的參數，先分別經過對應的fnList成員處理，再傳入fn執行。

var decreaseOne = x => x - 1; var increaseOne = x => x + 1; R.useWith(Math.pow, [decreaseOne, increaseOne])(3, 4) // 32 R  .useWith(Math.pow, [decreaseOne, increaseOne])(3)(4) // 32

memoize：返回一個函數，會緩存每一次的運行結果。

var productOfArr = arr => { var product = 1;                            arr.forEach(i => product *= i); return product; }; var count = 0; var factorial = R.memoize(n => { count += 1; return productOfArr(R.range(1, n + 1)); }); factorial(5) // 120 factorial(5) // 120 factorial(5) // 120 count // 1

complement：返回一個新函數，如果原函數返回true，該函數返回false；如果原函數返回false，該函數返回true。

var gt10 = x => x > 10; var lte10 = R.complement(gt10); gt10(7) // false lte10(7) // true 

5.3 函數的執行

binary：參數函數執行時，只傳入最前面兩個參數。

var takesThreeArgs = function(a, b, c) {   return [a, b, c]; }; var takesTwoArgs = R.binary(takesThreeArgs); takesTwoArgs(1, 2, 3) // [1, 2, undefined]

tap：將一個值傳入指定函數，並返回該值。

var sayX = x => console.log('x is ' + x); R.tap(sayX)(100) // 100 R.pipe( R.assoc('a', 2),        R.tap(console.log), R.assoc('a', 3) )({a: 1}) // {a: 3}

zipWith：將兩個數組對應位置的值，一起作為參數傳入某個函數。

var f = (x, y) => {  // ... };   R.zipWith(f, [1, 2, 3])(['a', 'b', 'c']) // [f(1, 'a'), f(2, 'b'), f(3, 'c')]

apply：將數組轉成參數序列，傳入指定函數。

var nums = [1, 2, 3, -99, 42, 6, 7]; R.apply(Math.max)(nums) // 42

applySpec：返回一個模板函數，該函數會將參數傳入模板內的函數執行，然後將執行結果填充到模板。

var getMetrics = R.applySpec({ sum: R.add, nested: { mul: R.multiply } }); getMetrics(2, 4) // { sum: 6, nested: { mul: 8 } }

ascend：返回一個升序排列的比較函數，主要用於排序。

var byAge = R.ascend(R.prop('age')); var people = [   // ... ];  var peopleByYoungestFirst = R.sort(byAge)(people);

descend：返回一個降序排列的比較函數，主要用於排序。

var byAge = R.descend(R.prop('age')); var people = [  // ... ];   var peopleByOldestFirst = R.sort(byAge)(people);

6.1 數組的特徵判斷

contains：如果包含某個成員，返回true。

R.contains(3)([1, 2, 3]) // true R.contains(4)([1, 2, 3]) // false R.contains({ name: 'Fred' })([{ name: 'Fred' }]) // true R.contains([42])([[42]]) // true

all：所有成員都滿足指定函數時，返回true，否則返回false

var equals3 = R.equals(3); R.all(equals3)([3, 3, 3, 3]) // true R.all(equals3)([3, 3, 1, 3]) // false

any：只要有一個成員滿足條件，就返回true。

var lessThan0 = R.flip(R.lt)(0); var lessThan2 = R.flip(R.lt)(2); R.any(lessThan0)([1, 2]) // false R.any(lessThan2)([1, 2]) // true

none：沒有成員滿足條件時，返回true。

var isEven = n => n % 2 === 0; R.none(isEven)([1, 3, 5, 7, 9, 11]) // trueR.none(isEven)([1, 3, 5, 7, 8, 11]) // false

6.2 數組的截取和添加

head：返回數組的第一個成員。

R.head(['fi', 'fo', 'fum']) // 'fi' R.head([]) // undefined R.head('abc') // 'a' R.head('') // ''

last：返回數組的最後一個成員。

R.last(['fi', 'fo', 'fum']) // 'fum' R.last([]) // undefined R.last('abc') // 'c' R.last('') // ''

tail：返回第一個成員以外的所有成員組成的新數組。

R.tail([1, 2, 3]) // [2, 3] R.tail([1, 2]) // [2] R.tail([1]) // [] R.tail([]) // [] R.tail('abc') // 'bc' R.tail('ab') // 'b' R.tail('a') // '' R.tail('') // ''

init：返回最後一個成員以外的所有成員組成的新數組。

R.init([1, 2, 3]) // [1, 2] R.init([1, 2]) // [1] R.init([1]) // [] R.init([]) // [] R.init('abc') // 'ab' R.init('ab') // 'a' R.init('a') // '' R.init('') // ''

nth：取出指定位置的成員。

var list = ['foo', 'bar', 'baz', 'quux']; R.nth(1)(list) // 'bar' R.nth(-1)(list) // 'quux' R.nth(-99)(list) // undefined R.nth(2)('abc') // 'c' R.nth(3)('abc') // ''

take：取出前 n 個成員。

R.take(1)(['foo', 'bar', 'baz']) // ['foo'] R.take(2)(['foo', 'bar', 'baz']) // ['foo', 'bar'] R.take(3)(['foo', 'bar', 'baz']) // ['foo', 'bar', 'baz'] R.take(4)(['foo', 'bar', 'baz']) // ['foo', 'bar', 'baz'] R.take(3)('ramda') // 'ram'

takeLast：取出後 n 個成員。

R.takeLast(1)(['foo', 'bar', 'baz']) // ['baz'] R.takeLast(2)(['foo', 'bar', 'baz']) // ['bar', 'baz'] R.takeLast(3)(['foo', 'bar', 'baz']) // ['foo', 'bar', 'baz'] R.takeLast(4)(['foo', 'bar', 'baz']) // ['foo', 'bar', 'baz'] R.takeLast(3)('ramda') // 'mda'

slice：從起始位置（包括）開始，到結束位置（不包括）為止，從原數組截取出一個新數組。

R.slice(1, 3)(['a', 'b', 'c', 'd']) // ['b', 'c'] R.slice(1, Infinity)(['a', 'b', 'c', 'd']) // ['b', 'c', 'd'] R.slice(0, -1)(['a', 'b', 'c', 'd']) // ['a', 'b', 'c'] R.slice(-3, -1)(['a', 'b', 'c', 'd']) // ['b', 'c'] R.slice(0, 3)('ramda') // 'ram'

remove：移除開始位置後的n個成員。

R.remove(2, 3)([1,2,3,4,5,6,7,8]) // [1,2,6,7,8]

insert：在指定位置插入給定值。

R.insert(2, 'x')([1,2,3,4]) // [1,2,'x',3,4]

insertAll：在指定位置，插入另一個數組的所有成員。

R.insertAll(2，['x','y','z'])([1,2,3,4]) // [1,2,'x','y','z',3,4]

prepend：在數組頭部插入一個成員

R.prepend('fee')(['fi', 'fo', 'fum']) // ['fee', 'fi', 'fo', 'fum']

append：在數組尾部追加新的成員。

R.append('tests')(['write', 'more']) // ['write', 'more', 'tests'] R.append('tests')([]) // ['tests'] R.append(['tests'])(['write', 'more']) // ['write', 'more', ['tests']]

intersperse：在數組成員之間插入表示分隔的成員。

R.intersperse('n')(['ba', 'a', 'a']) // ['ba', 'n', 'a', 'n', 'a']

join：將數組合併成一個字符串，並在成員之間插入分隔符。

R.join('|')([1, 2, 3]) // '1|2|3'

6.3 數組的過濾

filter：過濾出符合條件的成員。

var isEven = n => n % 2 === 0; R.filter(isEven)([1, 2, 3, 4]) // [2, 4]

reject：過濾出所有不滿足條件的成員。

var isOdd = (n) => n % 2 === 1; R.reject(isOdd)([1, 2, 3, 4]) // [2, 4]

takeWhile： 一旦滿足條件，後面的成員都會被過濾。

var isNotFour = x => x !== 4; R.takeWhile(isNotFour)([1, 2, 3, 4, 3, 2, 1]) // [1, 2, 3]

dropWhile：一旦不滿足條件，取出剩餘的所有成員。

var lteTwo = x => x <= 2; R.dropWhile(lteTwo)([1, 2, 3, 4, 3, 2, 1]) // [3, 4, 3, 2, 1]

without：返回指定值以外的成員。

R.without([1, 2])([1, 2, 1, 3, 4]) // [3, 4]

6.4 單數組運算

countBy：對每個成員執行指定函數以後，返回一個對象，表示各種執行結果分別包含多少成員。

var numbers = [1.0, 1.1, 1.2, 2.0, 3.0, 2.2]; R.countBy(Math.floor)(numbers) // {'1': 3, '2': 2, '3': 1}var letters = ['a', 'b', 'A', 'a', 'B', 'c']; R.countBy(R.toLower)(letters) // {'a': 3, 'b': 2, 'c': 1}

splitAt：在給定位置，將原數組分成兩個部分。

R.splitAt(1)([1, 2, 3]) // [[1], [2, 3]] R.splitAt(5)('hello world') // ['hello', ' world'] R.splitAt(-1)('foobar') // ['fooba', 'r']

splitEvery：按照指定的個數，將原數組分成多個部分。

R.splitEvery(3)([1, 2, 3, 4, 5, 6, 7]) // [[1, 2, 3], [4, 5, 6], [7]] R.splitEvery(3)('foobarbaz') // ['foo', 'bar', 'baz']

splitWhen：以第一個滿足指定函數的成員為界，將數組分成兩個部分。

R.splitWhen(R.equals(2))([1, 2, 3, 1, 2, 3]) // [[1], [2, 3, 1, 2, 3]]

aperture：每個成員與其後給定數量的成員分成一組，這些組構成一個新的數組。

R.aperture(3)([1, 2, 3, 4, 5, 6, 7]) // [[1, 2, 3], [2, 3, 4], [3, 4, 5], [4, 5, 6], [5, 6, 7]]

partition：根據是否滿足指定函數，將成員分區。

R.partition(R.contains('s'))(['sss', 'ttt', 'foo', 'bars']) // => [ [ 'sss', 'bars' ], [ 'ttt', 'foo' ] ]

indexOf：某個值在數組中第一次出現的位置。

R.indexOf(3)([1,2,3,4]) // 2 R.indexOf(10)([1,2,3,4]) // -1

lastIndexOf：某個值在數組中最後一次出現的位置。

R.lastIndexOf(3)([-1,3,3,0,1,2,3,4]) // 6 R.lastIndexOf(10)([1,2,3,4]) // -1

map：數組的每個成員依次執行某個函數。

var double = x => x * 2; R.map(double)([1, 2, 3]) // [2, 4, 6]

mapIndexed：與map類似，區別是遍歷函數可以額外獲得兩個參數：索引位置和原數組。

var mapIndexed = R.addIndex(R.map); mapIndexed( (val, idx) => idx + '-' + val, ['f', 'o', 'o', 'b', 'a', 'r'] ) // ['0-f', '1-o', '2-o', '3-b', '4-a', '5-r']

forEach：數組的每個成員依次執行某個函數，總是返回原數組。

var printXPlusFive = x => console.log(x + 5); R.forEach(printXPlusFive, [1, 2, 3]) // [1, 2, 3] // logs 6 // logs 7 // logs 8

reduce：數組成員依次執行指定函數，每一次的運算結果都會進入一個累積變量。

var mySubtract = function (a, b) { return a - b; }; R.reduce(mySubtract, 0)([1, 2, 3, 4]) // -10

reduceRight：與reduce類似，區別是數組成員從左到右執行。

R.reduceRight(R.subtract, 0)([1, 2, 3, 4]) // -2

reduceWhile：與reduce類似，區別是有一個判斷函數，一旦數組成員不符合條件，就停止累積。

var isOdd = (acc, x) => x % 2 === 1; var xs = [1, 3, 5, 60, 777, 800]; R.reduceWhile(isOdd, R.add, 0)(xs) // 9 var ys = [2, 4, 6]; R.reduceWhile(isOdd, R.add, 111)(ys) // 111

sort：按照給定函數，對數組進行排序。

var diff = function(a, b) { return a - b; }; R.sort(diff)([4,2,7,5]) // [2, 4, 5, 7]

sortWith：按照給定的一組函數，進行多重排序。

var alice = { name: 'alice', age: 40 }; var bob = { name: 'bob', age: 30 }; var clara = { name: 'clara', age: 40 }; var people = [clara, bob, alice]; var ageNameSort = R.sortWith([ R.descend(R.prop('age')),                               R.ascend(R.prop('name')) ]); ageNameSort(people); //=> [alice, clara, bob]

adjust：對指定位置的成員執行給定的函數。

R.adjust(R.add(10), 1)([1, 2, 3]) // [1, 12, 3] R.adjust(R.add(10)，1)([1, 2, 3]) // [1, 12, 3]

ap：數組成員分別執行一組函數，將結果合成為一個新數組。

R.ap([R.multiply(2), R.add(3)])([1,2,3]) // [2, 4, 6, 4, 5, 6] R.ap([R.concat('tasty '), R.toUpper])(['pizza', 'salad']) // ["tasty pizza", "tasty salad", "PIZZA", "SALAD"]

flatten：將嵌套數組鋪平。

R.flatten([1, 2, [3, 4], 5, [6, [7, 8, [9, [10, 11], 12]]]]) // [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12] 

groupBy：將數組成員依次按照指定條件兩兩比較，並按照結果將所有成員放入子數組。

R.groupWith(R.equals)([0, 1, 1, 2, 3, 5, 8, 13, 21]) // [[0], [1, 1], [2], [3], [5], [8], [13], [21]] R.groupWith((a, b) => a % 2 === b % 2)([0, 1, 1, 2, 3, 5, 8, 13, 21]) // [[0], [1, 1], [2], [3, 5], [8], [13, 21]] R.groupWith(R.eqBy(isVowel), 'aestiou') //=> ['ae', 'st', 'iou']

6.5 雙數組運算

concat：將兩個數組合併成一個數組。

R.concat('ABC')('DEF') // 'ABCDEF' R.concat([4, 5, 6])([1, 2, 3]) // [4, 5, 6, 1, 2, 3] R.concat([])([]) // []

zip：將兩個數組指定位置的成員放在一起，生成一個新數組。

R.zip([1, 2, 3])(['a', 'b', 'c']) // [[1, 'a'], [2, 'b'], [3, 'c']]

zipObj：將兩個數組指定位置的成員分別作為鍵名和鍵值，生成一個新對象。

R.zipObj(['a', 'b', 'c'])([1, 2, 3]) // {a: 1, b: 2, c: 3}

xprod：將兩個數組的成員兩兩混合，生成一個新數組。

R.xprod([1, 2])(['a', 'b']) // [[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b']]

intersection：返回兩個數組相同的成員組成的新數組。

R.intersection([1,2,3,4], [7,6,5,4,3]) // [4, 3]

intersectionWith：返回經過某種運算，有相同結果的兩個成員。

var buffaloSpringfield = [   {id: 824, name: 'Richie Furay'},   {id: 956, name: 'Dewey Martin'},   {id: 313, name: 'Bruce Palmer'},   {id: 456, name: 'Stephen Stills'},   {id: 177, name: 'Neil Young'} ]; var csny = [   {id: 204, name: 'David Crosby'},   {id: 456, name: 'Stephen Stills'},  {id: 539, name: 'Graham Nash'},   {id: 177, name: 'Neil Young'} ]; R.intersectionWith(R.eqBy(R.prop('id'))，buffaloSpringfield)(csny) // [{id: 456, name: 'Stephen Stills'}, {id: 177, name: 'Neil Young'}]

difference：返回第一個數組不包含在第二個數組裡面的成員。

R.difference([1,2,3,4])([7,6,5,4,3]) // [1,2] R.difference([7,6,5,4,3])([1,2,3,4]) // [7,6,5] R.difference([{a: 1}, {b: 2}])([{a: 1}, {c: 3}]) // [{b: 2}]

differenceWith：返回執行指定函數後，第一個數組裡面不符合條件的所有成員。

var cmp = (x, y) => x.a === y.a; var l1 = [{a: 1}, {a: 2}, {a: 3}]; var l2 = [{a: 3}, {a: 4}];R.differenceWith(cmp, l1)(l2) // [{a: 1}, {a: 2}]

symmetricDifference：返回兩個數組的非共有成員所組成的一個新數組。

R.symmetricDifference([1,2,3,4])([7,6,5,4,3]) // [1,2,7,6,5] R.symmetricDifference([7,6,5,4,3])([1,2,3,4]) // [7,6,5,1,2]

symmetricDifferenceWith：根據指定條件，返回兩個數組所有運算結果不相等的成員所組成的新數組。

var eqA = R.eqBy(R.prop('a')); var l1 = [{a: 1}, {a: 2}, {a: 3}, {a: 4}]; var l2 = [{a: 3}, {a: 4}, {a: 5}, {a: 6}]; R.symmetricDifferenceWith(eqA, l1, l2) // [{a: 1}, {a: 2}, {a: 5}, {a: 6}]

6.6 複合數組

find：返回符合指定條件的成員。

var xs = [{a: 1}, {a: 2}, {a: 3}]; R.find(R.propEq('a', 2))(xs) // {a: 2} R.find(R.propEq('a', 4))(xs) // undefined

findIndex：返回符合指定條件的成員的位置。

var xs = [{a: 1}, {a: 2}, {a: 3}]; R.findIndex(R.propEq('a', 2))(xs) // 1 R.findIndex(R.propEq('a', 4))(xs) // -1

findLast：返回最後一個符合指定條件的成員。

var xs = [{a: 1, b: 0}, {a:1, b: 1}]; R.findLast(R.propEq('a', 1))(xs) // {a: 1, b: 1} R.findLast(R.propEq('a', 4))(xs) // undefined

findLastIndex：返回最後一個符合指定條件的成員的位置。

var xs = [{a: 1, b: 0}, {a:1, b: 1}]; R.findLastIndex(R.propEq('a', 1))(xs) // 1 R.findLastIndex(R.propEq('a', 4))(xs) // -1

pluck：取出數組成員的某個屬性，組成一個新數組。

R.pluck('a')([{a: 1}, {a: 2}]) // [1, 2] R.pluck(0)([[1, 2], [3, 4]]) // [1, 3]

project：取出數組成員的多個屬性，組成一個新數組。

var abby = {name: 'Abby', age: 7, hair: 'blond', grade: 2}; var fred = {name: 'Fred', age: 12, hair: 'brown', grade: 7}; var kids = [abby, fred]; R.project(['name', 'grade'])(kids) // [{name: 'Abby', grade: 2}, {name: 'Fred', grade: 7}]

transpose：將每個成員相同位置的值，組成一個新數組。

R.transpose([[1, 'a'], [2, 'b'], [3, 'c']]) // [[1, 2, 3], ['a', 'b', 'c']] R.transpose([[1, 2, 3], ['a', 'b', 'c']]) // [[1, 'a'], [2, 'b'], [3, 'c']] R.transpose([[10, 11], [20], [], [30, 31, 32]]) // [[10, 20, 30], [11, 31], [32]]

mergeAll：將數組的成員合併成一個對象。

R.mergeAll([{foo:1},{bar:2},{baz:3}]) // {foo:1,bar:2,baz:3} R.mergeAll([{foo:1},{foo:2},{bar:2}]) // {foo:2, bar:2}

fromPairs：將嵌套數組轉為一個對象。

R.fromPairs([['a', 1], ['b', 2], ['c', 3]]) // {a: 1, b: 2, c: 3}

groupBy：將數組成員按照指定條件分組。

var byGrade = R.groupBy(function(student) {   var score = student.score;   return score < 65 ? 'F' : score < 70 ? 'D' : score < 80 ? 'C' : score < 90 ? 'B' : 'A';}); var students = [  {name: 'Abby', score: 84},  {name: 'Eddy', score: 58}, // ...  {name: 'Jack', score: 69}]; byGrade(students); // { // 'A': [{name: 'Dianne', score: 99}], // 'B': [{name: 'Abby', score: 84}] // // ..., // 'F': [{name: 'Eddy', score: 58}] // }

sortBy：根據成員的某個屬性排序。

var sortByFirstItem = R.sortBy(R.prop(0)); sortByFirstItem([[-1, 1], [-2, 2], [-3, 3]]) // [[-3, 3], [-2, 2], [-1, 1]] var sortByNameCaseInsensitive = R.sortBy( R.compose(R.toLower, R.prop('name')) );var alice = {name: 'ALICE', age: 101}; var bob = {name: 'Bob', age: -10}; var clara = {name: 'clara', age: 314.159}; var people = [clara, bob, alice]; sortByNameCaseInsensitive(people) // [alice, bob, clara]

七、對象

7.1 對象的特徵判斷

has: 返回一個布爾值，表示對象自身是否具有該屬性。

var hasName = R.has('name') hasName({name: 'alice'}) //=> true hasName({name: 'bob'}) //=> true hasName({}) //=> false var point = {x: 0, y: 0}; var pointHas = R.has(R.__, point); pointHas('x') // true pointHas('y') // true pointHas('z') // false

hasIn：返回一個布爾值，表示對象自身或原型鏈上是否具有某個屬性。

function Rectangle(width, height) {   this.width = width;   this.height = height;}Rectangle.prototype.area = function() {   return this.width * this.height;}; var square = new Rectangle(2, 2); R.hasIn('width')(square) // true R.hasIn('area')(square) // true

propEq：如果屬性等於給定值，返回true。

var abby = {name: 'Abby', age: 7, hair: 'blond'}; var fred = {name: 'Fred', age: 12, hair: 'brown'}; var rusty = {name: 'Rusty', age: 10, hair: 'brown'}; var alois = {name: 'Alois', age: 15, disposition: 'surly'}; var kids = [abby, fred, rusty, alois];var hasBrownHair = R.propEq('hair', 'brown');R.filter(hasBrownHair)(kids) // [fred, rusty]

whereEq：如果屬性等於給定值，返回true。

var pred = R.whereEq({a: 1, b: 2}); pred({a: 1}) // falsepred({a: 1, b: 2}) // true pred({a: 1, b: 2, c: 3}) // true pred({a: 1, b: 1}) // false

where：如果各個屬性都符合指定條件，返回true。

var pred = R.where({ a: R.equals('foo'), b:                     R.complement(R.equals('bar')), x: R.gt(__, 10), y: R.lt(__, 20) }); pred({a: 'foo', b: 'xxx', x: 11, y: 19}) // true pred({a: 'xxx', b: 'xxx', x: 11, y: 19}) // false pred({a: 'foo', b: 'bar', x: 11, y: 19}) // false pred({a: 'foo', b: 'xxx', x: 10, y: 19}) // false pred({a: 'foo', b: 'xxx', x: 11, y: 20}) // false

7.2 對象的過濾

omit：過濾指定屬性。

R.omit(['a', 'd'])({a: 1, b: 2, c: 3, d: 4}) // {b: 2, c: 3}

filter：返回所有滿足條件的屬性

var isEven = n => n % 2 === 0; R.filter(isEven)({a: 1, b: 2, c: 3, d: 4}) // {b: 2, d: 4}

reject：返回所有不滿足條件的屬性

var isOdd = (n) => n % 2 === 1;R.reject(isOdd)({a: 1, b: 2, c: 3, d: 4}) // {b: 2, d: 4} 

7.3 對象的截取

dissoc：過濾指定屬性。

R.dissoc('b')({a: 1, b: 2, c: 3}) // {a: 1, c: 3}

assoc：添加或改寫某個屬性。

R.assoc('c', 3)({a: 1, b: 2}) // {a: 1, b: 2, c: 3}

partition：根據屬性值是否滿足給定條件，將屬性分區。

R.partition(R.contains('s'))({ a: 'sss', b: 'ttt', foo: 'bars' }) // [ { a: 'sss', foo: 'bars' }, { b: 'ttt' } ]

pick：返回指定屬性組成的新對象

R.pick(['a', 'd'])({a: 1, b: 2, c: 3, d: 4}) // {a: 1, d: 4}R.pick(['a', 'e', 'f'])({a: 1, b: 2, c: 3, d: 4}) // {a: 1}

pickAll：與pick類似，但會包括不存在的屬性。

R.pickAll(['a', 'd'])({a: 1, b: 2, c: 3, d: 4}) // {a: 1, d: 4} R.pickAll(['a', 'e', 'f'])({a: 1, b: 2, c: 3, d: 4}) // {a: 1, e: undefined, f: undefined}

pickBy：返回符合條件的屬性

var isUpperCase = (val, key) => key.toUpperCase() === key; R.pickBy(isUpperCase)({a: 1, b: 2, A: 3, B: 4}) // {A: 3, B: 4}

keys：返回對象自身屬性的屬性名組成的新數組。

R.keys({a: 1, b: 2, c: 3}) // ['a', 'b', 'c']

keysIn：返回對象自身的和繼承的屬性的屬性名組成的新數組。

var F = function() { this.x = 'X'; }; F.prototype.y = 'Y';var f = new F(); R.keysIn(f) // ['x', 'y']

values：返回對象自身的屬性的屬性值組成的數組。

R.values({a: 1, b: 2, c: 3}); //=> [1, 2, 3]

valuesIn：返回對象自身的和繼承的屬性的屬性值組成的數組。

var F = function() { this.x = 'X'; }; F.prototype.y = 'Y'; var f = new F(); R.valuesIn(f) // ['X', 'Y']

invertObj：將屬性值和屬性名互換。如果多個屬性的屬性值相同，只返回最後一個屬性。

var raceResultsByFirstName = { first: 'alice', second: 'jake', third: 'alice', }; R.invertObj(raceResultsByFirstName) // {"alice": "third", "jake": "second"}

invert：將屬性值和屬性名互換，每個屬性值對應一個數組。

var raceResultsByFirstName = { first: 'alice', second: 'jake', third: 'alice', };R.invert(raceResultsByFirstName) // { 'alice': ['first', 'third'], 'jake':['second'] }

7.4 對象的運算

prop：返回對象的指定屬性

R.prop('x')({x: 100}) // 100 R.prop('x')({}) // undefined

map：對象的所有屬性依次執行某個函數。

var double = x => x * 2; R.map(double)({x: 1, y: 2, z: 3}) // {x: 2, y: 4, z: 6}

mapObjIndexed：與map類似，但是會額外傳入屬性名和整個對象。

var values = { x: 1, y: 2, z: 3 }; var prependKeyAndDouble = (num, key, obj) => key + (num * 2); R.mapObjIndexed(prependKeyAndDouble)(values) // { x: 'x2', y: 'y4', z: 'z6' }

forEachObjIndexed：每個屬性依次執行給定函數，給定函數的參數分別是屬性值和屬性名，返回原對象。

var printKeyConcatValue = (value, key) => console.log(key + ':' + value);R.forEachObjIndexed(printKeyConcatValue)({x: 1, y: 2}) // {x: 1, y: 2} // logs x:1 // logs y:2

merge：合併兩個對象，如果有同名屬性，後面的值會覆蓋掉前面的值。

R.merge({ 'name': 'fred', 'age': 10 })({ 'age': 40 }) // { 'name': 'fred', 'age': 40 } var resetToDefault = R.merge(R.__, {x: 0}); resetToDefault({x: 5, y: 2}) // {x: 0, y: 2}

mergeWith：合併兩個對象，如果有同名屬性，會使用指定的函數處理。

R.mergeWith(   R.concat,   { a: true, values: [10, 20] },   { b: true, values: [15, 35] }); // { a: true, b: true, values: [10, 20, 15, 35] } 

eqProps：比較兩個對象的指定屬性是否相等。

var o1 = { a: 1, b: 2, c: 3, d: 4 }; var o2 = { a: 10, b: 20, c: 3, d: 40 }; R.eqProps('a', o1)(o2) // false R.eqProps('c', o1)(o2) // true

R.evolve：對象的屬性分別經過一組函數的處理，返回一個新對象。

var tomato = { firstName: ' Tomato ', data: {elapsed: 100, remaining: 1400}, id: 123 }; var transformations = {   firstName: R.trim,   lastName: R.trim, // 不會被調用   data: {    elapsed: R.add(1),     remaining: R.add(-1)  } };                        R.evolve(transformations)(tomato) // { // firstName: 'Tomato', // data: {elapsed: 101, remaining: 1399}, // id: 123 // }

7.5 複合對象

path：取出數組中指定路徑的值。

R.path(['a', 'b'], {a: {b: 2}}) // 2 R.path(['a', 'b'], {c: {b: 2}}) // undefined

pathEq：返回指定路徑的值符合條件的成員

var user1 = { address: { zipCode: 90210 } }; var user2 = { address: { zipCode: 55555 } }; var user3 = { name: 'Bob' }; var users = [ user1, user2, user3 ]; var isFamous = R.pathEq(['address', 'zipCode'], 90210); R.filter(isFamous)(users) // [ user1 ]

assocPath：添加或改寫指定路徑的屬性的值。

R.assocPath(['a', 'b', 'c'], 42)({a: {b: {c: 0}}}) // {a: {b: {c: 42}}}R.assocPath(['a', 'b', 'c'], 42)({a: 5}) // {a: {b: {c: 42}}}

閱讀更多 前端在路上 的文章

關鍵字: 數學 教程 泛函編程