Pengaturcaraan berfungsi tangan dengan ramda.js

Artikel ini dikaji semula oleh Yaphi Berhanu, Vildan Softic, Jani Hartikainen dan Dan Prince. Terima kasih kepada semua pengulas rakan sebaya SitePoint untuk mendapatkan kandungan SitePoint untuk yang terbaik!

Salah satu daya tarikan JavaScript adalah ciri -ciri pengaturcaraan fungsinya. Dari awal lagi, fungsi adalah warga kelas pertama di dunia JavaScript. Ini memungkinkan untuk menulis kod elegan dan ekspresif yang dapat dengan mudah disatukan dalam banyak cara. Walau bagaimanapun, mempunyai keupayaan untuk melaksanakan pengaturcaraan berfungsi sahaja tidak dapat melaksanakan pengaturcaraan berfungsi secara automatik. Ramda.js adalah perpustakaan yang sangat popular (dengan lebih daripada 4K bintang di GitHub) yang boleh kita gunakan untuk membantu kita memulakan dengan JavaScript untuk pengaturcaraan berfungsi.

mata utama

Ramda.js meningkatkan keupayaan pengaturcaraan fungsi JavaScript dengan memastikan fungsi tidak mengubah data input mereka, dengan itu meningkatkan kebolehprediksi dan kemudahan ujian.
Ciri -ciri utama Ramda.js termasuk penggulingan fungsi automatik dan penekanan yang kuat pada invarians, yang menjadikannya lebih mudah untuk membina saluran paip berfungsi tanpa kesan sampingan.
Perpustakaan ini sesuai untuk persekitaran front-end dan node.js dan boleh diintegrasikan dengan lancar dengan perpustakaan atau rangka kerja JavaScript yang lain.
Ramda.js menyediakan kaedah dan fungsi praktikal seperti
• , R.map dan R.prop, memudahkan operasi struktur data dan meningkatkan kebolehbacaan dan pemeliharaan kod. R.curry
Walaupun Ramda.js mempunyai banyak kelebihan, ia bukan penyelesaian sejagat;

pemula

Untuk memanfaatkan sepenuhnya ramda.js, kita harus akrab dengan kelebihannya dengan membuat projek node.js kecil. Kami hanya boleh memasangnya melalui Pengurus Pakej Node (NPM).

npm install ramda

Biasanya, kita hanya akan mengimport fungsi perpustakaan ke ruang nama R. Dengan cara ini, semua panggilan ke kaedah Ramda akan mempunyai awalan R.

var R = require('ramda');

Sudah tentu, tiada apa yang dapat menghalang kita daripada menggunakan Ramda.js dalam kod depan. Dalam penyemak imbas, kita hanya perlu memasukkan laluan yang betul ke salinan perpustakaan. Ini mungkin semudah coretan kod HTML berikut.

<🎜>

Ramda.js tidak menggunakan mana-mana ciri khusus DOM atau Node.js. Ia hanya perpustakaan/lanjutan bahasa dan membina struktur dan algoritma yang telah didedahkan oleh runtime JavaScript (seperti yang diseragamkan dalam Ecmascript 5). Bersedia untuk menjalankan penyelidikan mendalam? Mari kita lihat aplikasi praktikal beberapa fungsi!

Konsep

Konsep yang paling penting dalam pengaturcaraan berfungsi adalah konsep fungsi tulen. Fungsi tulen adalah idempotent dan tidak mengubah mana -mana keadaan. Dari sudut pandang matematik, ini masuk akal, kerana fungsi seperti dosa (x) kelihatan sangat semula jadi dan tidak bergantung kepada mana -mana keadaan luaran. Sebagai tambahan kepada fungsi tulen, kami juga ingin mempunyai fungsi parameter tunggal. Mereka adalah yang paling primitif. Fungsi sifar-parameter biasanya bermaksud bahawa keadaan luaran akan diubah, jadi ia bukan fungsi murni. Tetapi dalam bahasa seperti JavaScript, kita biasanya mempunyai fungsi dengan pelbagai parameter.

currihua

