Anonüümsed funktsioonid | Noolefunktsioonid
Anonüümsed funktsioonid
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 ;
Kood:
// Anonüümse funktsiooni näide
var tervita = function() {
console.log("Tere maailm!");
};
// Anonüümse funktsiooni kutsumine
tervita()
Pilt:
Siin on näide anonüümsest funktsioonist argumentide kasutamisel, mis tagastab summa kahe arvu vahel
Kood:
var summa = function(a, b) {
return a + b;
};
var tulemus = summa(3, 5);
console.log(tulemus); // Väljund: 8
Pilt:
Anonüümseid funktsioone saab kasutada argumentidena teistele funktsioonidele, näiteks sündmuste käitlemiseks või ajaliste viivituste loomiseks.
Kood:
// Anonüümne funktsioon koos argumendiga
setTimeout(function() {
console.log("Tere pärastlõunast!");
}, 1000);
Pilt:
Anonüümseid funktsioone saab kasutada massiivi elementide kuvamiseks mitmel erineval viisil. Näiteks forEach meetodi kasutamine
Kood:
var array = [1, 2, 3, 4, 5];
array.forEach(function(element) {
console.log(element);
});
Pilt:
forEach meetod võib vastu võtta ka teisi parameetreid, näiteks indeksi või massiivi ennast:
Kood:
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);
});
Pilt:
Anonüümsed funktsioonid pakuvad paindlikkust ja lihtsust, eriti ühekorraliste ülesannete, sündmuspõhise ja asünkroonse programmeerimise puhul. Klassikalised funktsioonid annavad selgema struktuuri, korduvkasutatavuse ning võimaldavad keerukamaid operatsioone, sealhulgas rekursiooni ja objektorienteeritud programmeerimist. Nende valik sõltub ülesandest, mõnikord on efektiivne kasutada mõlemaid tüüpe.
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.
IIFE koosneb anonüümsest funktsioonist, mis on ümbritsetud sulgudega. See anonüümne funktsioon on koheselt väljakutsutud, tavaliselt lisades () paare selle järel.
IIFE-d eristatakse teistest anonüümsetest funktsioonidest selle poolest, et neid kutsutakse välja kohe pärast nende loomist, samal real, kus need on defineeritud. See eristab neid tavalistest anonüümsetest funktsioonidest, mis võivad olla defineeritud ilma kohest väljakutsumisteta.
Kood:
(function() {
var x = 10;
console.log(x); // Output: 10
})();
Pilt:
Noolefunktsioonid
Uue Javascripti versiooniga ES6 tutvustati uut lähenemist anonüümsete funktsioonide loomisel – noolefunktsioon (arrow function). See on anonüümse funktsiooni alaliik Javascriptis. Noolefunktsioonid on lihtsustatud süntaksiga funktsioonid, mis kasutavad nooleoperaatorit (=>) funktsioonikeha defineerimiseks.
Noolefunktsioonide eeliseks on lühem ja selgem süntaks ning automaatne sidumine väliskeskkonnaga (this-sidumine). Need võimaldavad kergemini ja loetavamalt kirjutada anonüümseid funktsioone.
Siin on näide noolefunktsioonist
Kood:
const noolFunktsioon= () => {
// funktsiooni keha
};
Pilt:
Ehk lihtne tervitus näeks välja järgmine
Kood:
const noolFunktsioon = () => {
console.log("Tere noolfunktsioon!")
};
noolFunktsioon();
Pilt:
Kui funktsiooni kehas on ainult üks avaldus, siis saame isegi loogelised sulud {} ära jätta.
Kood:
const noolFunktsioon = () => console.log("Tere noolfunktsioon!");
noolFunktsioon();
Pilt:
Ja argumentidega ja massiiviga funktsiooni näited
Kood:
//noolefunktsioon argumentidega
let tervita = (nimi) => {console.log(`Tere ${nimi}`)};
tervita("Juhan");
//noolefunktsioon lihtsustatud - KUI ARGUMENTE ON ÜKS, SIIS VÕIB KA NEED SULUD ÄRA JÄTTA
let tervita2 = nimi => console.log(`Tere ${nimi}`);
tervita2("Mari");
//kui kehas on rohkem ridu, siis sulud jäävad
let liitmine = (a, b) => {
let result = a + b;
return result;
};
console.log(liitmine(3,5));
//noolefunktsioon lihtsustatud argumentidega
let liitmine = (a, b) => a + b;
console.log(liitmine(3,5));
//noolefunktsioon ja massiviist elementide kuvamine
const array = [1, 2, 3, 4, 5];
array.forEach(element => console.log(element));
Pilt:
Eriti läheb huvitavamaks, kui lisada mitu lühendatud koodi kokku. Näiteks funktsioon, mis leiab kas arv on paaris või paaritu
Kood:
const number = 5;
const isEven = number => number % 2 === 0 ? "paaris" : "paaritu";
console.log(isEven(number)); // Väljund: paaritu
Pilt:
Ja sama näide massiivi korral
Kood:
const arvud = [1, 2, 3, 4, 5];
arvud.forEach(nr => {
const paaris = nr % 2 === 0 ? "paaris" : "paaritu";
console.log(`${nr} is ${paaris}`);
});
Pilt:
Noolefunktsioone ei saa kasutada kui:
Noolefunktsioonidel puudub oma this seos, seetõttu ei saa neid kasutada konstruktorfunktsioonides, objekti meetodites ega prototüübi meetodites, kui on vaja õiget viidet objektile. Nad pärivad this ümbritsevast kontekstist.
Tagasikutsumisfunktsioon (Callbacks)
Tagasikutsumisfunktsioon (callbacks) 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.
Mõtle sellele kui “helistamisele ja tagasihelistamisele”. Sa saad kedagi helistada ja paluda neil midagi teha, ning hiljem nad helistavad sulle tagasi, et anda teada, et ülesanne on täidetud. Tagasikutsumisfunktsioonid toimivad sarnaselt.
Tegelikult eespool näidetes me seda forEach puhul kasutasime, aga selguse huvides vaatame uuesti üle. Javascripti forEach meetod võtab vastu callback-funktsiooni argumendina ja seejärel kutsub seda funktsiooni iga massiivi elemendi jaoks.
Kood:
const arvud = [1, 2, 3, 4, 5];
arvud.forEach(nr => {
const paaris = nr % 2 === 0 ? "paaris" : "paaritu";
console.log(`${nr} is ${paaris}`);
});
Pilt:
Võime funktsiooni ka eraldi luua ja siis selle välja kutsuda.
Kood:
let nimed = ["Kati", "Marta", "Andres", "Jüri", "Liisa"];
const kasutaja = function(nimi) {
console.log(`<li>${nimi}</li>`);
};
nimed.forEach(kasutaja);
Pilt:
Ja veel parem, me saame selle panne kirja noolefunktsioonina
Kood:
let nimed = ["Kati", "Marta", "Andres", "Jüri", "Liisa"];
//pikalt
const kasutaja = nimi => console.log(`<li>${nimi}</li>`);
nimed.forEach(kasutaja);
//lühidalt
nimed.forEach(nimi => console.log(`<li>${nimi}</li>`));
Pilt:
Näide lihtsast AJAX API päringust koos callback-funktsiooniga, kasutades noolefunktsiooni
Kood:
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);
Pilt:
Ülesanne
1.Erinevad funktsioonid
Koosta kaks funktsiooni, mis väljastavad sinu nime (ilma ühegi argumendita). Kasuta klassikaslist ja noolefunktsioone.
Kood:
var nimi_klassika = function (){
console.log("Oleksandra Ryshniak");
};
nimi_klassika();
const nimi_nool = () => {
console.log("Oleksandra Ryshniak");
};
nimi_nool()
Pilt:
2. Argumendiga funktsioon
Kirjuta funktsioon nimega `kuupaevEesti`, mis kuvab konsoolile praeguse kuupäeva ja kuu eesti keeles. Argumendiks kuupäev kujul 19.07.25
Kood:
let month = ["jaanuar", "veebruar", "märts", "aprill", "mai", "juuni",
"juuli","august", "september", "oktoober", "november", "detsember"]
var kuupaevEesti = function (date){
const str = date.split(".");
const paev = Number(str[0]);
const kuupaev = parseInt(str[1]) - 1;
console.log(`${paev} ${month[kuupaev]}`);
}
kuupaevEesti('13.11.2025');
Pilt:
3. Teadmata hulk
Kirjuta funktsioon, mis võtab siseniks kasutajalt teadmata hulga täisarve ning tagastab nende koguarvu ning keskmise.
Kood:
var number = function(numbers) {
let koguarv = numbers.length;
let summa = 0;
for (let i = 0; i < numbers.length; i++) {
summa += numbers[i];
}
let keskmine = summa / koguarv;
console.log('Koguarv: ' + koguarv);
console.log('Keskmine: ' + keskmine);
}
number([10, 45, 78, 12]);
Pilt:
4. Salajane sõnum
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.
Kood:
const salajaneSonum = (string) => {
let tulemus = "";
const vokaalid = ["a","e","i","o","u","ü","õ","ö","ä",
"A","E","I","O","U","Ü","Õ","Ö","Ä"];
for (let märk of string) {
let onVokaal = false;
for (let v of vokaalid) {
if (märk === v) {
onVokaal = true;
break;
}
}
if (onVokaal) {
tulemus += "*";
} else {
tulemus += märk;
}
}
return tulemus;
};
console.log(salajaneSonum("Hello world!"));
Pilt:
5. Unikaalsed nimed
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"]
Kood:
const leiaUnikaalsedNimed = (nimed) => {
const tulem = [];
for (let nimi of nimed) {
let jubaOlemas = false;
for (let n of tulem) {
if (nimi === n) {
jubaOlemas = true;
break;
}
}
if (!jubaOlemas) {
tulem.push(nimi);
}
}
return tulem;
};
const nimid = ["Kati", "Mati", "Kati", "Mari", "Mati", "Jüri"]
console.log (leiaUnikaalsedNimed(nimid))
Pilt:
