Pengenalan kepada pengaturcaraan fungsional yang murni

3

Takeaways Key

Fungsi tulen adalah penting dalam pengaturcaraan fungsional kerana mereka mengembalikan output yang sama untuk input yang sama tanpa menyebabkan kesan sampingan, meningkatkan kebolehprediksi dan kebolehlaksanaan.

Pengaturcaraan berfungsi mengurangkan kerumitan program dengan memecahkan proses ke dalam fungsi yang lebih mudah dan tidak berubah, yang membantu dalam meminimumkan pepijat dan meningkatkan kebolehbacaan kod.

over-abstraction dalam pengaturcaraan berfungsi, sambil mengurangkan kerumitan kod, boleh menyebabkan kod yang sukar difahami dan diselenggarakan, menonjolkan kepentingan keseimbangan.

• fungsi JavaScript penting seperti `MAP`,` Mengurangkan`, `Penapis`, dan` Compose` adalah penting untuk mengadopsi paradigma pengaturcaraan berfungsi dan memudahkan penciptaan kod yang lebih ringkas dan deklaratif.
Ujian menjadi lebih mudah dengan fungsi tulen, kerana sifat terpencil mereka membolehkan persediaan ujian yang lebih mudah dan hasil yang diharapkan.
Pengaturcaraan berfungsi bukan sekadar konsep teori tetapi boleh digunakan dalam senario praktikal seperti mengendalikan operasi tak segerak dan kemas kini UI, menunjukkan kaitannya dalam pembangunan web moden.
Artikel ini dikaji semula oleh Panayiotis «Pvgr» Velisarakos, Jezen Thomas dan Florian Rappl. Terima kasih kepada semua pengulas rakan sebaya SitePoint untuk membuat kandungan SitePoint yang terbaik!
Apabila belajar untuk program, anda mula -mula diperkenalkan kepada pengaturcaraan prosedur; Di sinilah anda mengawal mesin dengan memberi makan senarai perintah yang berurutan. Selepas anda mempunyai pemahaman tentang beberapa asas bahasa seperti pembolehubah, tugasan, fungsi dan objek yang anda dapat bersama -sama dengan program yang mencapai apa yang anda berikan untuk melakukannya - dan anda merasa seperti wizard mutlak.
• Proses menjadi
lebih baik
• pengaturcara adalah tentang mendapatkan keupayaan yang lebih besar untuk mengawal program yang anda tulis dan mencari penyelesaian paling mudah yang kedua
. Apabila anda menjadi pengaturcara yang lebih baik, anda akan menulis fungsi yang lebih kecil, mencapai penggunaan semula kod anda yang lebih baik, tulis ujian untuk kod anda dan anda akan mendapat keyakinan bahawa program yang anda tulis akan terus dilakukan seperti yang anda inginkan. Tiada siapa yang suka mencari dan menetapkan pepijat dalam kod, jadi menjadi pengaturcara yang lebih baik juga tentang mengelakkan perkara-perkara tertentu yang rawan kesilapan. Belajar apa yang harus dielakkan datang melalui pengalaman atau mengutamakan nasihat orang -orang yang lebih berpengalaman, seperti Douglas Crockford yang terkenal menerangkan dalam JavaScript: bahagian yang baik.

Pengaturcaraan berfungsi memberi kita cara untuk menurunkan kerumitan program kami dengan mengurangkannya ke dalam bentuk yang paling mudah: fungsi yang berkelakuan seperti fungsi matematik tulen. Mempelajari prinsip -prinsip pengaturcaraan berfungsi adalah tambahan yang hebat untuk set kemahiran anda dan akan membantu anda menulis program yang lebih mudah dengan bug yang lebih sedikit.

Konsep utama pengaturcaraan berfungsi adalah fungsi tulen, nilai yang tidak berubah, komposisi dan kesan sampingan.

fungsi tulen

Fungsi tulen adalah fungsi yang, diberi input yang sama, akan sentiasa mengembalikan output yang sama dan tidak mempunyai kesan sampingan yang dapat dilihat.

<span>// pure
</span><span>function add(a<span>, b</span>) {
</span>  <span>return a + b;
</span><span>}
</span>

