函数式编程——学习笔记

函数式编程中的函数指的不是程序中的函数方法，而是数学中的函数即映射关系，是对运算过程的抽象，是用来描述数据之间的映射

// 非函数式
let a = 1, b = 2, c = a + b;
console.log(c)

// 函数式
const aa = (a, b) => {
    return a + b
}
let c = aa(1, 2)
console.log(c)

函数式编程语言的特性

函数是一等公民

  1. 函数可以存储在变量中
  2. 函数可以作为参数
  3. 函数可以作为返回值

高阶函数

什么是高阶函数？
  1. 函数可以作为参数传递给另一个函数
  2. 函数可以作为另一个函数的返回结果
函数作为参数
// 模拟forEach,打印数组中的每一项
const forEach = (arr, fn) => {
    for (let i = 0; i < arr.length; i++) {
        fn(arr[i])
    }
}
let c = [1, 2, 3, 4, 5];
forEach(arr, (item) => {
    console.log(item)
})

// 模拟filter,把满足条件的每一项存储下来并返回
const filter = (arr, fn) => {
    let result = [];
    for (let i = 0; i < arr.length; i++) {
        if (fn(arr[i])) {
            result.push(arr[i])
        }
    }
    return result
}

// 测试
let arr = [1, 2, 4, 7, 8];
filter(arr, (item) => {
    return item % 2 === 0
})
函数作为返回值
const makeFn = () => {
    let msg = 'hello function';
    return () => {
        console.log(msg)
    }
}
makeFn()();

// 模拟lodash中的once,只执行一次
const once = (fn) => {
    let done = false;
    return function () {
        if (!done) {
            done = true;
            return fn.apply(this, arguments);
        }
    }
}

let pay = once((money) => {
    console.log('gg', money)
    console.log(`支付了${money}RMB`)
});

pay(9);

使用高阶函数的意义

高阶函数是用来抽象通用问题，抽象可以帮我们屏蔽细节，我们只用关注实现的目标

// 模拟常用的高阶函数：map、every、some
// map 遍历数组中的每一项,将满足条件的项存入新的数组并返回
const map = (array, fn) => {
    let result = [];
    for (let value of array) {
        result.push(fn(value))
    }
    return result
}

// 测试
console.log(map([1, 2, 3, 4], v => v * v))

// every 检测数组所有元素是否都符合指定条件，有一项不满足条件就返回false，剩余的元素不会再进行检测。
const every = (array, fn) => {
    let result = true;
    for (let value of array) {
        if (!fn(value)) {
            result = false;
            break;
        }
    }
    return result
}
// 测试
console.log(every([5, 7, 6,], v => v > 10));

// some 检测数组中的元素是否满足指定条件，如果有一个元素满足指定条件就返回true,剩余的元素不会再继续检测。
const some = (array, fn) => {
    let result = true;
    for (let value of array) {
        if (fn(value)) {
            result = true;
        }
    }
    return result
}
// 测试
console.log(some([5, 8, 9, 3], (v) => v > 2));

闭包

含义：

  1. 函数和其周围的状态（语法环境）的引用捆绑在一起形成闭包。

  2. 可以在另一个作用域中调用一个函数的内部函数并访问到该函数的作用域中的成员

本质：函数在执行的时候会放到一个执行栈上，当函数执行完毕会从执行栈上移除，但是堆上的作用于成员因为被外部引用不能释放，因此内部函数依然可以访问外部函数的成员。

function makePower(power) {
   return function (number) {
       return Math.pow(number, power)
   }
}

// 求平方
let power2 = makePower(2);
// 求立方
let power3 = makePower(3);

console.log(power2(2))
console.log(power2(3))
console.log(power3(4))

纯函数

纯函数的概念

相同的输入永远会得到相同的输出，而且没有任何可观察的副作用

  1. 纯函数就类似数学中的函数，用来描述输入和输出的关系

  2. lodash是一个纯函数的功能库，提供了对数组，数字，对象，字符串，函数等操作方法

  3. 数组的slice和splic分别是纯函数和不纯的函数

    slice返回数组中的指定部分，不会改变原数组

    splice对数组进行操作返回该数组，会改变原数组

