Kiire sissejuhatus rekursioonile Javascriptis

Funktsioon kutsub ennast seni, kuni keegi selle peatab.

Rekursioon võib uutele arendajatele keeruline tunduda. Võib-olla sellepärast, et paljud ressursid õpetavad seda algoritmiliste näidete abil (Fibonacci, lingitud loendid). Loodetavasti tutvustab see tükk asju lihtsalt, kasutades ühte lihtsat näidet.

Põhiidee

Rekursioon on see, kui funktsioon helistab ise, kuni keegi selle peatab. Kui keegi seda ei peata, kordub see (helistab ise) igavesti.

ei-see-on-patrick

Rekursiivsed funktsioonid võimaldavad teil ühikut tööd teha mitu korda. See on täpselt see, mida for/whilelaseme silmustel saavutada! Mõnikord on rekursiivsed lahendused probleemi lahendamiseks elegantsem lähenemine.

Countdown funktsioon

Loome funktsiooni, mis loendab etteantud arvu. Me kasutame seda niimoodi.

countDownFrom(5); // 5 // 4 // 3 // 2 // 1 

Ja siin on meie algoritm selle probleemi lahendamiseks.

  1. Võtke üks parameeter nimega number. See on meie lähtepunkt.
  2. Minge numberalla 0, logides igaüks mööda teed.

Alustame fortsüklilisest lähenemisest ja võrdleme seda siis rekursiivsega.

Imperatiivne lähenemine (tsüklid)

function countDownFrom(number) { for (let i = number; i > 0; i--) { console.log(i); } } countDownFrom(5); // 5 // 4 // 3 // 2 // 1 

See sisaldab mõlemat algoritmilist sammu.

  1. ✅ Võtke üks parameeter nimega number.
  2. ✅ Logi kõik sisse numberkuni 0.

Rekursiivne lähenemine

function countDownFrom(number) { if (number === 0) { return; } console.log(number); countDownFrom(number - 1); } countDownFrom(5); // 5 // 4 // 3 // 2 // 1 

Ka see möödub.

  1. ✅ Võtke üks parameeter nimega number.
  2. ✅ Logi kõik sisse numberkuni 0.

Nii et kontseptuaalselt on need kaks lähenemist ühesugused. Kuid nad saavad töö tehtud erineval viisil.

Meie hädavajaliku lahenduse silumine

Visuaalsema näite saamiseks lisame oma silmuseversiooni a debuggerja viskame selle Chrome'i arendaja tööriistadesse.

function countDownFrom(number) { for (let i = number; i > 0; i--) { console.log(i); debugger; } } 

countdownFrom-iteratiivne

Vaadake, kuidas ta kasutab ipraeguse numbri jälgimiseks lisamuutujat ? Kui kordate, iväheneb see lõpuks 0ja lõpeb.

Ja fortsüklis täpsustasime "stop if i > 0".

Meie rekursiivse lahenduse silumine

function countDownFrom(number) { if (number === 0) { return; } console.log(number); debugger; countDownFrom(number - 1); } 

countdownFrom-rekursiivne

Rekursiivne versioon ei vaja edasiliikumise jälgimiseks lisamuutujaid. Pange tähele, kuidas funktsioonihunnik ( kõnepakk ) kasvab, kui me kordume?

Seda seetõttu, et iga kutse kasutajale countDownFromlisab virna, lisades selle number - 1. Seda tehes liigume numberiga kord uuendatud versiooniga . Lisariiki pole vaja!

See on kahe lähenemise peamine erinevus.

  1. Iteratiiv kasutab sisemist olekut (lisamuutujad loendamiseks jne).
  2. Rekursiivne ei, see lihtsalt edastab värskendatud parameetrid iga kõne vahel.

Aga kuidas saab kumbki versioon teada, millal peatuda?

Lõputud aasad

Reisil olles võis teid hoiatada kardetud lõpmatu silmuse eest.

? THIS RUNS FOREVER, BE WARNED ? while (true) { console.log('WHY DID YOU RUN THIS?!' } ? THIS RUNS FOREVER, BE WARNED ? for (i = 0;;) { console.log('WHY DID YOU RUN THIS?!') } 

Kuna need töötaksid teoreetiliselt igavesti, peatab lõpmatu silmus teie programmi ja võib-olla ka teie brauseri krahhi. Nende vältimiseks saate alati peatamistingimuse kodeerida .

✅ This does not run forever x = 0; while (x < 3) { console.log(x); x++; } ✅ This does not run forever for (x = 0; x < 3; x++) { console.log(x); } 

Mõlemal juhul logime sisse x, suurendame seda ja peatume, kui see saab 3. Meie countDownFromfunktsioonil oli sarnane loogika.

// Stop at 0 for (let i = number; i > 0; i--) 

Jällegi vajavad tsüklid lisaseisundit, et määrata, millal nad peaksid peatuma. Selleks xja imilleks.

Lõputu rekursioon

Recursion also presents the same danger. It's not hard to write a self-referencing function that'll crash your browser.

?THIS RUNS FOREVER, BE WARNED? function run() { console.log('running'); run(); } run(); // running // running // ... 

on-see-rekursiivne

Without a stopping condition, run will forever call itself. You can fix that with an if statement.

✅ This does not run forever function run(x) { if (x === 3) return; console.log('running'); run(x + 1); } run(0); // running // running // running // x is 3 now, we're done. 

Base case

This is known as the base case–our recursive countDownFrom had one.

if (number === 0) { return; } 

It's the same idea as our loop's stopping logic. Whichever approach you pick, always remember that at some point it needs to be stopped.

kas-seda-peate-peatama

Summary

  • Recursion is when a function calls itself until someone stops it.
  • It can be used instead of a loop.
  • If no one stops it, it'll recurse forever and crash your program.
  • A base case is a condition that stops the recursion. Don't forget to add them!
  • Silmused kasutavad jälgimiseks ja loendamiseks täiendavaid olekumuutujaid, rekursioon aga ainult esitatud parameetreid.

kaovad-silmused

Täname lugemast

Sellise sisu saamiseks vaadake lehte //yazeedb.com. Ja palun andke mulle teada, mida soovite veel näha! Minu DM-id on Twitteris avatud.

Järgmise korrani!