Keupayaan untuk mempunyai fungsi pesanan yang lebih tinggi (iaitu, fungsi yang boleh mengambil fungsi sebagai fungsi input dan memancarkan sebagai output) yang digabungkan dengan penutupan (menangkap pembolehubah tempatan) memberikan kita cara yang baik: kari. Currying adalah proses di mana fungsi dengan pelbagai (mengandaikan n) parameter ditukar menjadi fungsi dengan parameter tunggal, yang mengembalikan fungsi lain dengan parameter tunggal. Ini akan berterusan sehingga semua parameter yang diperlukan dikumpulkan. Katakan kami mahu menggunakan fungsi Ramda.js Helper untuk menulis pembungkus parameter tunggal yang menguji sama ada parameternya adalah rentetan. Kod berikut akan melakukan tugas tersebut.

npm install ramda

Ini boleh dilakukan dengan lebih mudah dengan kari. Oleh kerana r.is adalah sebahagian daripada ramda.js, jika kami menyediakan parameter yang lebih sedikit daripada yang diperlukan oleh fungsi, perpustakaan akan secara automatik mengembalikan fungsi kari:

var R = require('ramda');

Ini lebih ekspresif. Oleh kerana kami memanggil R.IS dengan satu hujah, kami mendapat fungsi. Dalam panggilan kedua (ingat, panggilan fungsi asal mengambil dua parameter), kami mendapat hasilnya. Tetapi bagaimana jika kita tidak menggunakan fungsi penolong Ramda.js pada mulanya? Mari kita anggap kita telah menentukan fungsi berikut di suatu tempat dalam kod:

<🎜>

Ini adalah polinomial pesanan kedua lengkap. Ia mempunyai empat parameter yang membolehkan semua nilai yang mungkin. Tetapi biasanya, kami hanya mahu menukar X untuk set parameter tetap A, B, dan C. Mari lihat cara menukarnya menggunakan ramda.js:

function isString (test) {
    return R.is(String, test);
}

var result = isString('foo'); //=> true

Begitu juga, kita dapat menggunakan penilaian parameter untuk membuat alias untuk subset tertentu. Sebagai contoh, persamaan x - 1 boleh diperolehi dengan:

var isString = R.is(String);
var result = isString('foo'); //=> true

Sekiranya bilangan parameter tidak diberikan oleh parameter fungsi kita, kita perlu menggunakan Curryn dan secara jelas menentukan bilangan parameter. Currying adalah di tengah -tengah Ramda.js, tetapi perpustakaan tidak kelihatan begitu menarik tanpa lebih. Satu lagi konsep penting dalam pengaturcaraan berfungsi adalah invarian.

Struktur tidak berubah

Cara paling mudah untuk mengelakkan fungsi daripada mengubah keadaannya adalah dengan hanya menggunakan struktur data yang tidak dapat diubah. Untuk objek mudah, kita memerlukan aksesori baca sahaja, contohnya:

tidak dibenarkan. Di samping mengisytiharkan sifat baca sahaja, kita juga boleh menukarnya kepada fungsi getter:

var quadratic = (a, b, c, x) => x * x * a + x * b + c;
quadratic(1, 0, 0, 2); //=> 4
quadratic(1, 0, 0)(2); //=> TypeError: quadratic(..) is not a function

Ini jauh lebih baik sekarang, bagaimanapun, objek masih boleh diubah. Ini bermakna seseorang boleh menambah definisi tersuai fungsi GETX, contohnya:

var quadratic = R.curry((a, b, c, x) => x * x * a + x * b + c);
quadratic(1, 0, 0, 2); //=> 4
quadratic(1, 0, 0)(2); //=> 4

npm install ramda

Cara terbaik untuk mencapai invariance adalah menggunakan object.freeze. Digabungkan dengan kata kunci Const, kita boleh memperkenalkan pemboleh ubah invarian yang tidak dapat diubah.

var R = require('ramda');

Satu lagi contoh melibatkan senarai. Menambah elemen ke senarai yang tidak berubah memerlukan menyalin senarai asal dan menambah elemen baru hingga akhir. Sudah tentu, kita juga boleh menggunakan pengetahuan invarians objek asal untuk mengoptimumkan pelaksanaannya. Dengan cara ini kita boleh menggantikan salinan dengan rujukan mudah. Pada asasnya, ini mungkin berubah menjadi senarai yang dipautkan. Kita harus menyedari bahawa tatasusunan JavaScript standard boleh berubah dan oleh itu perlu disalin untuk memastikan ketepatannya. Kaedah seperti tambahan () bekerja pada tatasusunan JavaScript dan mengembalikan tatasusunan tersebut. Operasi ini adalah idempotent;

