美文网首页web前端-javascript
理解面向对象与函数式

理解面向对象与函数式

作者: 老鼠AI大米_Java全栈 | 来源:发表于2019-06-12 14:32 被阅读2次

    编写程序是每个程序员的事，如何编写出高效的，易用的，健壮的程序呢？跟编程方式有很大关系，过程式，对象式和函数式，哪一个适合你？

    面向对象

    面向对象是一种设计思想，面向对象的核心是 类 (class)和 对象 (object)，通过类来抽象现实世界，通过对象来模拟现实世界。 面向对象的难点在于抽象，抽象的好坏很大程度决定了整个程序设计的好坏。

    面向对象的设计中会有很多的层次结构，然后现实世界很多时候并没有那么多层次结构， 这时，如果强行用面向对象的设计方式，反而会把问题复杂化，也会让应对变化没那么容易，所以产生了 设计模式 这种概念。 设计模式被很多人推崇，个人感觉设计模式进一步让设计远离现实世界，把对解决实际问题的关注变为对重构代码的关注。

    当然，面向对象也有它明显的优势，在代码组织上结构清晰，有严格的访问控制，同时简单易懂，相对于函数式编程，更容易上手。

    面向对象核心概念

    • 抽象
    • 多态
    • 继承
    • 封装

    函数式编程

    函数式编程其实是比面向对象更早的编程方式，但是由于其对使用者有更高的要求（主要在代码组织方面，将实际问题转换为函数方面）， 所有面向对象设计方式出现之后，一度被忽略，成为一种小众的编程方式。

    函数式的编程范式使得它更加适用于复杂数据处理，高并发的环境，这也是函数式编程最近又兴起的原因之一。

    • 函数是一等公民，也就是函数和变量等其他数据类型一样使用
    • 没有副作用，函数保持独立，和外部的交互仅限于 函数参数 和 返回值

    函数式核心概念

    • 不变性
    • 纯函数
    • 高阶函数

    函数式 和 面向对象 比较

    面向对象核心是状态，函数式核心是数据

    所以面向对象更适合对业务（复杂的状态变化）的设计，而函数式适合对功能（复杂的数据变化）的设计， 我想，这也是面向对象应用广泛的原因之一，毕竟大部分人接触的都是业务开发。

    随着面向对象设计方式的发展，理论是越来越完善，复杂度也越来越高，面向对象的设计方式很多时候不再把目光投向实际的问题， 而是追求所谓的设计技巧。 函数式编程则更加直接，将问题转化为对数据的处理，关注点更容易集中在问题本身。

    函数式 和 AI

    函数式编程能够再度火起来，和 AI 也有一定的关系，机器学习本身就是对大量数据的学习和处理，通过数据来训练出算法。 这种模式更加适合函数式编程，而面向对象面对这种未知结果的学习，抽象会非常困难。

    理解函数式编程

    看了上面的介绍，估计大家对函数式编程还是不清楚，下面来一一举例说明(来自阮老师博客)
    函数式编程的起源，是一门叫做范畴论（Category Theory）的数学分支，理解函数式编程的关键，就是理解范畴论。它是一门很复杂的数学，认为世界上所有的概念体系，都可以抽象成一个个的"范畴"（category）。

    范畴论与函数式编程

    范畴论使用函数，表达范畴之间的关系。

    伴随着范畴论的发展，就发展出一整套函数的运算方法。这套方法起初只用于数学运算，后来有人将它在计算机上实现了，就变成了今天的"函数式编程"。

    本质上，函数式编程只是范畴论的运算方法，跟数理逻辑、微积分、行列式是同一类东西，都是数学方法，只是碰巧它能用来写程序。

    函数的合成与柯里化

    函数式编程有两个最基本的运算：合成和柯里化。

    1. 函数的合成
      如果一个值要经过多个函数，才能变成另外一个值，就可以把所有中间步骤合并成一个函数，这叫做"函数的合成"（compose）。
      合成两个函数的简单代码如下。
    const compose = function (f, g) {
  return function (x) {
    return f(g(x));
  };
}
    1. 柯里化
      f(x)和g(x)合成为f(g(x))，有一个隐藏的前提，就是f和g都只能接受一个参数。如果可以接受多个参数，比如f(x, y)和g(a, b, c)，函数合成就非常麻烦。

    这时就需要函数柯里化了。所谓"柯里化"，就是把一个多参数的函数，转化为单参数函数。

    // 柯里化之前
function add(x, y) {
  return x + y;
}

