Anonüümsed funktsioonid on nimetamata funktsioonid, mis luuakse otse koodis ning neid kasutatakse sageli kohapeal, kus neid vaja on. Selle asemel, et funktsioonile anda kindel nimi, luuakse anonüümne funktsioon otse muutujasse, argumendina või atribuudina. Anonüümseid funktsioone saab kasutada mitmel viisil, olenevalt vajadusest. NB! Lõppu lisatakse semikoolon ;

Näide 1: Anonüümne funktsioon muutujas

// Anonüümse funktsiooni näide
var tervita = function() {
    console.log("Tere maailm!");
};

// Anonüümse funktsiooni kutsumine
tervita();

Näide 2: Anonüümne funktsioon argumentidega

var summa = function(a, b) {
    return a + b;
};

var tulemus = summa(3, 5);
console.log(tulemus); // Väljund: 8

Näide 3: Anonüümne funktsioon funktsiooni argumendina

// Anonüümne funktsioon koos argumendiga
setTimeout(function() {
    console.log("Tere pärastlõunast!");
}, 1000);

Näide 4: Anonüümsed funktsioonid massiivi meetodites

var array = [1, 2, 3, 4, 5];

array.forEach(function(element) {
    console.log(element);
});

Näide 5: forEach koos lisaparameetritega

const array = [1, 2, 3, 4, 5];

array.forEach(function(element, index, array) {
    console.log("Element:", element);
    console.log("Index:", index);
    console.log("Array:", array);
});

Eelised:

Pakuvad paindlikkust ja lihtsust.
Sobivad väikeste, ühekordsete funktsioonide loomiseks.
Olulised sündmustepõhises ja asünkroonses programmeerimises.

Võrdlus klassikaliste funktsioonidega:

Klassikalised funktsioonid on struktureeritumad ja taaskasutatavad.
Sobivad keerukamateks operatsioonideks, nt rekursioon ja OOP.
Valik nende vahel sõltub olukorrast ja arendaja eelistustest ja sageli kasutatakse mõlemat koos parima tulemuse saavutamiseks.

IIFE (Immediately Invoked Function Expression)

IIFE (Immediately Invoked Function Expression) on anonüümse funktsiooni alaliik.
IIFE on nimetatud selle järgi, kuidas see kohe pärast loomist kohe välja kutsutakse.

Näide:

(function() {
  var x = 10;
  console.log(x); // Output: 10
})();

Noolefunktsioonid

Eelised:

Lühem ja selgem süntaks.
Automaatne sidumine väliskeskkonnaga (this-sidumine).
Lihtsam ja loetavam viis anonüümsete funktsioonide kirjutamiseks.

Põhinäide:

const noolFunktsioon = () => {
  // funktsiooni keha
};

Näide: Lihtne tervitus

const noolFunktsioon = () => {
  console.log("Tere noolfunktsioon!");
};

noolFunktsioon();

Lühendatud süntaks (üks rida):

const noolFunktsioon = () => console.log("Tere noolfunktsioon!");
noolFunktsioon();

Näited argumentidega:

// Noolefunktsioon argumentidega
let tervita = (nimi) => { console.log(`Tere ${nimi}`); };
tervita("Juhan");

// Kui on ainult üks argument, võib jätta sulud ära
let tervita2 = nimi => console.log(`Tere ${nimi}`);
tervita2("Mari");

Keha mitme reaga:

let liitmine = (a, b) => {
  let result = a + b;
  return result;
};
console.log(liitmine(3,5));

Lühendatud versioon:

let liitmine = (a, b) => a + b;
console.log(liitmine(3,5));

Näide: Noolefunktsioon ja massiiv

const array = [1, 2, 3, 4, 5];
array.forEach(element => console.log(element));

Tingimuslause noolefunktsioonis:

const number = 5;
const isEven = number => number % 2 === 0 ? "paaris" : "paaritu";

console.log(isEven(number)); // Väljund: paaritu

Näide massiiviga:

const arvud = [1, 2, 3, 4, 5];

arvud.forEach(nr => {
    const paaris = nr % 2 === 0 ? "paaris" : "paaritu";
    console.log(`${nr} is ${paaris}`);
});

Konstruktorifunktsioonides –
Noolefunktsioonidel puudub this sidumine, seega neid ei saa kasutada objektide loomiseks konstruktorifunktsioonide kaudu.

Meetoditena objektides –
Kui soovite luua meetodi, mis kasutab this viidet objekti enda kontekstile, siis noolefunktsioone ei sobi kasutada.

Prototüüpimeetoditena –
Noolefunktsioon ei päri õiget this sidumist ega viita õigesti objektile, kuhu see lisatakse.

**Tagasikutsumisfunktsioon (Callbacks)**

Tagasikutsumisfunktsioon (callback) on viis, kuidas JavaScriptis funktsioone teistele funktsioonidele edastada ja need hiljem tagasi kutsuda.