let numbers = [1, 2, 3, 4, 5] 
//纯函数 
numbers.slice(0, 3) // => [1, 2, 3] 
numbers.slice(0, 3) // => [1, 2, 3] 
numbers.slice(0, 3) // => [1, 2, 3] 
    
// 不纯的函数 
numbers.splice(0, 3) // => [1, 2, 3] 
numbers.splice(0, 3) // => [4, 5] 
numbers.splice(0, 3) // => []

纯函数代表：lodash

纯函数的好处：

1、可缓存，因为纯函对于相同输入始终具有相同输出，所以可以把纯函数的结果缓存起来

2、可测试，纯函数让测试更方便

3、并行处理，在多线程环境下并行操作共享的内存数据很有可能出现意外的情况；纯函数只依赖参数，不需要访问共享的内存数据，所以在并行环境下可以任意运行纯函数（web worker）

函数的副作用：

// 不纯的 
let mini = 18
function checkAge(age) {
    return age >= mini
}
// 纯的(有硬编码，后续可以通过柯里化解决) 
function checkAge(age) {
    let mini = 18
    return age >= mini
}

副作用让一个纯函数变的不纯，如上例，纯函数根据相同的输入返回相同的输出，如果函数依赖于外部的状态就无法保证输出相同，就会带来副作用

副作用的来源：配置文件、数据库、获取用户的输入...

所有的外部交互都有可能带来副作用，副作用也使得方法通用性下降不适合扩展和重用性，同时副作用会给程序带来安全隐患给程序带来不确定性，但是副作用不可能完全禁止，尽可能控制它们在可控范围内发生。

柯里化

当一个函数有多个参数的时候先传递一部分参数调用它（这部分参数以后永远不变），然后返回一个新的函数接收剩余的参数，返回结果

lodash中的柯里化

// 柯里化案例
''.match(/\s+/g);// 提取字符串中的空白字符
''.match(/\d+/g);// 提取字符串中的数字
const _ = require('lodash');

const match = _.curry((reg, str) => str.match(reg));

const haveSpace = match(/\s+/g);
const haveNumber = match(/\d+/g);

// console.log(haveSpace('hello  word'))
// console.log(haveNumber('333adg'))

// 操作数组

const filter = _.curry((func, array) => array.filter(func))

// 获取数组中具有空白字符的元素
const findSpace = filter(haveSpace);

console.log(findSpace(['fsf,vvv ,kkk  l']));

柯里化实现原理


// 模拟柯里化实现原理

const getSum = (a, b, c) => a + b + c;

// 模拟lodash中curry方法
const curry = (func) => {
    return function curriedFn(...args) {
        // 判断形参和实参的个数
        if (args.length < func.length) {
            return function () {
                return curriedFn(...args.concat(Array.from(arguments)))
            }
        }
        return func(...args)
    }
}
const curried = curry(getSum);
console.log(curried(1)(2, 3)); // 6
console.log(curried(1, 2)(3));// 6
console.log(curried(1, 2, 3));// 6
总结

柯里化可以让我们给一个函数传递较少的参数得到一个已经记住啦某些固定参数的新函数

这是一种对函数参数的缓存

让函数变得更灵活，让函数的粒度更小

可以把多元函数转成一元函数，可以组合使用函数产生强大的功能

函数组合

如果一个函数需要经过多个函数处理才能得到最终只，这个时候可以把中间过程的函数组合成一个函数

// 函数组合
const compose = (f, g) => {
    return function (value) {
        return f(g(value))
    }
}

// 反转数组
const reverse = (array) => {
    return array.reverse()
}
// 获取数组的第一个元素
const first = (array) => {
    return array[0]
}

const last = compose(first, reverse);

console.log(last([1, 2, 3, 4, 5, 6,]));

lodash中的组合函数

// 模拟lodash中的flowRight
// const _ = require('lodash');
const reverse = arr => arr.reverse();
const first = arr => arr[0];
const toUpper = s => s.toUpperCase();