<🎜>

Terdapat juga kaedah keluarkan yang mengembalikan array yang diberikan tetapi tidak mengandungi entri yang ditentukan. Ia berfungsi seperti berikut:

function isString (test) {
    return R.is(String, test);
}

var result = isString('foo'); //=> true

Oleh kerana ia mempunyai bilangan parameter yang fleksibel, kita memerlukan fungsi Curryn yang disebut sebelum ini untuk memohon kari. Terdapat juga beberapa fungsi penolong umum yang berguna.

Kaedah praktikal

Konsep yang paling penting dari semua fungsi penolong adalah bahawa parameter diperintahkan untuk memudahkan kari. Lebih kerap parameter berubah, semakin kecil kemungkinannya sebelum parameter lain.

jumlah () dan julat ()

Sudah tentu, anda boleh mencari fungsi biasa dalam ramda.js, seperti jumlah dan julat:

var isString = R.is(String);
var result = isString('foo'); //=> true

Untuk pelbagai fungsi penolong, kita boleh membuat pembungkus menggunakan kari:

var quadratic = (a, b, c, x) => x * x * a + x * b + c;
quadratic(1, 0, 0, 2); //=> 4
quadratic(1, 0, 0)(2); //=> TypeError: quadratic(..) is not a function

Bagaimana jika kita mahu membungkusnya dengan maksimum tetap (eksklusif)? Ramda.js memenuhi keperluan kita dengan menggunakan parameter khas yang diwakili oleh r .__:

var quadratic = R.curry((a, b, c, x) => x * x * a + x * b + c);
quadratic(1, 0, 0, 2); //=> 4
quadratic(1, 0, 0)(2); //=> 4

peta ()

Di samping itu, ramda.js cuba menggunakan penyelesaian "lebih baik" untuk menyediakan alternatif kepada fungsi teras JavaScript seperti array.prototype.map. Penyelesaian "lebih baik" mempunyai perintah parameter yang berbeza dan kari keluar dari kotak. Untuk fungsi peta, seperti yang ditunjukkan di bawah:

var xOffset = quadratic(0, 1, -1);
xOffset(0); //=> -1
xOffset(1); //=> 0

prop ()

Satu lagi utiliti berguna ialah fungsi prop, yang cuba mendapatkan nilai harta yang ditentukan. Sekiranya harta yang diberikan tidak wujud, undefined dikembalikan. Ini mungkin samar -samar jika nilai itu tidak jelas, tetapi dalam praktiknya kita jarang mengambil berat tentangnya.

var position = {
    x: 5,
    y: 9
};
position.x = 10; // works!

zipwith ()

Jika kaedah yang diperkenalkan sebelum ini tidak meyakinkan anda bahawa ramda.js boleh memberikan sesuatu yang berguna, maka kaedah seterusnya mungkin lebih menarik. Kali ini kita tidak akan membincangkan contoh khusus, tetapi sebaliknya melihat senario yang dipilih sewenang -wenangnya. Katakan kami mempunyai dua senarai dan kami mahu menyambungkannya. Menggunakan fungsi zip sebenarnya sangat mudah. Walau bagaimanapun, keputusan biasa (tatasusunan elemen, yang sendiri adalah susunan dua kali ganda) mungkin bukan hasil yang kita mahu. Di sinilah fungsi zipwith dimainkan. Ia memetakan nilai kepada satu nilai menggunakan fungsi sewenang -wenangnya.

var position = (function (x, y) {
    return {
        getX: () => { return x; },
        getY: () => { return y; }
    };
})(5, 9);
position.getX() = 10; // does not work!

Begitu juga, kita boleh memperkenalkan produk DOT kepada vektor:

npm install ramda

