Une brève introduction aux compétences de programmation fonctionnelle Javascript_javascript

Depuis des décennies, la programmation fonctionnelle est l'une des préférées des passionnés d'informatique, enterrée dans les laboratoires informatiques par les data scientists et les candidats au doctorat en raison de sa pureté mathématique et de sa nature énigmatique. Mais maintenant, il connaît une renaissance, grâce aux langages modernes comme Python, Julia, Ruby, Clojure et – mais pas le dernier – Javascript.

Tu veux dire Javascript ? Ce langage de script WEB ? C'est exact!

Javascript s'est avéré être une technologie importante qui n'a pas disparu depuis longtemps. Cela est principalement dû à la capacité de renaître grâce à certains des frameworks et bibliothèques qu'il étend, tels que backbone.js, jQuery, Dojo, underscore.js, etc. Ceci est directement lié à la véritable identité de Javascript en tant que langage de programmation fonctionnel. Une compréhension de la programmation fonctionnelle en Javascript est importante et sera utile aux programmeurs de tous niveaux pendant un certain temps.

Pourquoi ? La programmation fonctionnelle est très puissante, robuste et élégante. C’est très utile et efficace pour les grandes structures de données. En tant que langage de script côté client, Javascript est très utile pour manipuler fonctionnellement le DOM, organiser les réponses de l'API et accomplir d'autres tâches lorsqu'il s'agit de sites Web de plus en plus complexes.

Dans ce livre, vous apprendrez tout ce que vous devez savoir sur la programmation fonctionnelle en Javascript : comment créer vos applications Web Javascript avec la programmation fonctionnelle, comment débloquer la puissance cachée de Javascript et comment écrire du code plus puissant, et comme le programme est plus petit, le code est plus facile à maintenir, peut être téléchargé plus rapidement et coûte moins cher. Vous apprendrez également les concepts de base de la programmation fonctionnelle et comment les appliquer à Javascript, comment éviter certains problèmes lors de l'utilisation de Javascript comme langage fonctionnel et comment mélanger programmation fonctionnelle et programmation orientée objet en Javascript.

Mais avant de commencer, faisons une expérience.

Exemple

La meilleure façon d'introduire la programmation fonctionnelle en Javascript est peut-être de donner un exemple rapide. Nous effectuerons certaines tâches en Javascript - une en utilisant une approche traditionnelle et native et une autre en utilisant la programmation fonctionnelle. Nous comparerons ensuite ces deux méthodes.

Application - un site e-commerce

Afin de poursuivre le réalisme, nous allons créer un site de commerce électronique, une entreprise de vente par correspondance de grains de café. Ce site vend plusieurs types de café, avec des qualités différentes et, bien sûr, des prix différents.

Méthode impérative

Tout d’abord, nous commençons à écrire le programme. Pour rendre cet exemple pratique, nous devons créer des objets pour contenir les données. Nous pouvons obtenir la valeur de la base de données si nécessaire. Mais maintenant, nous supposons qu'ils sont définis statiquement :

 // create some objects to store the data.
var columbian = {
 name: 'columbian',
 basePrice: 5
};
var frenchRoast = {
 name: 'french roast',
 basePrice: 8
};
var decaf = {
 name: 'decaf',
 basePrice: 6
};
// 我们将使用辅助函数计算价格
// 根据size打印到一个HTML的列表中
function printPrice(coffee, size) {
 if (size == 'small') {
  var price = coffee.basePrice + 2;
 }
 else if (size == 'medium') {
  var price = coffee.basePrice + 4;
 }
 else {
  var price = coffee.basePrice + 6;
 }
 // create the new html list item
 var node = document.createElement("li");
 var label = coffee.name + ' ' + size;
 var textnode = document.createTextNode(label+' price: $'+price);
 node.appendChild(textnode);
 document.getElementById('products').appendChild(node);
}
// 现在我们只需根据咖啡的各种价格和size的组合调用printPrice函数
printPrice(columbian, 'small');
printPrice(columbian, 'medium');
printPrice(columbian, 'large');
printPrice(frenchRoast, 'small');
printPrice(frenchRoast, 'medium');
printPrice(frenchRoast, 'large');
printPrice(decaf, 'small');
printPrice(decaf, 'medium');
printPrice(decaf, 'large');

Comme vous pouvez le constater, ce code est très basique. Et s’il existait désormais plus de types de café que ces trois-là ? Et s’il y en avait 20, voire 50 ? Et s'il y avait plus de tailles ? Et s'il y avait du organique et du inorganique ? Cela représentera rapidement une énorme quantité de code !

En utilisant cette méthode, nous laissons la machine imprimer tous les types de café et toutes les tailles. C’est là le problème fondamental que pose cette approche impérative.

Programmation Fonctionnelle

Le code impératif indique à l'ordinateur étape par étape ce qui doit être fait pour résoudre le problème. En revanche, la programmation fonctionnelle continue de décrire le problème mathématiquement et laisse l'ordinateur faire le reste.

De manière plus fonctionnelle, la même application peut s'écrire ainsi :