// const compose = (...args) => {
//     return (value) => {
//         return args.reverse().reduce((acc, fn) => {
//             return fn(acc)
//         }, value)
//     }
// }
// ES6
const compose = (...args) => value => args.reverse().reduce((acc, fn) => fn(acc), value)

const f = compose(toUpper, first, reverse);
console.log(f(['one', 'two', 'three']));

函数结合律

// 函数结合需要满足结合律
const _ = require('lodash');

const f = _.flowRight(_.toUpper, flowRight(_.first, _.reverse));
console.log(f(['one', 'two', 'three']));

函数组合调试

// 函数结合 调试
// NEVER SAY DIE --->never-say-die
const _ = require('lodash');

const trace = _.curry((tag, v) => {
    console.log(tag, v)
    return v
})

const split = _.curry((sep, str) => _.split(str, sep))

const join = _.curry((sep, array) => _.join(array, sep))
const map = _.curry((fn, array) => _.map(array, fn));

const f = _.flowRight(join('-'), trace('map之后'), map(_.toLower),trace('split之后'), split(' '));


console.log(f('NEVER SAY DIE'))

lodash模块数据优先，函数置后

lodash/fp模块函数优先，数据置后

// lodash和lodash/fp模块中map方法的区别
const _ = require('lodash');
console.log(_map(["23", "8", "10"]), parseInt);
// parseInt("23",0,array)
// parseInt("8",1,array)
// parseInt("10",2,array)

const fp = require('lodash/fp');
console.log(fp.map(parseInt, ["23", "8", "10"]))

PointFree

我们可以把数据处理的过程定义成与数据无关的合成运算，不需要用到代表数据的那个参
数，只要把简单的运算步骤合成到一起，在使用这种模式之前我们需要定义一些辅助的基本运算函数。

1、不需要指明处理的数据

2、只需要合并运算过程

3、需要定义一些辅助的基本运算函数

const f = fp.flowRight(fp.join('-'), trace('map之后'), fp.map(fp.toLower), trace('split之后'), fp.split(' '));

案例

// 非pointFree模式
// const f = (word) => word.toLowerCase().replace(/\s+/g, '_');

// pointFree模式
const fp = require('lodash/fp')
const f = fp.flowRight(fp.replace(/\s+/g, "_"), fp.toLower);
console.log(f('hello   word'))

//把一个字符串的首字符提取并转换成大写，使用. 作为分隔符
// word wild web ==>W. W. W

// pointFree模式
const fp = require('lodash/fp')
const firstLetterToUpper = fp.flowRight(fp.join('. '),fp.map(fp.flowRight(fp.first,fp.toUpper)),fp.split(' '))

console.log(firstLetterToUpper('word wild web'))

函子

函子的概念

函子是函数式编程里面最重要的数据类型，也是基本的运算单位和功能单位。

函子首先是一个容器，它包含了值和值的变形关系，这个变形关系就是函数。

函子可以把函数式编程副作用控制在可控的范围内，包括处理异常，异步操作等。
一般约定，函子的标志就是容器具有map方法。该方法将容器里面的每一个值，映射到另一个容器。

函子的基本构造

函子就是一个特殊的容器，它可以由对象来实现，这个对象中包含了值，这个值永远不会对外公布，有一个map方法，用来操作这个值。还有一个of方法，用来生成一个新的容器。

// Functor
class Container {
    static of(value) {
        return new Container(value)
    }
    constructor(value) {
        this._value = value;
    }
    map(fn) {
        return Container.of((fn(this._value)))
    }
}
let r = Container.of(5).map(x => x + 1).map(x => x * x);
console.log('r', r);

这里总结一下函子的使用

  • 程序运算不会直接操作值，而是通过函子来完成
  • 由map处理后返回的是一个新的对象，我们可以继续链式的操作值
  • 我们可以把函子想象成一个盒子，盒子中封装着一个值，当我恩处理盒子中的值的时候我们要用到盒子专门改变值的工具：map，我们需要给盒子的map方法传递一个处理值的函数(纯函数)，由这个函数来对值进行处理，最终map方法返回一个包含新值的盒子(函子)。