Kami memampatkan dua tatasusunan dengan pendaraban (menghasilkan [1, 4, 9]) dan lulus hasilnya kepada fungsi jumlah. Walau apa pun, menggunakan objek yang boleh dibaca adalah topik penting. Tidak menghairankan bahawa Ramda.js menyediakan banyak fungsi penolong yang berguna. Kami telah memperkenalkan R.Map untuk memohon fungsi kepada setiap elemen. Begitu juga, terdapat beberapa fungsi penolong yang mengurangkan bilangan elemen. Nilai tunggal boleh dihasilkan oleh fungsi penapis yang paling umum (menghasilkan array lain) atau dengan fungsi mengurangkan.

rantaian ()

Terdapat beberapa fungsi penolong yang berguna untuk operasi array. Sebagai contoh, menggunakan rantai, kita boleh menggabungkan tatasusunan dengan mudah. Katakan kita mempunyai fungsi primefactorization yang menggunakan nombor sebagai input dan memberikan array dengan faktor utama sebagai output, kita dapat menggabungkan hasil penggunaan fungsi dengan satu set nombor seperti berikut:

var R = require('ramda');

Contoh praktikal

Setakat ini, semuanya telah berjalan lancar. Persoalan terbesar sekarang ialah: Apakah manfaat kerja harian kita dengan menggunakan konsep -konsep ini yang diperkenalkan oleh Ramda.js? Mari kita anggap kita mempunyai coretan kod berikut (sudah sangat baik).

<🎜>

Bagaimana menggunakan ramda.js untuk menjadikannya lebih mudah dibaca? Nah, baris pertama cukup baik. Baris kedua sudah sangat mengelirukan. Apa yang kita mahukan ialah mengekstrak harta benda parameter yang disediakan. Akhirnya, kami mempunyai garis ketiga yang sedikit mengelirukan. Di sini kita cuba melangkah ke atas semua jawatan (disediakan oleh parameter). Sekali lagi, tujuannya adalah untuk mengekstrak sifat tertentu. Bagaimana dengan penyelesaian berikut?

function isString (test) {
    return R.is(String, test);
}

var result = isString('foo'); //=> true

Ini mungkin penyelesaian terbaik untuk kebolehbacaan terima kasih kepada pengaturcaraan fungsional yang dibolehkan Ramda.js. Walau bagaimanapun, kita perlu ambil perhatian bahawa sintaks "anak panah lemak" yang diperkenalkan dalam ECMAScript 6 juga membawa kepada kod yang sangat ringkas dan mudah dibaca:

var isString = R.is(String);
var result = isString('foo'); //=> true

Ini hampir mudah dibaca tanpa pengetahuan Ramda.js. Selain itu, kami mengurangkan bilangan abstraksi - ini hanya akan memberi manfaat kepada prestasi dan pemeliharaan.

lensa

Akhirnya, kita juga harus membincangkan fungsi penolong objek yang berguna. Perlu dinyatakan di sini bahawa fungsi lensa itu. Kanta adalah objek khas yang boleh diluluskan bersama dengan objek atau array ke fungsi Ramda.js tertentu. Ia membolehkan fungsi ini mengambil atau menukar data dari sifat tertentu atau indeks objek atau array, masing -masing. Katakan kita mempunyai objek dengan dua kunci X dan Y - sama seperti contoh invariance yang diberikan pada permulaan artikel. Daripada membungkus objek dalam objek lain dengan kaedah getter dan setter, kita boleh membuat lensa untuk "fokus" pada sifat -sifat kepentingan. Untuk membuat lensa yang mengakses atribut x objek, kita boleh melakukan perkara berikut:

var quadratic = (a, b, c, x) => x * x * a + x * b + c;
quadratic(1, 0, 0, 2); //=> 4
quadratic(1, 0, 0)(2); //=> TypeError: quadratic(..) is not a function

Walaupun prop adalah getter standard (ini telah diperkenalkan), Assoc adalah fungsi setter (tiga nilai sintaks: kunci, nilai, objek). Sekarang kita boleh menggunakan fungsi dalam ramda.js untuk mengakses sifat -sifat yang ditakrifkan oleh lensa ini.

npm install ramda

Perhatikan bahawa operasi ini tidak menyentuh objek kedudukan yang diberikan (sama ada kita membekukannya atau tidak). Harus diingat bahawa set hanyalah satu kes khas, yang sama tetapi mengambil fungsi dan bukannya nilai sewenang -wenangnya. Fungsi ini kemudiannya akan digunakan untuk menukar nilai. Sebagai contoh, panggilan berikut menguburkan koordinat x dengan 3:

