Weblabor

Ádám majd úgy is ki fog javítani, hogy ezeket hogyan lehetne magyarul írni: self defining function és memoization. Mindenesetre felmerült a probléma, hogy hogyan lehetne optimalizálni rekurzív függvényeket, úgy hogy egyfajta iterátorként is működhessenek. Ehhez írtam egy nagyszerű kis függvényt, ami a Fibonacci-sort számítja ki, de kicsit érdekesen. Ami meglepő lehet, hogy a függvény az első sorban felüldefiniálja és bővíti magát pár tulajdonsággal és metódussal. Például gyorstárazza a már eddig kiszámolt értékeket, mindezt egy hordozható formában.

Várom róla a véleményeket:

/**
 * Kiszámolja az n. Fibonacci-számot.
 * 
 * @param {Number} n
 *   Az a természetes szám, amelyik elemre a Fibonacci-sorban szükségünk van.
 * @return {Number}
 *   Az n. Fibonacci-szám.
 */
function fib(n) {
  /**
   * Felüldefiniáljuk a függvényünket, mely visszaadja az n. Fibonacci-számot.
   */
  fib = function (n) {
    if (fib.cache[n] === undefined) {
      fib.cache[n] = fib(n - 1) + fib(n - 2);
    }
    return fib.cache[n];
  }
  
  // Bővítjük saját tulajdonsággal és metódussal.
  fib.cache = [0, 1];

  /**
   * A következő nem gyorsítótárazott Fibonacci-számot számolja ki.
   * 
   * @return {Number}
   *   A következő még ki nem számított Fibonacci-szám.
   */
  fib.next = function () {
    return fib(fib.cache.length);
  }
  
  return fib(n);
}

(function(n) {
  // Lekérdezzük a 0. elemet.
  fib(0);
  
  while (n--) {
    // Meghívjuk a next metódust 10-szer.
    console.log(fib.next());
  }
  
  console.log('A 20. Fibonacci-szám:', fib(20));
}(10));

Kimenet:

1
2
3
5
8
13
21
34
55
89
A 20. Fibonacci szám: 6765