See võimaldab teatud sündmuste või tingimuste täitumisel teostada soovitud toiminguid.

Näide 1: Callback funktsioon forEach meetodis:

let nimed = ["Kati", "Marta", "Andres", "Jüri", "Liisa"];

nimed.forEach(function(nimi) {
  console.log(`<li>${nimi}</li>`);
});

Näide 2: Callback eraldi funktsioonina

let nimed = ["Kati", "Marta", "Andres", "Jüri", "Liisa"];

const kasutaja = function(nimi) {
  console.log(`<li>${nimi}</li>`);
};

nimed.forEach(kasutaja);

Näide 3: Callback noolefunktsioonina

let nimed = ["Kati", "Marta", "Andres", "Jüri", "Liisa"];

// Pikem variant
const kasutaja = nimi => console.log(`<li>${nimi}</li>`);
nimed.forEach(kasutaja);

// Lühem variant
nimed.forEach(nimi => console.log(`<li>${nimi}</li>`));

Näide 4: Callback asünkroonses koodis (AJAX päring)

const teostaAJAXPäring = (url, callback) => {
  setTimeout(() => {
    const vastus = "Vastus andmebaasist";
    callback(vastus);
  }, 2000);
};

const callbackFunktsioon = (vastus) => {
  console.log("Vastus saadud:", vastus);
};

teostaAJAXPäring("https://api.example.com/data", callbackFunktsioon);

Ulesanne:

Koosta kaks funktsiooni, mis väljastavad sinu nime (ilma ühegi argumendita). Kasuta klassikaslist ja noolefunktsioone.

function minuNimi() {
    console.log("Nikita");
}

const minuNimiArrow = () => console.log("Nikita");

minuNimi();
minuNimiArrow();

2. Kirjuta funktsioon nimega kuupaevEesti, mis kuvab konsoolile praeguse kuupäeva ja kuu eesti keeles. Argumendiks kuupäev kujul 19.07.25

function kuupaevEesti(kuupaev) {
    const kuud = [
        "jaanuar", "veebruar", "märts", "aprill", "mai", "juuni",
        "juuli", "august", "september", "oktoober", "november", "detsember"
    ];
    
    const osad = kuupaev.split(".");
    const aasta = osad[0];
    const kuu = kuud[parseInt(osad[1], 10) - 1];
    const paev = osad[2];
    
    console.log(`${aasta}.${kuu} 20${paev}`);
}
kuupaevEesti("19.07.25"); // Kuvab: 19 juuli 25

3. Kirjuta funktsioon, mis võtab siseniks kasutajalt teadmata hulga täisarve ning tagastab nende koguarvu ning keskmise.

function arvudeStatistika(...arvud) {
    let summa = 0;
    
    for (let i = 0; i < arvud.length; i++) {
        summa += arvud[i];
    }
    let keskmine = arvud.length > 0 ? summa / arvud.length : 0;
    return { summa, keskmine };
}
console.log(arvudeStatistika(2, 4, 6, 8, 10));

4. Kirjuta noolefunktsioon nimega salajaneSonum, mis võtab sisendiks sõnumi stringi ning tagastab selle sõnumi põhjal salajase versiooni. Salajase versiooni loomiseks asendatakse kõik täishäälikud (vokaalid) tärniga (*), jättes konsonandid muutumatuks.

const salajaneSonum = (sonum) => {
    let tulemus = "";
    for (let i = 0; i < sonum.length; i++) {
        let c = sonum[i].toLowerCase();
        if ("aeiouõäöü".includes(c)) {
            tulemus += "*";
        } else {
            tulemus += sonum[i];
        }
    }
    return tulemus;
};

console.log(salajaneSonum("Tere tulemast, Nikita Nikiforov TARpv24. Minsk kruto"));

5. Kirjuta noolefunktsioon nimega leiaUnikaalsedNimed, mis võtab sisendiks massiivi erinevatest nimedest ning tagastab uue massiivi, kus on ainult unikaalsed nimed esialgses järjekorras. See tähendab, et kui esineb mitu sama nime, siis tuleb need jätta ainult esinemise esialgsesse kohta ja eemaldada ülejäänud koopiad.
["Kati", "Mati", "Kati", "Mari", "Mati", "Jüri"]

const leiaUnikaalsedNimed = (nimed) => {
    let unikaalsed = [];
    for (let i = 0; i < nimed.length; i++) {
        let nimiOnUus = true;
        for (let j = 0; j < unikaalsed.length; j++) {
            if (nimed[i] == unikaalsed[j]) {
                nimiOnUus = false;
            }
        }
        if (nimiOnUus) {
            unikaalsed[unikaalsed.length] = nimed[i];
        }
    }
    return unikaalsed;
};

const nimed = ["Kati", "Mati", "Kati", "Mari", "Mati", "Jüri"];
console.log(leiaUnikaalsedNimed(nimed));