var R = require('ramda');

ramda.js, lodash atau lain -lain?

Soalan yang munasabah tentu saja mengapa ramda.js dipilih - mengapa kita tidak menggunakan lodash atau sesuatu? Sudah tentu, seseorang mungkin berpendapat bahawa Ramda.js dikemas kini, jadi ia mesti lebih baik, tetapi itu jauh dari kebenaran. Kebenarannya ialah Ramda.js dibina dengan prinsip -prinsip fungsional dalam fikiran -dengan pendekatan baru untuk penempatan dan pemilihan parameter (untuk perpustakaan JavaScript). Sebagai contoh, penyenaraian Iterator dalam Ramda.js hanya meluluskan item secara lalai, bukan senarai. Sebaliknya, standard untuk perpustakaan lain (seperti lodash) adalah untuk lulus item dan indeks untuk fungsi panggilan balik. Ini seolah-olah sedikit masalah, tetapi ia menghalang anda daripada menggunakan fungsi terbina dalam yang mudah seperti ParseInt () (yang mengambil hujah kedua pilihan), sambil menggunakan ramda.js, ini berfungsi dengan baik. Pada akhirnya, apa yang anda pilih bergantung kepada keperluan khusus atau pengalaman dan/atau pengetahuan pasukan, tetapi ada beberapa alasan yang baik untuk mendapatkan Ramda.js perhatian yang sewajarnya.

bacaan selanjutnya

Fungsi Pesanan Lanjutan
Kenapa kari membantu
Invariance
Mengapa memilih Ramda?
Dokumentasi Ramda
pengaturcaraan berfungsi menggunakan ramda.js

Kesimpulan

Pengaturcaraan berfungsi tidak boleh dianggap sebagai ubat. Sebaliknya, ia harus dilihat sebagai tambahan semulajadi kepada kotak alat kami yang sedia ada, yang memberikan kita komposibiliti yang lebih besar, fleksibiliti yang lebih besar dan toleransi kesalahan/kebolehgunaan yang lebih besar. Perpustakaan JavaScript moden telah cuba memanfaatkan beberapa konsep berfungsi. Ramda.js adalah alat yang berkuasa yang memanjangkan perpustakaan utiliti fungsional anda sendiri. Apa pendapat anda mengenai pengaturcaraan berfungsi? Dalam aspek apa yang anda fikir ia berfungsi dengan baik? Tolong beritahu saya dalam komen!

FAQs (FAQs) pada pengaturcaraan fungsional dengan ramda

Apakah kelebihan utama menggunakan RAMDA untuk pengaturcaraan berfungsi?

Ramda adalah perpustakaan berfungsi praktikal untuk pengaturcara JavaScript. Ia direka untuk gaya pengaturcaraan berfungsi, yang menjadikannya lebih mudah untuk membuat saluran paip berfungsi dan tidak pernah mengubah data pengguna. Kelebihan utama menggunakan RAMDA ialah ia menekankan fungsi invariance dan sampingan. Ini bermakna fungsi itu tidak mengubah data inputnya, menjadikan kod anda lebih mudah untuk diramal dan menguji. Fungsi Ramda secara automatik dikurangkan, yang membolehkan anda dengan mudah membina fungsi baru dari fungsi lama tanpa tersesat dalam sekumpulan kurungan atau neraka panggilan balik.

Bagaimana Ramda berbeza dari perpustakaan JavaScript lain?

Tidak seperti perpustakaan JavaScript lain, Ramda direka untuk menyokong pengaturcaraan berfungsi dan tidak mengubah data. Ia menyediakan satu set fungsi praktikal yang kari secara lalai, yang bermaksud ia dimaksudkan untuk digunakan bersama untuk membuat fungsi baru. Ini sangat berbeza dari perpustakaan seperti garis bawah atau lodash, yang tidak seperti kari secara lalai dan biasanya memerlukan anda menulis kod tambahan untuk mendapatkan hasil yang sama. API Ramda juga lebih konsisten dan lebih mudah digunakan, dengan penekanan pada kesederhanaan dan kebolehbacaan.

Bolehkah saya menggunakan Ramda dengan perpustakaan atau rangka kerja JavaScript yang lain?