add(1, 2) // 3

// 柯里化之后
function addX(y) {
  return function (x) {
    return x + y;
  };
}

addX(2)(1) // 3

    有了柯里化以后，我们就能做到，所有函数只接受一个参数。后文的内容除非另有说明，都默认函数只有一个参数，就是所要处理的那个值。

    函数式之函子

    函数不仅可以用于同一个范畴之中值的转换，还可以用于将一个范畴转成另一个范畴。这就涉及到了函子（Functor）。

    1. 函子的概念
      函子是函数式编程里面最重要的数据类型，也是基本的运算单位和功能单位。
      它首先是一种范畴，也就是说，是一个容器，包含了值和变形关系。比较特殊的是，它的变形关系可以依次作用于每一个值，将当前容器变形成另一个容器。

    2. 函子的实现
      任何具有map方法的数据结构，都可以当作函子的实现。

    class Functor {
  constructor(val) { 
    this.val = val; 
  }

  map(f) {
    return new Functor(f(this.val));
  }
}

    上面代码中，Functor是一个函子，它的map方法接受函数f作为参数，然后返回一个新的函子，里面包含的值是被f处理过的（f(this.val)）。

    一般约定，函子的标志就是容器具有map方法。该方法将容器里面的每一个值，映射到另一个容器。

    下面是一些用法的示例。

    (new Functor(2)).map(function (two) {
  return two + 2;
});
// Functor(4)

(new Functor('flamethrowers')).map(function(s) {
  return s.toUpperCase();
});
// Functor('FLAMETHROWERS')

(new Functor('bombs')).map(_.concat(' away')).map(_.prop('length'));
// Functor(10)

    上面的例子说明，函数式编程里面的运算，都是通过函子完成，即运算不直接针对值，而是针对这个值的容器----函子。函子本身具有对外接口（map方法），各种函数就是运算符，通过接口接入容器，引发容器里面的值的变形。

    因此，学习函数式编程，实际上就是学习函子的各种运算。由于可以把运算方法封装在函子里面，所以又衍生出各种不同类型的函子，有多少种运算，就有多少种函子。函数式编程就变成了运用不同的函子，解决实际问题。

    1. 函子of
      上面生成新的函子的时候，用了new命令。这实在太不像函数式编程了，因为new命令是面向对象编程的标志。

    函数式编程一般约定，函子有一个of方法，用来生成新的容器。

    下面就用of方法替换掉new。

    Functor.of = function(val) {
  return new Functor(val);
};

    然后，前面的例子就可以改成下面这样。

    Functor.of(2).map(function (two) {
  return two + 2;
});
// Functor(4)

    这就更像函数式编程了。

    1. 函子maybe
      函子接受各种函数，处理容器内部的值。这里就有一个问题，容器内部的值可能是一个空值（比如null），而外部函数未必有处理空值的机制，如果传入空值，很可能就会出错。
    Functor.of(null).map(function (s) {
  return s.toUpperCase();
});
// TypeError

    上面代码中，函子里面的值是null，结果小写变成大写的时候就出错了。

    Maybe 函子就是为了解决这一类问题而设计的。简单说，它的map方法里面设置了空值检查。

    class Maybe extends Functor {
  map(f) {
    return this.val ? Maybe.of(f(this.val)) : Maybe.of(null);
  }
}

    有了 Maybe 函子，处理空值就不会出错了。

    Maybe.of(null).map(function (s) {
  return s.toUpperCase();
});
// Maybe(null)
    1. Either 函子
      条件运算if...else是最常见的运算之一，函数式编程里面，使用 Either 函子表达。

    Either 函子内部有两个值：左值（Left）和右值（Right）。右值是正常情况下使用的值，左值是右值不存在时使用的默认值。

    class Either extends Functor {
  constructor(left, right) {
    this.left = left;
    this.right = right;
  }

  map(f) {
    return this.right ? 
      Either.of(this.left, f(this.right)) :
      Either.of(f(this.left), this.right);
  }
}

Either.of = function (left, right) {
  return new Either(left, right);
};

    下面是用法。

    var addOne = function (x) {
  return x + 1;
};

Either.of(5, 6).map(addOne);
// Either(5, 7);

Either.of(1, null).map(addOne);
// Either(2, null);

    上面代码中，如果右值有值，就使用右值，否则使用左值。通过这种方式，Either 函子表达了条件运算。

    Either 函子的常见用途是提供默认值。下面是一个例子。

    Either