MayBe函子

函子会接收各种函数来处理内部的值，这里就有可能遇到错误，我们需要对这些错误做处理，MayBe函子的作用就是对外部的空值情况做处理。

MayBe函子的构造就是在map中设置空值检查

class Maybe{
   static of(value){
     return new Maybe(value)
   }

   constructor(val){
     this._value = val
   }
   map(f) {
     return this.val ? Maybe.of(f(this.val)) : Maybe.of(null);
   }
 }

虽然 MayBe函子可以避免出现错误，但是多次调用map时我们并不知道哪里出现了错误

Either函子

Either函子与if...else处理很相似。它内部有两个值，左值和右值。右值通常代表正常的值，左值是当右值不存在或错误时的默认值

class Either {
     static of(left,right){
      return new Either (left,right))
    }
    constructor(left,right){
      this.left = left
      this.right = right
    }
    map(fn){
      return this.right ? Either.of(this.left,fn(this.right)) : Either.of(fn(this.left),right)
    }
  }

此外，Either函子另一个用途是替代try...catch，使用左值来表示错误

 function parseJSON(json) {
  try {
    return Either.of(null, JSON.parse(json));
  } catch (e: Error) {
    return Either.of(e, null);
  }
}

ap函子

函子中的值有可能是数值，也有可能是一个函数，我们想让值为函数的函子用另一个函子中的值运算，我们就可以用ap函子

 function add(x) {
    return x + 1
  }
  const A = Functor.of(2)
  const B = Functor.of(add)

  class Ap extends Functor {
    ap(F) {
      return Ap.of(this.val(F.val))
    }
  }
 //我们想让B函子的值使用A函子的值
  Ap.of(add).ap(Functor.of(2))

凡是部署了ap方法的函子，就是ap函子。ap函子的意义在于对多参数的函数，可以从多个容器中取值，实现函子的链式调用。

Monad 函子

函子中的值可以接受任何值，所以函子之中可以包含另一个函子。这样就会造成函子多层嵌套的问题。取值时会很不方便。Monad函子的作用就是：总是返回一个单层的函子，它有一个FlatMap方法，与map方法作用相同，唯一的区别就是如果生成了一个嵌套函子，它会取出后者的值，保证返回的永远是一个单层的容器，不会出现嵌套的情况。

 class Monad extends Functor {
    join() {
      return this.val;
    }
    flatMap(f) {//f是一个函子
      return this.map(f).join();
    }
  }

如果函数f返回的是一个函子，那么this.map(f)就会生成一个嵌套的函子。所以，join方法保证了flatMap方法总是返回一个单层的函子。这意味着嵌套的函子会被铺平。

IO函子

I/O是一个不纯的操作，普通的函数式编程无法处理,所以使用IO函子操作

const fp = require('lodash/fp')
class IO {
    static of (value) {
        return new IO (function () {
            return value
        })
    }

    constructor(fn) {
        this._value = fn
    }

    map (fn){
        return new IO (fp.flowRight(fn,this._value));
    }
}
  • IO函子中的_value是一个一个函数，这里是把函数作为值来处理
  • IO函子可以把不纯的动作存储到_value中，延迟这个不纯的操作（惰性执行）,包装当前的操作是纯的操作
  • 把不纯的操作交给调用者来处理
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 194,319评论 5赞 459
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 81,801评论 2赞 371
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 141,567评论 0赞 319
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 52,156评论 1赞 263
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 61,019评论 4赞 355
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 46,090评论 1赞 272
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 36,500评论 3赞 381
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 35,192评论 0赞 253
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 39,474评论 1赞 290
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 34,566评论 2赞 309
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 36,338评论 1赞 326
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 32,212评论 3赞 312
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 37,572评论 3赞 298
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 28,890评论 0赞 17
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 30,169评论 1赞 250
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 41,478评论 2赞 341
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 40,661评论 2赞 335