Ya, Ramda boleh digunakan dengan perpustakaan dan kerangka JavaScript lain. Ia adalah perpustakaan mandiri yang tidak bergantung kepada mana -mana perpustakaan atau kerangka lain, dan tidak mengubah prototaip objek JavaScript. Ini menjadikannya selamat untuk bekerja dengan perpustakaan atau kerangka lain tanpa perlu bimbang tentang konflik atau kesan sampingan yang tidak dijangka. Sama ada anda menggunakan jQuery, react, angular, vue, atau mana -mana perpustakaan atau kerangka lain, anda boleh menggunakan Ramda untuk membantu menulis kod yang lebih bersih, lebih berfungsi.

Adakah Ramda sesuai untuk pemula dalam pengaturcaraan berfungsi?

Ramda adalah alat yang hebat untuk pemimpin baru dalam pengaturcaraan berfungsi. Reka bentuk APInya mudah dan intuitif, dan konvensyen penamaannya jelas dan konsisten. Dokumentasi ini juga sangat terperinci dan terdapat banyak contoh untuk bermula. Tetapi, seperti mana -mana alat atau paradigma baru, terdapat lengkung pembelajaran. Ia mungkin mengambil sedikit masa untuk membiasakan diri untuk berfikir fungsional dan memahami cara menggunakan fungsi Ramda dengan berkesan. Walau bagaimanapun, dengan amalan, anda akan mendapati bahawa ia dapat memudahkan kod anda dan memudahkan difahami.

Bagaimanakah Ramda mengendalikan nilai null dan undefined?

Ramda merawat nilai null dan tidak jelas sebagai nilai null, sama seperti bagaimana bahasa pengaturcaraan berfungsi lain mengendalikannya. Ini bermakna anda boleh lulus dengan selamat atau tidak jelas kepada fungsi Ramda tanpa menyebabkan kesilapan atau pengecualian. Walau bagaimanapun, adalah idea yang baik untuk sentiasa memeriksa nilai null atau tidak jelas sebelum menyampaikannya kepada fungsi untuk mengelakkan tingkah laku yang tidak dijangka.

Bolehkah saya menggunakan ramda dalam persekitaran node.js?

Ya, Ramda boleh digunakan dalam persekitaran Node.js. Ia adalah perpustakaan biasa yang boleh digunakan dalam penyemak imbas dan node.js. Anda boleh memasangnya melalui npm dan memerlukannya dalam modul Node.js anda seperti mana -mana pakej lain.

Bagaimana Ramda Mengendalikan Operasi Asynchronous?

Ramda tidak mempunyai sokongan operasi asynchronous terbina dalam, kerana ia terutama adalah perpustakaan segerak. Walau bagaimanapun, anda boleh menggunakannya dengan perpustakaan lain yang menyokong operasi asynchronous, seperti janji atau async/menunggu. Anda juga boleh menggunakan fungsi Ramda dalam fungsi asynchronous atau pada masa itu panggilan balik.

Bagaimana untuk menyumbang kepada projek Ramda?

Ramda adalah projek sumber terbuka dan dialu -alukan untuk menyumbang pada bila -bila masa. Anda boleh menyumbang dengan melaporkan pepijat, mencadangkan ciri -ciri baru, meningkatkan dokumentasi, atau mengemukakan permintaan tarik. Sebelum anda menyumbang, lebih baik membaca panduan sumbangan di halaman Ramda GitHub.

Adakah Ramda masih mengekalkan dan mengemas kini?

Ya, Ramda secara aktif mengekalkan dan mengemas kini secara teratur. Kakitangan penyelenggaraan komited untuk menjaga perpustakaan sehingga kini dan menyelesaikan sebarang isu atau kesilapan yang timbul. Anda boleh menyemak halaman GitHub untuk kemas kini dan versi terkini.

Bolehkah saya menggunakan Ramda untuk projek komersial?

Ya, Ramda dilesenkan di bawah lesen MIT, yang bermaksud anda boleh menggunakannya untuk projek komersial. Walau bagaimanapun, adalah idea yang baik untuk sentiasa membaca perjanjian lesen penuh untuk memahami hak dan tanggungjawab anda.

Atas ialah kandungan terperinci Pengaturcaraan berfungsi tangan dengan ramda.js. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!