Fungsi ini adalah PURE . Ia tidak bergantung kepada atau mengubah mana -mana keadaan di luar fungsi dan ia akan sentiasa mengembalikan nilai output yang sama untuk input yang sama.

<span>// impure
</span><span>var minimum = 21;
</span><span>var checkAge = function(age) {
</span>  <span>return age >= minimum; // if minimum is changed we're cactus
</span><span>};
</span>

Fungsi ini tidak suci kerana ia bergantung pada keadaan mutable luaran di luar fungsi.

Jika kita menggerakkan pembolehubah ini di dalam fungsi ia menjadi murni dan kita pasti bahawa fungsi kita akan menyemak usia kita setiap kali .

<span>// pure
</span><span>var checkAge = function(age) {
</span>  <span>var minimum = 21;
</span>  <span>return age >= minimum;
</span><span>};
</span>

Fungsi tulen tidak mempunyai kesan sampingan . Berikut adalah beberapa perkara penting yang perlu diingat:

mengakses keadaan sistem di luar fungsi
objek bermutasi diluluskan sebagai argumen
membuat panggilan http
Mendapatkan Input Pengguna
Menanyakan Dom

Mutasi terkawal

Anda perlu menyedari kaedah mutator pada tatasusunan dan objek yang mengubah objek bawah, contohnya adalah perbezaan antara splice array dan kaedah slice.

<span>// impure, splice mutates the array
</span><span>var firstThree = function(arr) {
</span>  <span>return arr.splice(0,3); // arr may never be the same again
</span><span>};
</span>
<span>// pure, slice returns a new array
</span><span>var firstThree = function(arr) {
</span>  <span>return arr.slice(0,3);
</span><span>};
</span>

Jika kita mengelakkan kaedah mutasi pada objek yang diluluskan ke fungsi kita, program kita menjadi lebih mudah untuk alasan, kita boleh mengharapkan fungsi kita tidak boleh menukar perkara dari bawah kita.

faedah fungsi tulen

<span>let items = ['a','b','c'];
</span><span>let newItems = pure(items);
</span><span>// I expect items to be ['a','b','c']
</span>

fungsi tulen mempunyai beberapa faedah ke atas rakan -rakan mereka yang tidak suci:

lebih mudah diuji sebagai tanggungjawab tunggal mereka adalah untuk memetakan input -> output

• Hasil boleh dikacau kerana input yang sama selalu menghasilkan output yang sama
• Dokumentasi diri sebagai kebergantungan fungsi adalah eksplisit
• lebih mudah untuk bekerja dengan kerana anda tidak perlu bimbang tentang kesan sampingan
Oleh kerana hasil fungsi tulen boleh dikosongkan, kita dapat memoize mereka sehingga operasi mahal hanya dilakukan pada kali pertama fungsi dipanggil. Sebagai contoh, memoizing hasil mencari indeks yang besar akan menghasilkan peningkatan prestasi besar pada run semula.

pengaturcaraan fungsional yang tidak munasabah

Mengurangkan program kami ke fungsi tulen secara drastik dapat mengurangkan kerumitan program kami. Walau bagaimanapun, program berfungsi kami juga boleh memerlukan bantuan Rain Man untuk memahami jika kita menolak abstraksi fungsional terlalu jauh.

ambil satu minit untuk mencerna kod di atas.

<span>import _ from 'ramda';
</span><span>import $ from 'jquery';
</span>
<span>var Impure = {
</span>  <span>getJSON: _.curry(function(callback<span>, url</span>) {
</span>    $<span>.getJSON(url, callback);
</span>  <span>}),
</span>
  <span>setHtml: _.curry(function(sel<span>, html</span>) {
</span>    <span>$(sel).html(html);
</span>  <span>})
</span><span>};
</span>
<span>var img = function (url) {
</span>  <span>return $('<img  alt="Pengenalan kepada pengaturcaraan fungsional yang murni" >', { src: url });
</span><span>};
</span>
<span>var url = function (t) {
</span>  <span>return 'http://api.flickr.com/services/feeds/photos_public.gne?tags=' +
</span>    t <span>+ '&format=json&jsoncallback=?';
</span><span>};
</span>
<span>var mediaUrl = _.compose(_.prop('m'), _.prop('media'));
</span><span>var mediaToImg = _.compose(img, mediaUrl);
</span><span>var images = _.compose(_.map(mediaToImg), _.prop('items'));
</span><span>var renderImages = _.compose(Impure.setHtml("body"), images);
</span><span>var app = _.compose(Impure.getJSON(renderImages), url);
</span><span>app("cats");
</span>

