函数组合、Loadash/fp

-纯函数和柯里化很容易写出洋葱代码h(g(x()))
-函数组合可以让我们把细粒度的函数重新组合生成一个新的函数
-如果一个函数要经过多个函数处理才能得到最终值,这个时候可以把中间过程的函数合并成一个函数(默认从右到左执行)
-组合函数
-函数调试技巧,在函数之间写个打印日志函数,打印出上一个函数执行完的返回值

const _ = require('lodash');
// const log = v => {
//   console.log(v)
//   return v
// }
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/fp

-提供了使用的对函数式编程友好的方法
-提供了不可变"auto-curried iteratee-first data-last"的方法

const fp = require('lodash/fp');
const f = fp.flowRight(fp.join('-'),fp.map(fp.toLower),fp.split(' '))
console.log(f('NEVER SAY DIE'));

注意点:lodash和fp模块的map方法有区别,例如parseInt函数必须使用fp模块的fp.map(lodash由于进制转换会出问题,当index小于2时 )

Point Free

-不需要致命处理的数据
-只需要合成运算过程
-需要定义一些辅助的基本运算函数

const f = fp.flowRight(fp.join('-'),fp.map(_.toLower),fp.split(" "));
const fp = require('lodash/fp');
const _ = require('lodash');
//把一个字符串中的首字母提取并转换成大写,并以. 作为分隔符
// world wild web ==> W. W. W.
const trace = _.curry((tag,v) =>{
  console.log(tag,v);
  return v;
})
const firstLetterToUpper = fp.flowRight(fp.join('. '),fp.map(fp.toUpper),trace('map之后'),fp.map(fp.first),trace('split之后'),fp.split(' '))
//改造
const firstLetterToUpper = fp.flowRight(fp.join('. '),fp.map(fp.flowRight(fp.toUpper,fp.first)),fp.split(' '))
console.log(firstLetterToUpper('world wild web'));

Functor(函子)

-why:在函数式编程中如何去控制副作用
-what:
1)容器:包含值和值的变形关系(这个变形关系就是函数)
2)是一个特殊的容器,通过一个普通的对象来实现,该对象具备map方法,map方法可以运行一个函数对值继续逆行处理(变形关系)

// class Container {
//   constructor (value) {
//     this._value= value;
//   }

//   map(fn){
//     return new Container(fn(this._value))
//   }
// }
// let r = new Container(5)
//     .map(x => x + 1)
//     .map(x => x * x)
//     console.log(r);
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 + 2)
    .map(x => x * x)
    console.log(r);

`函子总结:

  • 函数式编程的运算不直接操作值,而由函子完成
    -函子就是一个实现了map函数的对象
    -我们可以把函子想象成一个盒子,这个盒子里封装了一个值
    -想要处理盒子中的值,我们需要给盒子的map方法传递一个处理
    之的函数(纯函数),有着函数来对值进行处理
    -最终map方法返回一个包含新值的盒子(函子)

Maybe函子:解决函子传参为null、undefined,但无法知道哪一处传的的是null

Either函子:两者中的任何一个,类似于id else;异常会让函数变得不纯,Either可以用来做异常处理

IO函子:_value是一个函数,这里是把函数作为值来处理

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));
  }
}
let r= IO.of(process).map(p => p.execPath)
console.log(r);
console.log(r._value());

Task异步执行:folktale库

const fs = require('fs')
const {task} = require('folktale/concurrency/task')
const {split ,find} = require('lodash/fp')
function readFile (filename) {
  return task(resolver => {
    fs.readFile(filename, 'utf-8' ,(err, data) => {
      if(err) resolver.reject(err)
      resolver.resolve(data);
    })
  })
}
readFile('package.json')
// .flowRight(find(x => x.includes('version')),split('\n'))
.map(split('\n'))
.map(find(x => x.includes('version')))
.run()
.listen({
  onRejected:err =>{
    console.log(err);
  },
  onResolved: value =>{
    console.log(value);
  }
})

Ponited函子

-实现了of静态方法的函子
-of方法是为了避免使用new来创建对象,更深层的含义是of方法用来把值放到上下文Context(把值放到容器中,使用map来处理)

Monad函子

-是可以变扁的pointed函子
-一个函子如果具有join和of两个方法并遵守一些定律就是一个Monad

最后编辑于
©著作权归作者所有,转载或内容合作请联系作者
平台声明:文章内容(如有图片或视频亦包括在内)由作者上传并发布,文章内容仅代表作者本人观点,简书系信息发布平台,仅提供信息存储服务。

推荐阅读更多精彩内容