Réflexions après avoir lu "Programmation fonctionnelle JavaScript"_compétences javascript

Cet article enregistre certaines des choses que j'ai comprises en apprenant des expressions fonctionnelles, pour approfondir ma mémoire, les organiser et les enregistrer pour une révision ultérieure.

J'ai pris ma décision en voyant le livre "JavaScript Functional Programming" en prévente récemment. Le but principal est que je ne comprends toujours pas ce qu'est la programmation fonctionnelle. Au cours de mon propre apprentissage, j'ai toujours entendu des gens autour de moi parler de programmation orientée processus et de programmation orientée objet, mais il existe très peu de programmation fonctionnelle. Afin de ne pas prendre de retard sur les autres étudiants, je souhaitais partager et enregistrer les connaissances acquises en lisant en écrivant des notes.

js et programmation fonctionnelle

Le livre utilise une phrase simple pour répondre à ce qu'est la programmation fonctionnelle :

La programmation fonctionnelle utilise des fonctions pour convertir des valeurs en unités abstraites, qui sont ensuite utilisées pour créer des systèmes logiciels.
Je pense qu'il doit y avoir des étudiants qui lisent cette phrase et ne savent toujours pas grand-chose de ce qu'est la programmation fonctionnelle et pourquoi nous devrions utiliser la programmation fonctionnelle. La plupart des exemples suivants utilisent le trait de soulignement.

Utiliser des fonctions comme unités abstraites

Les méthodes abstraites font référence à des fonctions qui masquent les détails. Prenons un exemple tiré du livre, une fonction qui détecte la valeur d'âge de sortie (principalement rapporte les erreurs et les avertissements) :

function parseAge(age) {
  if (!_.isString(age))
    throw new Error("Expecting a string");
  var a;
  console.log("Attempting to parse an age");

  a = parseInt(age, 10);
  if (_.isNaN(a)) {
    console.log(["Could not parse age: "].join());
    a = 0;
  }

  return a;
}

La fonction ci-dessus détermine si nous avons saisi un âge, et il doit être sous la forme d'une chaîne. L'étape suivante consiste à exécuter cette fonction :

parseAge("42"); //=> 42
parseAge(42); //=> Error:Expecting a string
parseAge("hhhh"); //=> 0

La fonction parseAge ci-dessus fonctionne correctement sans aucun problème. Si nous voulons changer la façon dont les erreurs de sortie = les informations et les avertissements sont présentés, nous devons alors modifier les lignes de code correspondantes, ainsi que le mode de sortie ailleurs. La méthode donnée dans le livre est obtenue en les abstractionnant en différentes fonctions :

function fail(thing) {
  throw new Error(thing);
}

function warn(thing) {
  console.log(["WARNING:", thing].join(''));
}

function note(thing) {
  console.log(["NOTE:", thing].join(''));
}

Utilisez ensuite la fonction ci-dessus pour reconstruire la fonction parseAge.

funciton parseAge(age) {
  if (!_.isString(age))
    fail("Expecting a string");
  var a;

  note("Attempting to parse an age");
  a = parseInt(age, 10);

  if (_.isNaN(a)) {
    warn(["Could not parse age:", age].join(""));
    a = 0;
  }

  return a;
}

Mettez le code qui signale les erreurs dans différentes fonctions, et le parseAge refactorisé n'a pas beaucoup changé par rapport au précédent. Mais la différence est que désormais l’idée de signaler les erreurs, les messages et les avertissements a été abstraite. Le reporting des erreurs, messages et avertissements a également été entièrement repensé.

Ce que cela fait, c'est que puisque le comportement est contenu dans une seule fonction, la fonction peut être remplacée par une nouvelle fonction qui fournit un comportement similaire, ou directement remplacée par un comportement complètement différent.

Encapsulation et dissimulation

Ce titre est facile à comprendre, voici un exemple. Nous utilisons souvent la vie pour éviter la pollution mondiale. C'est un bon exemple d'encapsulation et de dissimulation. En utilisant iife pour masquer certaines variables et méthodes que vous écrivez, le but n'est pas de polluer l'environnement global. Cela utilise également des fermetures pour masquer les données.

Parce que la fermeture est aussi une fonction. Et cela a beaucoup à voir avec l’apprentissage de la programmation fonctionnelle maintenant. Mais n’oubliez pas l’encapsulation orientée objet que vous avez apprise auparavant. Après tout, vous ne pouvez pas dire qui est le meilleur entre les deux. Mais ce n’est pas une mauvaise chose si vous les maîtrisez tous. Comme le dit le vieil adage : regardez la demande.

Utiliser la fonction comme unité de comportement

Masquer les données et les comportements (généralement peu pratiques pour une modification rapide) n'est qu'une façon de parler des fonctions comme d'unités abstraites. Une autre approche consiste à fournir un moyen simple de stocker et de transférer des comportements de base vers des unités discrètes hors ligne.

Une petite châtaigne dans le livre, utilisant la syntaxe js pour indexer une valeur dans un tableau :