Kecuali anda mempunyai latar belakang dalam pengaturcaraan berfungsi abstraksi ini (kari, penggunaan yang berlebihan dan prop) benar -benar sukar untuk diikuti, seperti aliran pelaksanaan. Kod di bawah adalah lebih mudah difahami dan diubahsuai, ia juga lebih jelas menerangkan program ini daripada pendekatan semata -mata berfungsi di atas dan kod kurang.

• Fungsi aplikasi mengambil rentetan tag
• mengambil json dari flickr
• menarik URL keluar respons
• membina pelbagai nod
• memasukkannya ke dalam dokumen

<span>// pure
</span><span>function add(a<span>, b</span>) {
</span>  <span>return a + b;
</span><span>}
</span>

atau, API alternatif ini menggunakan abstraksi seperti mengambil dan berjanji membantu kita menjelaskan makna tindakan asynchronous kita lebih jauh lagi.

<span>// impure
</span><span>var minimum = 21;
</span><span>var checkAge = function(age) {
</span>  <span>return age >= minimum; // if minimum is changed we're cactus
</span><span>};
</span>

Nota: Ambil dan janji adalah piawaian yang akan datang sehingga mereka memerlukan polyfills untuk digunakan hari ini.

Permintaan AJAX dan operasi DOM tidak akan menjadi murni tetapi kita boleh membuat fungsi murni daripada yang lain, memetakan JSON respons kepada pelbagai imej - mari kita maafkan kebergantungan pada jQuery buat masa ini.

<span>// pure
</span><span>var checkAge = function(age) {
</span>  <span>var minimum = 21;
</span>  <span>return age >= minimum;
</span><span>};
</span>

Fungsi kami hanya melakukan dua perkara sekarang:

• data tindak balas pemetaan -> url
• pemetaan url -> imej

Cara "berfungsi" untuk melakukan ini adalah untuk mewujudkan fungsi berasingan untuk kedua -dua tugas tersebut dan kita boleh menggunakan Compose untuk lulus tindak balas satu fungsi ke yang lain.

<span>// impure, splice mutates the array
</span><span>var firstThree = function(arr) {
</span>  <span>return arr.splice(0,3); // arr may never be the same again
</span><span>};
</span>
<span>// pure, slice returns a new array
</span><span>var firstThree = function(arr) {
</span>  <span>return arr.slice(0,3);
</span><span>};
</span>

mengarang pulangan fungsi yang merupakan komposisi senarai fungsi, masing -masing memakan nilai pulangan fungsi yang berikut.

Inilah yang dikarang dilakukan, lulus tindak balas URL ke dalam fungsi imej kami.

<span>let items = ['a','b','c'];
</span><span>let newItems = pure(items);
</span><span>// I expect items to be ['a','b','c']
</span>

ia membantu membaca hujah -hujah untuk mengarang dari kanan ke kiri untuk memahami arah aliran data.

dengan mengurangkan program kami ke fungsi tulen, ia memberi kita keupayaan yang lebih besar untuk menggunakannya semula pada masa akan datang, mereka lebih mudah untuk diuji dan mereka mendokumentasikan diri. Kelemahannya ialah apabila digunakan secara berlebihan (seperti dalam contoh pertama) abstraksi fungsional ini boleh membuat sesuatu lebih kompleks yang pastinya bukan apa yang kita inginkan. Soalan yang paling penting untuk ditanya apabila kod refactoring walaupun ini:

adakah kod lebih mudah dibaca dan difahami?

fungsi penting

Sekarang, saya tidak cuba menyerang pengaturcaraan berfungsi sama sekali. Setiap pemaju harus membuat usaha bersepadu untuk mempelajari fungsi asas yang membolehkan anda abstrak corak umum dalam pengaturcaraan ke dalam kod deklaratif yang lebih ringkas, atau sebagai Marijn Haverbeke meletakkannya ..

Seorang pengaturcara yang bersenjata dengan repertoar fungsi asas dan, lebih penting lagi, pengetahuan tentang cara menggunakannya, jauh lebih berkesan daripada seseorang yang bermula dari awal. - JavaScript yang fasih, Marijn HaverBeke