.of({address: 'xxx'}, currentUser.address)
.map(updateField);

    上面代码中，如果用户没有提供地址，Either 函子就会使用左值的默认地址。

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

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

    上面代码中，左值为空，就表示没有出错，否则左值会包含一个错误对象e。一般来说，所有可能出错的运算，都可以返回一个 Either 函子。

    1. ap 函子
      函子里面包含的值，完全可能是函数。我们可以想象这样一种情况，一个函子的值是数值，另一个函子的值是函数。
    function addTwo(x) {
  return x + 2;
}

const A = Functor.of(2);
const B = Functor.of(addTwo)

    上面代码中，函子A内部的值是2，函子B内部的值是函数addTwo。

    有时，我们想让函子B内部的函数，可以使用函子A内部的值进行运算。这时就需要用到 ap 函子。

    ap 是 applicative（应用）的缩写。凡是部署了ap方法的函子，就是 ap 函子。

    class Ap extends Functor {
  ap(F) {
    return Ap.of(this.val(F.val));
  }
}

    注意，ap方法的参数不是函数，而是另一个函子。

    因此，前面例子可以写成下面的形式。

    Ap.of(addTwo).ap(Functor.of(2))
// Ap(4)

    ap 函子的意义在于，对于那些多参数的函数，就可以从多个容器之中取值，实现函子的链式操作。

    function add(x) {
  return function (y) {
    return x + y;
  };
}

Ap.of(add).ap(Maybe.of(2)).ap(Maybe.of(3));
// Ap(5)

    上面代码中，函数add是柯里化以后的形式，一共需要两个参数。通过 ap 函子，我们就可以实现从两个容器之中取值。它还有另外一种写法。

    Ap.of(add(2)).ap(Maybe.of(3));

    1. Monad 函子
      函子是一个容器，可以包含任何值。函子之中再包含一个函子，也是完全合法的。但是，这样就会出现多层嵌套的函子。
    Maybe.of(
  Maybe.of(
    Maybe.of({name: 'Mulburry', number: 8402})
  )
)

    上面这个函子，一共有三个Maybe嵌套。如果要取出内部的值，就要连续取三次this.val。这当然很不方便，因此就出现了 Monad 函子。

    Monad(单子) 函子的作用是，总是返回一个单层的函子。它有一个flatMap方法，与map方法作用相同，唯一的区别是如果生成了一个嵌套函子，它会取出后者内部的值，保证返回的永远是一个单层的容器，不会出现嵌套的情况。

    class Monad extends Functor {
  join() {
    return this.val;
  }
  flatMap(f) {
    return this.map(f).join();
  }
}

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

    1. Monad 函子之IO操作
      Monad 函子的重要应用，就是实现 I/O （输入输出）操作。

    I/O 是不纯的操作，普通的函数式编程没法做，这时就需要把 IO 操作写成Monad函子，通过它来完成。

    var fs = require('fs');

var readFile = function(filename) {
  return new IO(function() {
    return fs.readFileSync(filename, 'utf-8');
  });
};

var print = function(x) {
  return new IO(function() {
    console.log(x);
    return x;
  });
}

    上面代码中，读取文件和打印本身都是不纯的操作，但是readFile和print却是纯函数，因为它们总是返回 IO 函子。

    如果 IO 函子是一个Monad，具有flatMap方法，那么我们就可以像下面这样调用这两个函数。

    readFile('./user.txt')
.flatMap(print)

    这就是神奇的地方，上面的代码完成了不纯的操作，但是因为flatMap返回的还是一个 IO 函子，所以这个表达式是纯的。我们通过一个纯的表达式，完成带有副作用的操作，这就是 Monad 的作用。

    由于返回还是 IO 函子，所以可以实现链式操作。因此，在大多数库里面，flatMap方法被改名成chain。

    var tail = function(x) {
  return new IO(function() {
    return x[x.length - 1];
  });
}

readFile('./user.txt')
.flatMap(tail)
.flatMap(print)

// 等同于
readFile('./user.txt')
.chain(tail)
.chain(print)

    上面代码读取了文件user.txt，然后选取最后一行输出。

    参考

    相关文章

      网友评论

        本文标题：理解面向对象与函数式

        本文链接：https://www.haomeiwen.com/subject/wzykfctx.html

        延伸阅读

        深度阅读

        • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

        栏目导航

        热点阅读

        web前端-javascript

        关于我们|服务条款|联系我们|理解面向对象与函数式|投稿指南|网站地图|RSS订阅|排版工具|手机版

        提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

        Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

        备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

        本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

        所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！