// 从接口中分解数据和逻辑
var printPrice = function(price, label) {
 var node = document.createElement("li");
 var textnode = document.createTextNode(label+' price: $'+price);
 node.appendChild(textnode);
 document.getElementById('products 2').appendChild(node);
}
// 为每种咖啡创建函数对象
var columbian = function(){
 this.name = 'columbian';
 this.basePrice = 5;
};
var frenchRoast = function(){
 this.name = 'french roast';
 this.basePrice = 8;
};
var decaf = function(){
 this.name = 'decaf';
 this.basePrice = 6;
};
// 为每种size通过字面量创建对象
var small = {
 getPrice: function(){return this.basePrice + 2},
 getLabel: function(){return this.name + ' small'}
};
var medium = {
 getPrice: function(){return this.basePrice + 4},
 getLabel: function(){return this.name + ' medium'}
};
var large = {
 getPrice: function(){return this.basePrice + 6},
 getLabel: function(){return this.name + ' large'}
};
// 将所有咖啡的种类和size放到数组里
var coffeeTypes = [columbian, frenchRoast, decaf];
var coffeeSizes = [small, medium, large];
// 创建由上面内容组成的新对象，并把它们放到一个新数组里
var coffees = coffeeTypes.reduce(function(previous, current) {
 var newCoffee = coffeeSizes.map(function(mixin) {
  // `plusmix`是函数式的minxin, 见第7章
  var newCoffeeObj = plusMixin(current, mixin);
  return new newCoffeeObj();
 });
 return previous.concat(newCoffee);
},[]);
// 现在我们已经定义了如何获得所有咖啡种类和size组合方式的价格，现在可以直接打印它们了
coffees.forEach(function(coffee){
 printPrice(coffee.getPrice(),coffee.getLabel());
});

La première chose qu'il faut préciser est que ce code est plus modulaire. Désormais, ajouter une taille ou ajouter un type de café est aussi simple que le code suivant :

var peruvian = function(){
 this.name = 'peruvian';
 this.basePrice = 11;
};
var extraLarge = {
 getPrice: function(){return this.basePrice + 10},
 getLabel: function(){return this.name + ' extra large'}
};
coffeeTypes.push(Peruvian);
coffeeSizes.push(extraLarge);

咖啡对象的数组和size对象的数组混合（mix）到了一起，也就是他们的方法和成员变量被组合到了一块儿 ——通过一个叫“plusMinxin”的自定义函数（详见第七章）。这些咖啡类型的类（columbian, frenchRoast, decaf）包含了成员变量， 而这些size对象（small, medium, large）包含了获取名称和计算价格的方法。 ”混合”（minxing）这个动作通过一个map操作来起作用，也就是对数组中的每一个成员执行一个纯函数并返回一个新的函数， 然后这些返回的函数被放到了一个reduce函数中被操作，reduce也是一个高阶函数，和map有些像， 只是reduce把数组里的所有元素处理后组合到了一个东西里面。最终，新的数组包含了所有可能的种类和size的组合， 这个数组通过forEach方法遍历，forEach也是一个高阶函数，它会让数组里面每一个对象作为参数执行一遍回调函数。 在这个例子里，这个回调函数是一个匿名函数，它获取这些对象后，以对象的getPrice()和getLabel() 两个方法的返回值作为参数调用printPrice函数。

实际上，我们可以让这个例子更加函数式：去掉coffees变量，并将函数串到一起链式调用，这也是函数式编程的一个小技巧。

coffeeTypes.reduce(function(previous, current) {
 var newCoffee = coffeeSizes.map(function(mixin) {
  // `plusMixin` function for functional mixins, see Ch.7
  var newCoffeeObj = plusMixin(current, mixin);
  return new newCoffeeObj();
 });
 return previous.concat(newCoffee);
},[]).forEach(function(coffee) {
 printPrice(coffee.getPrice(),coffee.getLabel());
});

这样，控制流没有像命令式代码那样从头到尾的顺序进行。在函数式编程里，map函数和其它高阶函数代替了for和while循环， 只有少量关键的代码是在顺序执行。 这使得新接触的人在阅读这样范式的代码有些困难，但是一旦你能够欣赏它，你就会发现这根本没啥难的， 而且这样写看起来更好。

这个例子仅仅是刚开始展露Javascript中函数式编程能做什么。通过这本书，你将会看到更多函数式实现的强悍的例子。

总结

首先，采用函数式风格的优点已经明确了。 其次，不要害怕函数式编程。的确，它往往被认为是编程语言的纯逻辑形式，但是我们不需要理解lambda演算也能够在日常任务中应用它。 实际上，通过把我们的程序拆分成小的片段，它们变得更容易被理解、维护，也更加可靠。 map和reduce函数是Javascript中不太被知道的内建函数，然而我们将要关注它们。

Javascript是一个脚本语言，可交互，易使用，不需要编译。我们甚至不需要下载任何开发软件， 你最喜欢的浏览器就可以作为开发环境的解释器。

感兴趣吗？好，我们开始！