Berikut adalah senarai fungsi penting yang setiap pemaju JavaScript harus belajar dan menguasai. Ini juga cara yang baik untuk menyikat kemahiran JavaScript anda untuk menulis setiap fungsi ini dari awal.

Arrays

• foreach
• peta
• penapis
• Kurangkan

Fungsi

• debounce
• Compose
• Partial
• Curry

kurang lebih

Mari kita lihat beberapa langkah praktikal yang boleh kita ambil untuk memperbaiki kod di bawah menggunakan konsep pengaturcaraan berfungsi.

<span>// pure
</span><span>function add(a<span>, b</span>) {
</span>  <span>return a + b;
</span><span>}
</span>

Mengurangkan fungsi pergantungan pada keadaan bersama

Ini mungkin kelihatan jelas dan remeh tetapi saya masih menulis fungsi yang mengakses dan mengubah banyak keadaan di luar diri mereka, ini menjadikan mereka lebih sukar untuk diuji dan lebih mudah terdedah kepada kesilapan.

<span>// impure
</span><span>var minimum = 21;
</span><span>var checkAge = function(age) {
</span>  <span>return age >= minimum; // if minimum is changed we're cactus
</span><span>};
</span>

Gunakan lebih banyak abstraksi bahasa yang boleh dibaca seperti foreach to iterate

<span>// pure
</span><span>var checkAge = function(age) {
</span>  <span>var minimum = 21;
</span>  <span>return age >= minimum;
</span><span>};
</span>

Gunakan abstraksi tahap yang lebih tinggi seperti peta untuk mengurangkan jumlah kod

<span>// impure, splice mutates the array
</span><span>var firstThree = function(arr) {
</span>  <span>return arr.splice(0,3); // arr may never be the same again
</span><span>};
</span>
<span>// pure, slice returns a new array
</span><span>var firstThree = function(arr) {
</span>  <span>return arr.slice(0,3);
</span><span>};
</span>

Kurangkan fungsi ke bentuk yang paling mudah

<span>let items = ['a','b','c'];
</span><span>let newItems = pure(items);
</span><span>// I expect items to be ['a','b','c']
</span>

padam kod sehingga berhenti berfungsi

Kami tidak memerlukan fungsi sama sekali untuk tugas yang mudah, bahasa ini memberikan kita abstraksi yang mencukupi untuk menulisnya verbatim.

<span>import _ from 'ramda';
</span><span>import $ from 'jquery';
</span>
<span>var Impure = {
</span>  <span>getJSON: _.curry(function(callback<span>, url</span>) {
</span>    $<span>.getJSON(url, callback);
</span>  <span>}),
</span>
  <span>setHtml: _.curry(function(sel<span>, html</span>) {
</span>    <span>$(sel).html(html);
</span>  <span>})
</span><span>};
</span>
<span>var img = function (url) {
</span>  <span>return $('<img  alt="Pengenalan kepada pengaturcaraan fungsional yang murni" >', { src: url });
</span><span>};
</span>
<span>var url = function (t) {
</span>  <span>return 'http://api.flickr.com/services/feeds/photos_public.gne?tags=' +
</span>    t <span>+ '&format=json&jsoncallback=?';
</span><span>};
</span>
<span>var mediaUrl = _.compose(_.prop('m'), _.prop('media'));
</span><span>var mediaToImg = _.compose(img, mediaUrl);
</span><span>var images = _.compose(_.map(mediaToImg), _.prop('items'));
</span><span>var renderImages = _.compose(Impure.setHtml("body"), images);
</span><span>var app = _.compose(Impure.getJSON(renderImages), url);
</span><span>app("cats");
</span>

ujian

dapat hanya menguji program kami adalah manfaat utama fungsi tulen, jadi dalam bahagian ini kami akan menubuhkan abah -abah ujian untuk modul Flickr kami yang kami lihat sebelumnya.

Api terminal dan editor teks anda bersedia dan siap, kami akan menggunakan Mocha sebagai pelari ujian kami dan Babel untuk menyusun kod ES6 kami.

