Funktionaalinen ohjelmointi JavaScript:ssä Osa 1 - Johdanto

Mitä on funktionaalinen ohjelmointi?

"Yksinkertaisesti sanottuna funktionaalinen ohjelmointi on ohjelmistokehitys tyyli, jossa painotetaan toimintojen käyttöä"."

Otteita kirjasta: Luis Atencio "Funktionaalinen ohjelmointi vuonna JavaScript. Miten parantaa JavaScript ohjelmat funktionaalisia tekniikoita käyttäen"

Toiminnallinen ohjelmointi luokitellaan deklaratiivinen paradigma, jossa ohjelman kuvaus on erotettu laskelmista. Tässä korostetaan lausekkeiden käyttöä ohjelmalogiikan kuvaamiseen. Tämä on vastakohta imperatiivinen ohjelmointi, jossa koodi suoritetaan askel askeleelta ja kerrotaan tietokoneelle yksityiskohtaisesti, miten työ tehdään.

Deklaratiivinen vs. imperatiivinen, esimerkkejä

Tarkastellaan tapausta, jossa meillä on joukko kokonaislukuja ja meidän on korotettava jokainen niistä toiseen potenssiin ja valittava sitten vain ne arvot, jotka eivät ole parillisia.

Imperatiivinen

const numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9];

const results = []

for(let i = 0; i < numbers.length; i++) {
const secondPower = Math.pow(numbers[i], 2)
if(secondPower & 1) { // tai % 2, mutta bittioperaatiot ovat nopeampia.
results.push(secondPower);
}
}

console.log(results) // [1, 9, 25, 49, 81]

Mitä tulee imperatiivinen ratkaisussa on selvästi nähtävissä, että keskitytään toteutuksen yksityiskohtiin. Silmukassa näkyy array-indeksi, joka perustuu tarpeeseen hallita elementtien määrää. Koska koodissa on paljon yksityiskohtia, on vaikeampi keskittyä siihen, mitä se tekee. Keskitytään nyt deklaratiivinen ratkaisu.

Deklaratiivinen

const risesToSecondPower = (num) => Math.pow(num, 2)
const isOdd = (num) => num & 1;

const numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]

const results = numbers
.map(risesToSecondPower)
.filter(isOdd);

console.log(results) // [1, 9, 25, 49, 81]

Tässä ratkaisussa toteutus on erotettu kutsumisesta viemällä logiikka erillisiin funktioihin. Tämän ratkaisun ansiosta voimme keskittyä vain funktioiden nimiin, jotka kuvaavat, mitä niissä tapahtuu. Lisäksi abstraktiotasoa on nostettu, ja logiikka voi nyt olla uudelleenkäytettävissä. Keskitytään nyt kutsuun. Siinä ei näy mitään yksityiskohtia, vain kuvaus, joka kertoo vaihe vaiheelta, mitä tämä koodi tekee:

1. map(risesToSecondPower) - ottaa jokaisen array-alkion ja korottaa sen toiseen potenssiin,
2. filter(isOdd) - suodatin ja valitse parittomat elementit.

Edut

Toiminnallinen ohjelmointi on monia etuja. Kun on kyse JavaScript, funktioiden käyttö on luonnollista, koska kyseessä on funktionaalinen kieli. Jopa tämän kielen luokat ovat "syntaktista sokeria", ja ne koostuvat funktioista.

Mitä tulee luettavuuteen, imperatiivisessa lähestymistavassa koodista tulee yleensä luettelo funktioiden nimistä, jotka voidaan lukea peräkkäin syventymättä niiden logiikkaan. Tämän seurauksena emme keskity toteutuksen yksityiskohtiin.

Toinen etu on pysyminen muuttumattomien objektien konventiossa. Tämän lähestymistavan ansiosta koodista tulee turvallisempaa, koska viittaukset in JavaScript ovat erittäin vahvoja, ja ei-toivottua kohdetta on helppo muokata.

Funktionaalisessa ohjelmoinnissa koodi jaetaan pieniin funktioihin, joita voidaan helposti pitää uudelleenkäytettävänä abstraktina koodina.

Puhdas toiminto

Yksi funktionaalisen ohjelmoinnin tärkeistä näkökohdista ovat puhtaat funktiot. Tällaisen funktion luomiseksi sinun on muistettava muutama sääntö:

• funktion palauttama tulos riippuu vain syöttöparametreista,
• älä käytä globaaleja muuttujia ja muuttujia, jotka ovat oman alueesi ulkopuolella,
• eivät muuta parametrien tilaa,
• puhtailla funktioilla ei ole sivuvaikutuksia (yleensä objektien ominaisuuksien muuttaminen),
• ilmoitetuille syöttöparametreille, ne palauttavat aina yhden ja saman tuloksen,
• puhdas funktio ottaa aina parametrin ja palauttaa aina parametrin.

// Inpure-toiminto
let counter = 5
...
const multipleCounter = (multiplier) => {
laskuri = laskuri * kerroin
}

multiplyCounter(2) // -> ? tulos riippuu alkuarvosta.

// Pure function
const multiplyBy = (kerroin) => (arvo) => arvo * kerroin
const multipleByTwo = multiplyBy(2)

const counter = multiplyByTwo(5) // -> 10

Ensimmäinen toiminto on arvaamaton, koska se riippuu ulkoisesta parametrista, joka voi muuttua. Toinen funktio on läpinäkyvä, koska se riippuu vain syöttöparametreista, ei muuta niitä eikä käytä alueen ulkopuolisia muuttujia. Se on läpinäkyvä, koska se riippuu parametreista, ei muuta niitä, ei käytä alueen ulkopuolisia muuttujia ja palauttaa uuden arvon.