Eine kurze Einführung in die funktionale Javascript-Programmierung_Javascript-Fähigkeiten

Funktionale Programmierung ist seit Jahrzehnten ein Favorit unter Informatikbegeisterten und wird aufgrund ihrer mathematischen Reinheit und rätselhaften Natur von Datenwissenschaftlern und Doktoranden in Computerlaboren begraben. Aber jetzt erlebt es dank moderner Sprachen wie Python, Julia, Ruby, Clojure und – aber nicht zuletzt – Javascript eine Renaissance.

Du meinst Javascript? Diese WEB-Skriptsprache? Das ist richtig!

Javascript hat sich als wichtige Technologie erwiesen, die schon lange nicht mehr verschwunden ist. Dies ist hauptsächlich auf die Fähigkeit zurückzuführen, aufgrund einiger der von ihm erweiterten Frameworks und Bibliotheken wiedergeboren zu werden, z. B. backbone.js, jQuery, Dojo, underscore.js usw. Dies steht in direktem Zusammenhang mit der wahren Identität von Javascript als funktionale Programmiersprache. Ein Verständnis der funktionalen Programmierung in Javascript ist wichtig und wird für Programmierer aller Niveaus noch lange von Nutzen sein.

Warum? Funktionale Programmierung ist sehr leistungsfähig, robust und elegant. Es ist sehr nützlich und effizient für große Datenstrukturen. Als clientseitige Skriptsprache ist Javascript sehr nützlich für die funktionale Manipulation des DOM, die Organisation von API-Antworten und die Erledigung anderer Aufgaben beim Umgang mit immer komplexeren Websites.

In diesem Buch erfahren Sie alles, was Sie über funktionale Programmierung in Javascript wissen müssen: wie Sie Ihre Javascript-Webanwendungen mit funktionaler Programmierung erstellen, wie Sie die verborgene Leistungsfähigkeit von Javascript freischalten und wie Sie leistungsfähigeren Code schreiben und Da das Programm kleiner ist, ist der Code einfacher zu warten, kann schneller heruntergeladen werden und kostet weniger. Außerdem lernen Sie die Kernkonzepte der funktionalen Programmierung und deren Anwendung auf Javascript kennen, wie Sie einige Probleme bei der Verwendung von Javascript als funktionale Sprache vermeiden und wie Sie funktionale Programmierung und objektorientierte Programmierung in Javascript kombinieren.

Aber bevor wir anfangen, machen wir ein Experiment.

Beispiel

Der vielleicht beste Weg, die funktionale Programmierung in Javascript einzuführen, ist ein kurzes Beispiel. Wir werden einige Aufgaben in Javascript erledigen – eine mit einem traditionellen, nativen Ansatz und eine andere mit funktionaler Programmierung. Wir werden dann diese beiden Methoden vergleichen.

Anwendung – eine E-Commerce-Website

Um Realismus zu erreichen, werden wir eine E-Commerce-Website erstellen, ein Versandunternehmen für Kaffeebohnen. Auf dieser Website werden verschiedene Kaffeesorten mit unterschiedlichen Qualitäten und natürlich unterschiedlichen Preisen verkauft.

Imperative Methode

Zuerst beginnen wir mit dem Schreiben des Programms. Um dieses Beispiel praktisch zu machen, müssen wir einige Objekte erstellen, um die Daten zu speichern. Bei Bedarf können wir den Wert aus der Datenbank abrufen. Aber jetzt gehen wir davon aus, dass sie statisch definiert sind:

 // 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');

Wie Sie sehen können, ist dieser Code sehr einfach. Was wäre, wenn es jetzt mehr Kaffeesorten als nur diese drei gäbe? Was wäre, wenn es 20 oder sogar 50 wären? Was ist, wenn es mehr Größen gibt? Was wäre, wenn es organisches und anorganisches gibt? Das summiert sich schnell zu einer riesigen Menge an Code!

Mit dieser Methode lassen wir die Maschine jede Kaffeesorte und jede Größe drucken. Das ist das Grundproblem dieses zwingenden Ansatzes.

Funktionale Programmierung

Imperativer Code sagt dem Computer Schritt für Schritt, was getan werden muss, um das Problem zu lösen. Im Gegensatz dazu geht es bei der funktionalen Programmierung darum, das Problem mathematisch zu beschreiben und den Computer den Rest erledigen zu lassen.

Auf funktionalere Weise kann dieselbe Anwendung wie folgt geschrieben werden:

// 从接口中分解数据和逻辑
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());
});

Das erste, was klargestellt werden muss, ist, dass dieser Code modularer ist. Jetzt ist das Hinzufügen einer Größe oder einer Kaffeesorte so einfach wie der folgende Code:

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

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