<span>var app = (tags)=> {
</span>  <span>let url = <span>`http://api.flickr.com/services/feeds/photos_public.gne?tags=<span>${tags}</span>&format=json&jsoncallback=?`</span>
</span>  $<span>.getJSON(url, (data)=> {
</span>    <span>let urls = data.items.map((item)=> item.media.m)
</span>    <span>let images = urls.map((url)=> $('<img  alt="Pengenalan kepada pengaturcaraan fungsional yang murni" >', { src: url }) )
</span>
    <span>$(document.body).html(images)
</span>  <span>})
</span><span>}
</span><span>app("cats")
</span>

Mocha mempunyai sekumpulan fungsi berguna seperti menggambarkan dan ia untuk memecahkan ujian dan cangkuk kami seperti sebelum dan selepas untuk tugas persediaan dan air mata. menegaskan adalah pakej nod teras yang boleh melakukan ujian kesamaan mudah, menegaskan dan menegaskan. Deepequal adalah fungsi yang paling berguna untuk diperhatikan.

mari kita tulis ujian pertama kami dalam ujian/contoh.js

<span>let flickr = (tags)=> {
</span>  <span>let url = <span>`http://api.flickr.com/services/feeds/photos_public.gne?tags=<span>${tags}</span>&format=json&jsoncallback=?`</span>
</span>  <span>return fetch(url)
</span>  <span>.then((resp)=> resp.json())
</span>  <span>.then((data)=> {
</span>    <span>let urls = data.items.map((item)=> item.media.m )
</span>    <span>let images = urls.map((url)=> $('<img  alt="Pengenalan kepada pengaturcaraan fungsional yang murni" >', { src: url }) )
</span>
    <span>return images
</span>  <span>})
</span><span>}
</span><span>flickr("cats").then((images)=> {
</span>  <span>$(document.body).html(images)
</span><span>})
</span>

buka pakej.json dan pindaan skrip "ujian" kepada

berikut

<span>let responseToImages = (resp)=> {
</span>  <span>let urls = resp.items.map((item)=> item.media.m )
</span>  <span>let images = urls.map((url)=> $('<img  alt="Pengenalan kepada pengaturcaraan fungsional yang murni" >', { src: url }))
</span>
  <span>return images
</span><span>}
</span>

maka anda harus dapat menjalankan ujian NPM dari baris arahan untuk mengesahkan segala -galanya berfungsi seperti yang diharapkan.

<span>let urls = (data)=> {
</span>  <span>return data.items.map((item)=> item.media.m)
</span><span>}
</span><span>let images = (urls)=> {
</span>  <span>return urls.map((url)=> $('<img  alt="Pengenalan kepada pengaturcaraan fungsional yang murni" >', { src: url }))
</span><span>}
</span><span>let responseToImages = _.compose(images, urls)
</span>

boom.

Nota: Anda juga boleh menambah bendera -w bendera pada akhir arahan ini jika anda mahu Mocha menonton perubahan dan menjalankan ujian secara automatik, mereka akan berjalan dengan lebih cepat pada semula.

<span>let responseToImages = (data)=> {
</span>  <span>return images(urls(data))
</span><span>}
</span>

menguji modul flickr kami

mari tambahkan modul kami ke lib/flickr.js

<span>let items = ['a', 'b', 'c'];
</span><span>let upperCaseItems = ()=> {
</span>  <span>let arr = [];
</span>  <span>for (let i = 0, ii = items.length; i     <span>let item = items[i];
</span>    arr<span>.push(item.toUpperCase());
</span>  <span>}
</span>  items <span>= arr;
</span><span>}
</span></span>

Modul kami mendedahkan dua kaedah: Flickr akan dimakan secara terbuka dan fungsi peribadi _responsetoimages supaya kita dapat menguji bahawa secara berasingan.

Kami mempunyai beberapa kebergantungan baru: jQuery, underscore dan polyfills untuk mengambil dan berjanji. Untuk menguji mereka yang boleh kita gunakan jsdom untuk polyfill tetingkap dan dokumen DOM Objek dan kita boleh menggunakan pakej Sinon untuk merapatkan API Fetch.

<span>// pure
</span><span>function add(a<span>, b</span>) {
</span>  <span>return a + b;
</span><span>}
</span>

Buka ujian/_setup.js dan kami akan mengkonfigurasi JSDOM dengan global kami bahawa modul kami bergantung pada.