var arr = ['a', 'b', 'c'];
arr[1] //=> b

Bien que l'indexation d'une valeur dans le tableau ci-dessus soit simple, il n'y a aucun moyen d'obtenir ce comportement et de l'utiliser selon les besoins sans la mettre dans une fonction. Écrivez une fonction simple nième pour indexer une valeur dans le tableau :

function nth(a, index) {
  return a[index];
}

Puis exécutez :

nth(arr, 1); //=> L'opération réussit, mais si un objet vide est transmis, une erreur sera signalée. Par conséquent, si nous voulons implémenter l'abstraction de fonction autour de nth, nous pourrions concevoir l'instruction suivante : nth renvoie une fonction valide stockée dans un type de données qui permet l'accès à l'index. La clé de cette affirmation est le concept de type de données d'index. Peut-être qu'une fonction est nécessaire pour déterminer le type :

function isIndexed(data) {
  return _.isArray(data) || _.isString(data);
}

Ensuite, continuez à améliorer la nième fonction. La fonction isIndexed est une abstraction qui fournit une abstraction permettant de déterminer si certaines données sont une chaîne ou un tableau.

function nth(a, index) {
  if (!_.isNumber(index)) 
    fail("Expected a number as the index");
  if (!isIndexed(a))
    fail("Not supported on non-indexed type");
  if ((index < 0) || (index > a.length - 1))
    fail("Index value is out of bounds");

  return a[index];
}

De la même manière que vous construisez une nième abstraction de fonction en extrayant des objets de l'index, vous pouvez également construire une deuxième abstraction de la même manière :

function second(a) {
  return nth(a, 1);
}

函数second允许在一个不同但相关的情况下，正确的使用nth函数：

second(arr); //=> b
通过上面的栗子，就知道。我们可以把每一步都抽象成一个函数，把每一个参数都抽象出来。虽然这样写感觉定义了许多函数。不过这样更加容易理解每一项的功能和流程。

数据抽象

JavaScript 的对象原型模型是一个丰富且基础的数据方案。
因为js没有类的原因，就有了许多模拟类的方法，且在ES6上也出现了class关键字。尽管类有许多长处，但很多的时候js应用程序的数据需求币类中的简单的要多。

基于类的对象系统的一个有理的论据是实现用户界面的历史使用。
js中的对象和数组已经能够满足我们对数据的操作了，且Underscore也是重点也是如何处理数组和对象。

实施和使用的简易性是使用js的核心数据结构进行数据建模的目的。这并不是说面向对象或者基于类的方法就完全没有用。处理集合为中心的函数式方式更加适合处理与人有关的数据，而面向对象的方法最适合模拟人。

js函数式初试

在开始函数式编程前，需要先定义两个常用且有用的函数：

function existy(x) {
  return x != null
}

function truthy(x) {
  return (x !== false) && existy(x);
}

existy函数旨在定义事物之前的存在。js中就有两个值可以表示不存在：null和undefined。
truthy函数用来判断一个对象是否应该认为是true的同义词。

我们可以在很多地方使用到这两个函数，其实函数式理念来自于它们的使用。有些同学可能已经熟悉了许多js实现中的map forEach等方法。且Underscroe也提供了许多类似的方法，这也许就是选择Underscroe来辅助学习函数式编程的原因。

简单说下就是：

一个对”存在“的抽象函数的定义。
一个建立在存在函数之上的，对”真“的抽象函数定义。
通过其他函数来使用上面的两个函数，以实现更多的行为。

加速

大概了解了函数式编程之后。你可能会想这函数式编程不是很慢吗？比如前面获取数组索引，有必要定义一个函数来专门获取吗？直接用arr[index]绝对比那些函数来的快。

var arr = [1, 2, 3, 4, 5];

// 最快
for (var i = 0; i < arr.length; i++) {
  console.log(arr[i]);
}

// 较慢
_.each(arr, function (val, index) {
  console.log(index);
});

但是我们在写代码的时候可能不会考虑的那么深，也许使用函数的确比原生要慢一些。但是大多数情况下也不会去在乎那么点时间，且现在有强大的v8引擎，大部分情况下的他都能很高效的编译和执行我们的js代码。所以我们没有必要在还没有写出正确的代码前考虑运算速度。

如果是我来选择的话，可能会更加关注与代码的风格。那种写法写的舒服看的舒服就使用哪一种，当然也是要保证基本的运算速度下，以不至于慢的离谱。看的舒服的代码比跑的快的代码可能更加有成就感。

总结

看完了第一章也是可以小结一下js的函数式编程。下面引用书上的总结：

确定抽象，并为其构建函数。
利用已有的函数来构建更加复杂的抽象。
通过将现有的函数传给其他的函数来构建更加复杂的抽象。
单是构建抽象还是不够的，如果能够把强大的数据抽象结合来实现函数式编程效果会更加好。

后面的章节读后感会慢慢的分享给大家，敬请关注。