Fikiran selepas membaca "Pengaturcaraan Fungsional JavaScript"_kemahiran javascript

Artikel ini merekodkan beberapa perkara yang telah saya fahami semasa mempelajari ungkapan berfungsi, untuk mendalami ingatan saya dan menyusun serta merekodkannya untuk semakan kemudian.

Saya membuat keputusan apabila saya melihat buku "JavaScript Functional Programming" pada pra-jualan baru-baru ini. Tujuan utamanya ialah saya masih tidak faham apa itu pengaturcaraan berfungsi. Dalam proses pembelajaran saya sendiri, saya selalu mendengar orang di sekeliling saya bercakap tentang pengaturcaraan berorientasikan proses dan pengaturcaraan berorientasikan objek, tetapi terdapat sangat sedikit pengaturcaraan berfungsi. Untuk tidak ketinggalan daripada pelajar lain, saya ingin berkongsi dan merekodkan ilmu yang saya perolehi daripada membaca dengan menulis nota.

js dan pengaturcaraan berfungsi

Buku ini menggunakan ayat mudah untuk menjawab apa itu pengaturcaraan berfungsi:

Pengaturcaraan fungsional menggunakan fungsi untuk menukar nilai kepada unit abstrak, yang kemudiannya digunakan untuk membina sistem perisian.
Saya rasa mesti ada pelajar yang membaca ayat ini dan masih tidak tahu apa itu pengaturcaraan berfungsi dan mengapa kita harus menggunakan pengaturcaraan berfungsi. Banyak daripada contoh berikut menggunakan Underscore.

Gunakan fungsi sebagai unit abstrak

Kaedah abstrak merujuk kepada fungsi yang menyembunyikan butiran. Ambil contoh daripada buku, fungsi yang mengesan nilai umur output (terutamanya melaporkan ralat dan amaran):

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;
}

Fungsi di atas menentukan sama ada kita telah memasuki usia, dan ia mestilah dalam bentuk rentetan. Langkah seterusnya ialah menjalankan fungsi ini:

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

Fungsi parseAge di atas berfungsi dengan baik tanpa sebarang masalah. Jika kita ingin menukar cara output error=maklumat dan amaran dibentangkan, maka kita perlu menukar baris kod yang sepadan, serta mod output di tempat lain. Kaedah yang diberikan dalam buku ini dicapai dengan mengabstrakkannya ke dalam fungsi yang berbeza:

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

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

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

Kemudian gunakan fungsi di atas untuk membina semula fungsi 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;
}

Letakkan kod yang melaporkan ralat ke dalam fungsi yang berbeza, dan parseAge yang difaktorkan semula tidak banyak berubah daripada yang sebelumnya. Tetapi perbezaannya ialah kini idea melaporkan ralat, mesej, dan amaran telah disarikan. Pelaporan ralat, mesej dan amaran juga telah dirombak sepenuhnya.

Apa yang dilakukannya ialah, memandangkan gelagat terkandung dalam satu fungsi, fungsi itu boleh digantikan dengan fungsi baharu yang menyediakan gelagat yang serupa, atau terus digantikan dengan gelagat yang berbeza sama sekali.

Encapsulation and Consealment

Tajuk ini mudah difahami, ini contohnya. Kami sering menggunakan iife untuk mengelakkan pencemaran global Ini adalah contoh pengkapsulan dan penyembunyian yang baik. Dengan menggunakan iife untuk menyembunyikan beberapa pembolehubah dan kaedah yang anda tulis, tujuannya adalah untuk tidak mencemarkan persekitaran global. Ini juga menggunakan penutupan untuk menyembunyikan data.

Sebab penutupan juga adalah satu fungsi. Dan ia mempunyai banyak kaitan dengan pembelajaran pengaturcaraan berfungsi sekarang. Tetapi jangan lupa enkapsulasi berorientasikan objek yang anda pelajari sebelum ini, anda tidak boleh mengatakan siapa yang lebih baik antara keduanya. Tetapi ia bukan perkara yang buruk jika anda menguasai semuanya. Seperti kata pepatah lama: lihat permintaan.

Gunakan fungsi sebagai unit tingkah laku

Menyembunyikan data dan tingkah laku (biasanya menyusahkan untuk pengubahsuaian pantas) hanyalah satu cara bercakap tentang fungsi sebagai unit abstrak. Pendekatan lain ialah menyediakan cara mudah untuk menyimpan dan memindahkan gelagat asas kepada unit diskret luar talian.

Berangan kecil dalam buku, menggunakan sintaks js untuk mengindeks nilai dalam tatasusunan:

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

Walaupun mengindeks nilai dalam tatasusunan di atas adalah mudah, tidak ada cara untuk mendapatkan tingkah laku ini dan menggunakannya seperti yang diperlukan tanpa meletakkannya dalam fungsi. Tulis fungsi mudah nth untuk mengindeks nilai dalam tatasusunan:

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

Kemudian jalankan:

nth(arr, 1); Operasi berjaya, tetapi jika objek kosong dimasukkan, ralat akan dilaporkan. Oleh itu, jika kita ingin melaksanakan abstraksi fungsi sekitar nth, kita mungkin mereka bentuk pernyataan berikut: nth mengembalikan fungsi sah yang disimpan dalam jenis data yang membenarkan akses indeks. Kunci kepada pernyataan ini ialah konsep jenis data indeks. Mungkin fungsi diperlukan untuk menentukan jenis:

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

Kemudian teruskan perbaiki fungsi ke-n. Fungsi isIndexed ialah abstraksi yang menyediakan abstraksi untuk menentukan sama ada data tertentu ialah rentetan atau tatasusunan.

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];
}

Dengan cara yang sama seperti membina abstraksi fungsi ke-n dengan mengekstrak objek daripada indeks, anda juga boleh membina abstraksi kedua dengan cara yang sama:

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的函数式编程。下面引用书上的总结：

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

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