<span>// impure
</span><span>var minimum = 21;
</span><span>var checkAge = function(age) {
</span>  <span>return age >= minimum; // if minimum is changed we're cactus
</span><span>};
</span>

Ujian kami boleh duduk dalam ujian/flickr.js di mana kami akan membuat pernyataan mengenai output fungsi kami yang diberikan input yang telah ditetapkan. Kami "melengkapkan" atau mengatasi kaedah pengambilan global untuk memintas dan memalsukan permintaan HTTP supaya kami dapat menjalankan ujian kami tanpa memukul API Flickr secara langsung.

<span>// pure
</span><span>var checkAge = function(age) {
</span>  <span>var minimum = 21;
</span>  <span>return age >= minimum;
</span><span>};
</span>

Jalankan ujian kami sekali lagi dengan ujian NPM dan anda harus melihat tiga kutu hijau yang menjamin.

<span>// impure, splice mutates the array
</span><span>var firstThree = function(arr) {
</span>  <span>return arr.splice(0,3); // arr may never be the same again
</span><span>};
</span>
<span>// pure, slice returns a new array
</span><span>var firstThree = function(arr) {
</span>  <span>return arr.slice(0,3);
</span><span>};
</span>

phew! Kami telah berjaya menguji modul kecil kami dan fungsi -fungsi yang terdiri daripada ia, belajar tentang fungsi tulen dan cara menggunakan komposisi berfungsi di sepanjang jalan. Kami telah memisahkan yang tulen dari yang tidak suci, ia boleh dibaca, terdiri daripada fungsi kecil, dan ia diuji dengan baik. Kod ini lebih mudah untuk membaca, memahami, dan mengubah suai daripada contoh yang tidak munasabah di atas dan itulah satu -satunya tujuan saya apabila kod refactoring.

fungsi tulen, gunakannya.

Pautan

• Panduan Profesor Frisby yang paling mencukupi untuk pengaturcaraan berfungsi - @Drboolean - buku percuma yang sangat baik ini mengenai pengaturcaraan fungsional oleh Brian Lonsdorf adalah panduan terbaik untuk FP yang saya jumpai. Banyak idea dan contoh dalam artikel ini telah datang dari buku ini.
• JavaScript yang fasih - Pengaturcaraan Fungsional @Marijnjh - buku Marijn HaverBeke tetap menjadi salah satu intros kegemaran saya sepanjang masa untuk pengaturcaraan dan mempunyai bab yang hebat mengenai pengaturcaraan berfungsi juga.
• Underscore - Menggali perpustakaan utiliti seperti garis bawah, Lodash atau Ramda adalah langkah penting dalam matang sebagai pemaju. Memahami cara menggunakan fungsi ini secara drastik akan mengurangkan jumlah kod yang anda perlukan untuk menulis, dan menjadikan program anda lebih deklaratif.

-

Itu semua buat masa ini! Terima kasih kerana membaca dan saya harap anda dapati ini pengenalan yang baik untuk pengaturcaraan fungsional, refactoring dan ujian dalam JavaScript. Ia adalah paradigma yang menarik yang membuat gelombang pada masa ini, disebabkan oleh populariti perpustakaan yang semakin meningkat seperti React, Redux, Elm, Cycle dan Reactivex yang menggalakkan atau menguatkuasakan corak -corak ini.

melompat masuk, air hangat.

soalan yang sering ditanya mengenai pengaturcaraan fungsional yang murni

Apakah kepentingan fungsi tulen dalam pengaturcaraan berfungsi? Mereka adalah fungsi yang sentiasa menghasilkan output yang sama untuk input yang sama dan tidak mempunyai kesan sampingan. Ini bermakna mereka tidak mengubah mana -mana negeri di luar skop mereka atau bergantung kepada mana -mana keadaan luaran. Ini menjadikan mereka dapat diramalkan dan mudah diuji, kerana anda hanya perlu mempertimbangkan input dan output, tanpa bimbang tentang faktor luaran. Fungsi tulen juga mempromosikan kebolehgunaan semula kod dan kebolehbacaan, menjadikan kod anda lebih mudah difahami dan diselenggara.

Bagaimanakah pengaturcaraan berfungsi berbeza daripada paradigma pengaturcaraan lain? Ini berbeza dengan pengaturcaraan yang penting, di mana program terdiri daripada kenyataan yang mengubah keadaan global apabila dilaksanakan. Pengaturcaraan fungsional menggalakkan abstraksi peringkat tinggi, seperti fungsi sebagai warga kelas pertama, dan menggalakkan pengaturcaraan dengan ungkapan dan bukannya kenyataan. Ini membawa kepada gaya pengaturcaraan yang lebih deklaratif dan ekspresif yang lebih mudah untuk alasan. menghasilkan output yang sama untuk input yang sama dan tidak menghasilkan sebarang kesan sampingan. Berikut adalah contoh:

fungsi tambah (a, b) { kembali b; }

Dalam contoh ini, fungsi tambah adalah fungsi tulen kerana ia selalu mengembalikannya Hasil yang sama diberikan hujah yang sama dan tidak mengubah suai mana -mana keadaan luaran. Mereka membuat kod anda lebih diramalkan dan lebih mudah untuk diuji dan debug, kerana anda hanya perlu mempertimbangkan input dan output fungsi. Mereka juga membuat kod anda lebih mudah dibaca dan dikekalkan, kerana mereka mempromosikan gaya pengaturcaraan yang jelas dan mudah. Tambahan pula, fungsi tulen sangat boleh diguna semula dan boleh digunakan, membolehkan anda membina fungsi yang lebih kompleks dengan kod yang kurang. , mereka juga mengemukakan beberapa cabaran. Salah satu cabaran utama ialah JavaScript bukan bahasa yang semata -mata berfungsi, dan ia membolehkan kesan sampingan dan data yang boleh berubah. Ini bermakna anda perlu berhati -hati untuk mengelakkan kesan sampingan secara tidak sengaja dalam fungsi anda. Di samping itu, menggunakan fungsi tulen kadang -kadang boleh membawa kepada lebih banyak kod verbose, kerana anda perlu mengelakkan data bermutasi dan sebaliknya mengembalikan data baru. sangat sesuai untuk kesesuaian dan paralelisme. Kerana fungsi tulen tidak mempunyai kesan sampingan, mereka boleh dilaksanakan dengan selamat selari tanpa bimbang tentang keadaan kaum atau rasuah data. Ini menjadikan pengaturcaraan berfungsi sebagai alat yang berkuasa untuk membangunkan aplikasi serentak dan selari, terutamanya dalam persekitaran pengkomputeran pelbagai teras dan diedarkan.

Apakah komposisi fungsi dalam pengaturcaraan berfungsi? Ia melibatkan menggabungkan dua atau lebih fungsi untuk mewujudkan fungsi baru. Hasil dari satu fungsi digunakan sebagai input kepada fungsi seterusnya. Ini membolehkan anda membina fungsi yang kompleks dari fungsi mudah, mempromosikan kebolehbacaan kod dan kebolehbacaan. Ini bermakna apabila struktur data dibuat, ia tidak boleh diubah. Sebaliknya, jika anda ingin mengubahsuai struktur data, anda membuat yang baru dengan perubahan yang dikehendaki. Ini mengelakkan kesan sampingan dan menjadikan kod anda lebih selamat dan lebih mudah untuk alasan. Daripada mengubah keadaan, pengaturcaraan berfungsi sering menggunakan fungsi tulen yang mengembalikan keadaan baru. Ini menjadikan negeri ini dapat diramalkan dan mudah dikendalikan. Beberapa bahasa pengaturcaraan berfungsi juga menawarkan ciri -ciri canggih untuk pengurusan negeri, seperti monad di Haskell. . Ia amat berguna dalam situasi di mana keserasian dan paralelisme adalah penting, seperti dalam pengkomputeran berbilang teras dan diedarkan. Pengaturcaraan fungsional juga biasa digunakan dalam pemprosesan data dan analisis, di mana fungsi tulen dan kebolehubahan dapat membantu memastikan integriti data. Selain itu, konsep pengaturcaraan berfungsi semakin diguna pakai dalam pembangunan front-end, dengan rangka kerja popular seperti React.js menggunakan gaya berfungsi untuk pembangunan komponen.

Atas ialah kandungan terperinci Pengenalan kepada pengaturcaraan fungsional yang murni. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!