Ha a portfóliójában van JavaScript, megnő annak esélye, hogy szoftverfejlesztői szerepet kapjon. Ennek ellenére nézzük meg a JavaScript-interjúk gyakran ismételt kérdéseit.
A JavaScript az egyik leggyakrabban használt nyelv a webfejlesztésben. Ma már szinte bármilyen típusú alkalmazás fejlesztésére használják.
Mielőtt belevágnánk az interjúkérdésekbe, nézzük meg a JavaScript elsajátításának előnyeit.
A JavaScript egy könnyű, értelmezett vagy éppen időben lefordított programozási nyelv. Ez a világháló egyik alapnyelve. Ismeri a www másik két alapnyelvét. Jobb, ha megkeresed őket, ha nem.
A JavaScriptet főként a web számára készítik. De ez most nem csak a webre vonatkozik. Az olyan környezetek segítségével, mint a Node, Deno stb., szinte bármilyen platformon futtathatjuk.
Nézzünk meg néhány előnyt.
Tartalomjegyzék
A JavaScript előnyei
Milyen adattípusok vannak a JavaScriptben?
Az adattípusok különböző típusú adatok tárolására szolgálnak. Az adattípusok programozási nyelvenként eltérőek lehetnek. A JavaScriptben 8 adattípusunk van. Lássuk őket egyenként.
- Szám
- Húr
- Boolean
- Meghatározatlan
- Nulla
- BigInt
- Szimbólum
- Tárgy
Az objektum kivételével minden adattípust primitív értéknek nevezünk. És megváltoztathatatlanok.
Melyek a JavaScript beépített metódusai?
A JavaScript beépített metódusai adattípusonként eltérőek. Ezeket a beépített metódusokat a megfelelő adattípus használatával érhetjük el. Lássunk néhány beépített módszert a különböző adattípusokhoz és adatstruktúrákhoz.
- to LowCase
- azzal kezdődik
- chartAt
Minden adattípushoz rengeteg beépített módszer létezik. Ellenőrizheti a hivatkozásokat a különböző adattípusok és adatstruktúrák összes beépített metódusához.
Hogyan készítsünk tömböt JavaScriptben?
A tömbök a JavaScript egyik alapvető adatstruktúrája. A tömbök bármilyen típusú adatot tartalmazhatnak, mivel a JavaScript dinamikus. Nézzük meg, hogyan hozhatunk létre tömböket JavaScriptben.
Tömböt készíthetünk szögletes zárójelek használatával[]. Egyszerű és gyors objektumok létrehozása
// Empty array const arr = []; // Array with some random values const randomArr = [1, "One", true]; console.log(arr, randomArr);
Tömböt készíthetünk az Array konstruktor segítségével. Az emberek ritkán használják a konstruktort tömbök létrehozására általános projektekben.
// Empty array const arr = new Array(); // Array with some random values const randomArr = new Array(1, "One", true); console.log(arr, randomArr);
A JavaScript tömbök változtathatók, azaz létrehozásuk után tetszés szerint módosíthatjuk őket.
Hogyan lehet objektumot létrehozni JavaScriptben?
A tömbön kívül az objektum egy másik alapvető adatstruktúra a JavaScriptben. Az objektumok tárolják a kulcs-érték párokat. A kulcsnak megváltoztathatatlan értéknek kell lennie, míg az érték bármi lehet. Nézzük meg, hogyan lehet objektumokat létrehozni JavaScriptben.
Létrehozhatunk objektumokat zárójelek {} használatával. Egyszerű és gyors objektumok létrehozása.
// Empty object
const object = {};
// Object with some random values
const randomObject = { 1: 2, one: "Two", true: false };
console.log(object, randomObject);
Objektumokat készíthetünk az Object konstruktor segítségével. Az emberek ritkán használják ezt az általános projektekben.
// Empty object const object = new Object(); // Object with some random values const randomObject = new Object(); randomObject[1] = 2; randomObject["one"] = "Two"; randomObject[true] = false; console.log(object, randomObject);
A JavaScript objektumok változtathatók, azaz a 2. példában látható módon a létrehozás után módosíthatjuk őket.
Hogyan lehet hibakeresni a JavaScript kódot?
A hibakeresési kód nem egyszerű. És ez különbözik programozási nyelvenként, projektenként stb.; lássuk a JavaScript hibakeresésére használt gyakori dolgokat.
1. Naplózás
A kódunkban több helyen is használhatjuk a console.log utasításokat a hiba azonosítására. A kód leállítja a következő kódsorok futtatását, ha hiba van az előző sorban.
A naplózás az egyik régi hibakeresési módszer, amely meglehetősen hatékony kis projekteknél. Ez egy általános hibakeresési technika bármely programozási nyelvhez.
2. Fejlesztői eszközök
A JavaScriptet leginkább webes alkalmazások fejlesztésére használják. Tehát szinte minden böngészőben vannak fejlesztői eszközök, amelyek segítenek a JavaScript-kód hibakeresésében.
Az egyik leggyakrabban használt hibakeresési módszer a töréspontok beállítása a fejlesztői eszközökben. A töréspontok leállítják a JavaScript végrehajtását, és minden információt megadnak a végrehajtásról pillanatnyilag.
Több töréspontot is beállíthatunk azon a helyen, ahol hibákat kapunk, és megnézhetjük, mi okozza azt. Ez a leghatékonyabb módja a JavaScript webalkalmazások hibakeresésének.
3. IDE-k
Az IDE-ket használhatjuk a JavaScript hibakeresésére. A VS Code támogatja a töréspontokkal történő hibakeresést. A hibakeresési funkció a használt IDE-től függően eltérő lehet. De a legtöbb IDE rendelkezik ezzel a funkcióval.
Hogyan lehet JavaScript kódot hozzáadni egy HTML fájlhoz?
A JavaScript HTML-fájlt a script tag segítségével adhatjuk hozzá. Az alábbi példát ellenőrizheti.
<!DOCTYPE html>
<html lang="en">
<head>
<title>etoppc.com</title>
</head>
<body>
<h1>etoppc.com</h1>
<script>
// JavaScript code goes here
console.log("This is JavaScript code");
</script>
</body>
</html>
Mik azok a sütik?
A cookie-k kulcs-érték párok, amelyek kis információk tárolására szolgálnak. Az információ bármi lehet. Beállíthatjuk a cookie-k lejárati idejét, amelyek a lejárati idejük után törlődnek. Ezeket széles körben használják a felhasználók információinak tárolására.
A cookie-k akkor sem törlődnek, ha frissítjük az oldalt, amíg nem töröljük őket, vagy le nem járnak. Bármely webalkalmazás/weboldal cookie-jait bármely böngészőben ellenőrizheti a fejlesztői eszközök megnyitásával.
Hogyan kell olvasni egy sütit?
A cookie-t JavaScriptben olvashatjuk a document.cookie segítségével. Visszaküldi az összes általunk létrehozott cookie-t.
console.log("All cookies", document.cookie);
Üres karakterláncot ad vissza, ha nincsenek cookie-k.
Hogyan lehet sütit létrehozni és törölni?
A cookie-kat úgy tudjuk létrehozni, hogy a kulcs-érték párt a document.cookie-ra állítjuk. Lássunk egy példát.
document.cookie = "one=One;";
A fenti szintaxisban az one cookie kulcs és az Egy az értéke. További attribútumokat is hozzáadhatunk a cookie-hoz, például domain, elérési út, lejárat stb.; mindegyiket pontosvesszővel (;) kell elválasztani. Az összes attribútum nem kötelező.
Lássunk egy példát az attribútumokkal.
document.cookie = "one=One;expires=Jan 31 2023;path=/;";
A fenti kódban hozzáadtunk egy lejárati dátumot és a cookie elérési útját. Ha a lejárati dátumot nem adják meg, a süti a munkamenet után törlődik. Az alapértelmezett elérési út a fájl elérési útja lesz. A lejárati dátum formátumának GMT-ben kell lennie.
Nézzük meg, hogyan lehet több cookie-t létrehozni.
document.cookie = "one=One;expires=Jan 31 2023;path=/;"; document.cookie = "two=Two;expires=Jan 31 2023;path=/;"; document.cookie = "three=Three;expires=Jan 31 2023;path=/;";
A cookie-k nem íródnak felül, ha a kulcs vagy az elérési út eltérő több cookie beállításakor. Ha a kulcs és az elérési út megegyezik, akkor felülírja az előző cookie-t. Tekintse meg az alábbi példát, amely felülírja az előzőleg beállított cookie-t.
document.cookie = "one=One;expires=Jan 31 2023;path=/;"; document.cookie = "one=Two;path=/;";
Eltávolítottuk a cookie-ból a lejárati dátumot, és megváltoztattuk az értéket.
Használja a lejárati dátumot egy jövőbeli dátumhoz, amikor teszteli a kódot, hogy megfelelően működjön. Ha a 2023. január 31-i dátumot a 2023. január 31-e után is megtartja, a cookie-k nem jönnek létre.
Láttuk, hogyan lehet sütiket létrehozni és frissíteni. Nézzük meg, hogyan lehet törölni a cookie-kat.
A cookie-k törlése egyszerű. Csak módosítsa a cookie lejárati dátumát bármely múltbeli dátumra. Ellenőrizze az alábbi példát.
// Creating cookies document.cookie = "one=One;expires=Jan 31 2023;path=/;"; document.cookie = "two=Two;expires=Jan 31 2023;path=/;"; document.cookie = "three=Three;expires=Jan 31 2023;path=/;"; // Deleting the last cookie document.cookie = "three=Three;expires=Jan 1 2023;path=/;";
Az utolsó cookie-t nem fogja megtalálni a cookie-kban, mivel az a kód utolsó sorában törlődik. Ennyi a min cookie-s oktatóanyag.
Mik a különböző JavaScript keretrendszerek?
Nagyon sok JavaScript-keretrendszer létezik. React, Vue, Angular stb. a felhasználói felület fejlesztéséhez. Express, Koa, Nest stb., szerveroldali fejlesztéshez. NextJS, Gatsby stb., statikus webhelygeneráláshoz. React Native, Ionic stb., mobilalkalmazások fejlesztéséhez. Itt említettünk néhány JavaScript-keretrendszert. További kereteket találhat, amelyek felfedezése sok időt vesz igénybe. Fedezze fel, amikor szüksége van rájuk.
Lezárások JavaScriptben
A lezárás egy függvény, amely a lexikális hatókörével és a szülőlexikai környezetével van összekapcsolva. Lezárásokkal elérhetjük a külső hatókör adatait. A lezárások a funkciók létrehozásakor jönnek létre.
function outer() {
const a = 1;
function inner() {
// We can access all the data from the outer function scope here
// The data will be available even if we execute this function outside the outer function
// as inners' closure formed while creating it
console.log("Accessing a inside inner", a);
}
return inner;
}
const innerFn = outer();
innerFn();
A lezárásokat széles körben használják JavaScript alkalmazásokban. Előfordulhat, hogy korábban is használta őket anélkül, hogy észrevette volna, hogy bezárások. Ennél sokkal többet megtudhatunk a lezárásokról. Győződjön meg arról, hogy teljesen megtanulta ezt a fogalmat.
Emelés JavaScriptben
Az emelés egy folyamat a JavaScriptben, ahol a változók, függvények és osztályok deklarációja a hatókör tetejére kerül a kód végrehajtása előtt.
// Accessing `name` before declaring console.log(name); // Declaring and initializing the `name` var name = "etoppc.com";
Ha a fenti kódot futtatja, nem fog semmilyen hibát látni. De a legtöbb nyelven megjelenik a hibaüzenet. A kimenet definiálatlan lesz, mivel a lifting csak a deklarációkat mozgatja a tetejére, és nem inicializálja a 3. sorig.
Módosítsa a var értéket let vagy const értékre az alábbiak szerint, és futtassa újra a kódot.
// Accessing `name` before declaring console.log(name); // Declaring and initializing the `name` const name = "etoppc.com";
Most egy hivatkozási hibaüzenetet fog kapni, amely szerint nem tudjuk elérni a változót inicializálása előtt.
ReferenceError: Cannot access 'name' before initialization
Tehát itt a let és a const bekerült az ES6-ba, amelyekhez nem lehet hozzáférni inicializálás előtt, ahogy a hiba is sugallja. Ennek az az oka, hogy a let vagy const paraméterrel deklarált változók az időbeli holt zónában (TDZ) lesznek egészen addig a sorig, amelyeket inicializálnak. A változókat nem tudjuk elérni a TDZ-ből.
Currying JavaScriptben
A currying egy olyan technika, amellyel a sok paraméterrel rendelkező függvényeket kevesebb paraméterré konvertálhatjuk több hívással. Segítségével egy hívható add(a, b, c, d) függvényt add(a)(b)(c)(d) hívhatóvá alakíthatunk. Lássunk egy példát, hogyan kell csinálni.
function getCurryCallback(callback) {
return function (a) {
return function (b) {
return function (c) {
return function (d) {
return callback(a, b, c, d);
};
};
};
};
}
function add(a, b, c, d) {
return a + b + c + d;
}
const curriedAdd = getCurryCallback(add);
// Calling the curriedAdd
console.log(curriedAdd(1)(2)(3)(4));
Általánosíthatjuk a getCurryCallback függvényt, amelyet különböző függvényekhez használunk, hogy currying hívhatóvá konvertáljuk. További részletekért tekintse meg a JavaScript Infot.
A dokumentum és az ablak közötti különbség
Az ablak a böngésző legfelső objektuma. Tartalmazza a böngészőablakkal kapcsolatos összes információt, például előzményeket, helyet, navigátort stb.; globálisan elérhető JavaScriptben. Importálás nélkül közvetlenül is használhatjuk a kódunkban. Az ablak objektum tulajdonságait és metódusait ablak nélkül érhetjük el.
A dokumentum az ablak objektum része. A weboldalra betöltött összes HTML dokumentum objektummá konvertálódik. A dokumentum objektum a speciális HTMLDocument elemre utal, amelynek eltérő tulajdonságai és módszerei lesznek, mint az összes HTML elemnek.
Az objektum ablaka a böngészőablakot, a dokumentum pedig az abban a böngészőablakban betöltött HTML-dokumentumot jelöli.
Különbség a kliens és a szerver oldal között
A kliens oldal az alkalmazást használó végfelhasználóra vonatkozik. A szerveroldal arra a webszerverre utal, amelyen az alkalmazás telepítve van.
A frontend terminológiában kliensoldalnak nevezhetjük böngészőt a felhasználók számítógépén, szerveroldalnak pedig felhőszolgáltatásokat.
Az innerHTML és az innerText közötti különbség
Mind az innerHTML, mind az innerText a HTML elemek tulajdonságai. Ezekkel a tulajdonságokkal módosíthatjuk egy HTML-elem tartalmát.
A HTML karakterláncot hozzárendelhetjük az innerHTML-hez egy olyan tulajdonsághoz, amely a normál HTML-hez hasonlóan jelenik meg. Ellenőrizze az alábbi példát.
const titleEl = document.getElementById("title");
titleEl.innerHTML = '<span style="color:orange;">etoppc.com</span>';
Adjon hozzá egy elemet az azonosító címmel a HTML-kódhoz, és adja hozzá a fenti szkriptet a JavaScript-fájlhoz. Futtassa a kódot, és nézze meg a kimenetet. Lesz etoppc.com narancssárga színben. És ha megvizsgálja az elemet, az a span címkén belül lesz. Tehát az innerHTML veszi a HTML karakterláncot, és normál HTML-ként jeleníti meg.
A másik oldalon lévő innerText egy normál karakterláncot vesz fel, és úgy jeleníti meg, ahogy van. Nem jelenít meg semmilyen HTML-t, mint az innerHTML. Módosítsa az innerHTML-t innerText-re a fenti kódban, és ellenőrizze a kimenetet.
const titleEl = document.getElementById("title");
titleEl.innerText="<span style="color:orange;">etoppc.com</span>";
Most látni fogja a pontos karakterláncot, amelyet a weboldalon adtunk meg.
A let és a var közötti különbség
A let és a var kulcsszavak változók létrehozására szolgálnak JavaScriptben. A let kulcsszót az ES6 vezeti be.
Az let egy blokk-hatókörű, a var pedig funkció-hatókörű.
{
let a = 2;
console.log("Inside block", a);
}
console.log("Outside block", a);
Futtassa a fenti kódot. Hibaüzenetet kap az utolsó sorban, mivel nem tudjuk elérni a let a kívül a blokkot, mert az blokk hatókörű. Most változtassa meg varra, és futtassa újra.
{
var a = 2;
console.log("Inside block", a);
}
console.log("Outside block", a);
Semmilyen hibát nem fog kapni, mivel a blokkon kívül is elérhetjük az a változót. Most cseréljük le a blokkot egy függvényre.
function sample() {
var a = 2;
console.log("Inside function", a);
}
sample();
console.log("Outside function", a);
Hivatkozási hibaüzenetet fog kapni, ha a fenti kódot futtatja, mivel a függvényen kívül nem tudjuk elérni a var a it-et, mert az függvény hatókörű.
A változókat újradeklarálhatjuk a var kulcsszó használatával, de nem tudjuk újra deklarálni a változókat a let kulcsszó használatával. Lássunk egy példát.
var a = "etoppc.com"; var a = "Chandan"; console.log(a);
let a = "etoppc.com"; let a = "Chandan"; console.log(a);
A kód első darabja nem ad hibát, és az a érték a legutóbb hozzárendelt értékre változik. A 2. kódrészlet hibát fog dobni, mivel nem tudjuk újra deklarálni a változókat a let segítségével.
Különbség a munkamenet-tárolás és a helyi tárhely között
A munkamenet-tárolás és a helyi tárhely információ tárolására szolgál a felhasználók számítógépein, amelyek internet nélkül is elérhetők. A kulcs-érték párokat mind a munkamenet-tárolóban, mind a helyi tárolóban tárolhatjuk. Mind a kulcs, mind az érték karakterláncokká konvertálódik, ha bármilyen más adattípust vagy adatstruktúrát ad meg.
A munkamenet tárhelye a munkamenet végén (a böngésző bezárásakor) törlődik. A helytárat addig nem ürítjük, amíg ki nem ürítjük.
A sessionStorage és a localStorage objektumokkal elérhetjük, frissíthetjük és törölhetjük a munkamenet-tárolót és a helytárat.
Mi az a NaN a JavaScriptben?
A NaN rövidítése Not-a-Number. Azt jelzi, hogy valami nem törvényes/érvényes szám a JavaScriptben. Vannak olyan esetek, amikor NaN-t kapunk kimenetként, például 0/0, undefined * 2, 1 + undefined, null * undefined stb.,
Mi az a lexikális hatókör?
A lexikális hatókör a változókhoz való hozzáférést jelenti a szülői hatókörből. Tegyük fel, hogy van egy függvényünk, amelynek két belső függvénye van. A legbelső függvény hozzáférhet két szülőfüggvényének hatókörváltozóihoz. Hasonlóképpen, a 2. szintű funkció elérheti a legkülső funkciótartományt. Nézzük meg egy példán.
function outermost() {
let a = 1;
console.log(a);
function middle() {
let b = 2;
// `a` are accessible here
console.log(a, b);
function innermost() {
let c = 3;
// both `a` and `b` are accessible here
console.log(a, b, c);
}
innermost();
}
middle();
}
outermost();
A JavaScript egy hatóköri láncot használ a változó megtalálásához, amikor valahol a kódban hozzáférünk. Először az aktuális hatókör változóját fogja ellenőrizni, majd a szülő hatókört a globális hatókörig.
Mit ad át érték és mit ad át referencia?
Az érték szerinti átadás és a hivatkozás szerinti átadás két módja annak, hogy az argumentumokat átadja egy függvénynek a JavaScriptben.
Pass by value: másolatot készít az eredeti adatokról és továbbadja a függvénynek. Tehát ha bármilyen változtatást végrehajtunk a függvényben, az nem befolyásolja az eredeti adatokat. Ellenőrizze az alábbi példát.
function sample(a) {
// changing the value of `a`
a = 5;
console.log("Inside function", a);
}
let a = 3;
sample(a);
console.log("Outside function", a);
Látni fogja, hogy az a eredeti értéke nem változik, pedig a függvényen belül megváltoztattuk.
Pass by reference: átadja az adatok hivatkozását a függvénynek. Tehát ha bármilyen változtatást végrehajtunk a függvényben, az az eredeti adatokat is módosítja.
function sample(arr) {
// adding a new value to the array
arr.push(3);
console.log("Inside function", arr);
}
let arr = [1, 2];
sample(arr);
console.log("Outside function", arr);
Látni fogja, hogy az arr eredeti értéke megváltozik, ha megváltoztatjuk a függvényen belül.
Megjegyzés: minden primitív adattípust érték, a nem primitív adattípust pedig hivatkozás adja át.
Mi az a memoizáció?
A memoization egy olyan technika, amely a kiszámított értékeket gyorsítótárban tárolja, és akkor használja fel, amikor újra szükségünk van rájuk anélkül, hogy újra kiszámolná őket. Felgyorsítja a kód végrehajtását, ha a számítás nagyon nehéz. Tárolási kompromisszum van, ami az időhöz képest nem nagy probléma.
const memo = {};
function add(a, b) {
const key = `${a}-${b}`;
// checking whether we computed the value already or not
if (memo[key]) {
console.log("Not computing again");
return memo[key];
}
// adding the newly computed value to cache
// here cache is a simple global object
memo[key] = a + b;
return memo[key];
}
console.log(add(1, 2));
console.log(add(2, 3));
console.log(add(1, 2));
Ez egy egyszerű példa, amely bemutatja az emlékezést. Itt két szám összeadása nem nehéz számítási feladat. Csak a demó kedvéért.
Mi a többi paraméter?
A többi paraméter a függvény összes többi paraméterének összegyűjtésére szolgál. Tegyük fel, hogy van egy függvényünk, amely legalább 2 argumentumot fogad el, és legfeljebb tetszőleges számú paramétert. Mivel nem áll rendelkezésünkre a maximális számú argumentum, az első 2 paramétert normál változókkal, az összes többit a rest paraméterrel gyűjthetjük össze a rest operátor segítségével.
function sample(a, b, ...rest) {
console.log("Rest parameter", rest);
}
sample(1, 2, 3, 4, 5);
A többi paraméter a fenti példa utolsó három argumentumának tömbje lesz. Ezzel tetszőleges számú paraméterünk lehet egy függvényhez.
Egy függvénynek csak egy nyugalmi paramétere lehet. A többi paraméter pedig az utolsó legyen a paraméterek sorrendjében.
Mi az objektumdestrukció?
Az objektumdestrukció segítségével hozzáférhet a változókhoz az objektumból, és hozzárendelheti azokat az objektumkulcsokkal azonos nevű változókhoz. Lássunk egy példát.
const object = { a: 1, b: 2, c: 3 };
// Object destructuring
const { a, b, c } = object;
// Now, a, b, c will be used as normal variables
console.log(a, b, c);
A destrukturált változók változóit ugyanabban a sorban az alábbiak szerint módosíthatjuk.
const object = { a: 1, b: 2, c: 3 };
// Changing the names of `a` and `b`
const { a: changedA, b: changedB, c } = object;
// Now, changedA, changedB, c will be used as normal variables
console.log(changedA, changedB, c);
Mi az a tömb destrukció?
A tömb destrukciója a változók tömbből való elérésére és változókhoz való hozzárendelésére szolgál. Lássunk egy példát.
const array = [1, 2, 3]; // Array destructuring // It's based on the index of the array const [a, b, c] = array; // Now, we can use a, b, c as normal variables console.log(a, b, c);
Mit jelent az eseményrögzítés és az események buborékolása?
Az eseményrögzítés és az események buborékolása az események terjesztésének két módja a HTML DOM-ban. Tegyük fel, hogy két HTML-elem van, egyik a másikban. És egy esemény történik a belső elemen. Most az eseményterjesztési mód határozza meg az események végrehajtásának sorrendjét.
Eseménybuborékolás: először az eseménykezelőt futtatja az elemen, majd az elemen, majd egészen a legfelső elemig. Ez az összes esemény alapértelmezett viselkedése.
Eseményrögzítés: meg kell adnunk abban az esetben, ha ezt a fajta eseményterjesztést kell használnunk. Az eseményfigyelő hozzáadásakor megadhatjuk. Az események a következő sorrendben fognak lefutni, ha engedélyeztük az eseményrögzítést.
Megállíthatjuk az esemény terjedését az event.stopPropogation metódus meghívásával az eseménykezelőben.
Mik az ígéretek a JavaScriptben?
A Promise the objektumot az aszinkron műveletekhez használják, amelyek a jövőben sikeres vagy sikertelen állapottal fejeződnek be.
Az ígéret a következő állapotok egyikében lehet.
Lássunk két példát a siker és a kudarc eseteire.
// Promise which will complete successfully
const successPromise = new Promise((resolve, reject) => {
setTimeout(() => {
resolve({ message: "Completed successfully" });
}, 300);
});
successPromise
.then((data) => {
console.log(data);
})
.catch((error) => {
console.log(error);
});
// Promise which will complete with failure state
const failurePromise = new Promise((resolve, reject) => {
setTimeout(() => {
reject(new Error("Failing the promise for testing"));
}, 300);
});
failurePromise
.then((data) => {
console.log(data);
})
.catch((error) => {
console.log(error);
});
Egynél több is lehet, majd szükség esetén láncolás. Az előzőleg visszaküldött adatok a következő, majd visszahívás során kerülnek elfogadásra.
Magyarázza el a JavaScript hatókörének különböző típusait
A JavaScriptben kétféle hatókör létezik. A globális és helyi hatókör.
Lehet, hogy hallott már a függvény- és blokkhatókörről is. Ezek a var és let, const helyi hatókörei.
Mik azok az önmeghívó funkciók?
Az önhívó függvények névtelen függvények, amelyek a létrehozás után azonnal végrehajtásra kerülnek. Lássunk néhány példát.
// Without any parameters
(function sayHello() {
console.log("Hello, World!");
})();
// With parameters
(function add(a, b) {
console.log("Sum", a + b);
})(1, 2);
Akár az érveket is átadhatjuk az önmeghívó függvényeknek, amint azt a példában láthatta.
Mik azok a nyíl függvények?
A nyíl függvény szintaktikai cukor a normál funkcióhoz, némi változtatással. Általános használati esetekben úgy viselkednek, mint a normál funkciók. A nyíl függvények jól jönnek, ha visszahívásra van szükségünk. Lássuk a szintaxisát.
// arrow functions will return by default if it doesn't have any brackets let add = (a, b) => a + b; console.log(add(1, 2));
Van némi különbség a nyílfunkciók és a normál funkciók között.
- A nyílfüggvényeknek nincs saját kötésük. A ez a kulcsszó a nyíl függvényen belül a szülő hatókörére utal.
- A nyílfüggvények nem használhatók konstruktor függvényként
Mik azok a visszahívások?
A visszahívás egy olyan függvény, amelyet egy másik függvénynek adnak át, amelyet a függvényen belül hívnak meg. A visszahívások használata gyakori dolog a JavaScriptben. Lássunk egy példát.
function sample(a, b, callback) {
const result = a + b;
callback(result);
}
function finished(result) {
console.log("Finished with", result);
}
sample(1, 2, finished);
A befejezett függvény visszahívásként kerül átadásra a mintának. A kész függvényt a rendszer meghívja az eredménnyel valamilyen művelet végrehajtása után. A visszahívások használatát többnyire aszinkron műveletekben fogja látni, például ígéretek, setTimeout stb.,
Melyek a különböző típusú hibák?
Nézzünk meg néhány hibát a JavaScriptben.
ReferenceError: ez a hiba akkor fordul elő, ha az általunk elért változó elérhető.
TypeError: A JavaScript ezt a hibát dobja ki, ha a hiba nem egyezik más típusú hibákkal. Ez akkor is előfordul, ha olyan műveletet próbálunk végrehajtani, amely nem kompatibilis az adatokkal.
SyntaxError: ez a hiba akkor fordul elő, ha a JavaScript szintaxisa nem megfelelő.
Vannak más típusú hibák is. De ezek a leggyakoribb hibatípusok a JavaScriptben.
Melyek a változók különböző hatókörei a JavaScriptben?
A JavaScriptben a változóknak két hatóköre van. A var kulcsszóval deklarált változók függvény hatókörrel, a let és const paraméterekkel deklarált változók pedig blokk hatókörrel rendelkeznek.
Tekintse meg a 17. kérdést a változók hatókörével kapcsolatos további részletekért.
Mik azok az escape karakterek a JavaScriptben?
A fordított perjel az escape karakter a JavaScriptben. Néhány speciális karakter kinyomtatására szolgál, amelyeket általában nem tudunk kinyomtatni. Tegyük fel, hogy aposztrófot (‘) akarunk nyomtatni egy karakterláncba, amit általában nem tehetünk meg, mivel a karakterlánc a második aposztrófra végződik. Ebben az esetben az escape karaktert használjuk, hogy elkerüljük a karakterlánc ezen a ponton történő befejezését.
const message="Hi, I"m etoppc.com'; console.log(message);
A fenti kimenetet escape karakter használata nélkül érhetjük el, ha a külső egyszeri aposztrófokat kettős aposztrófokra cseréljük. De ez csak egy példa az escape karakter használatára. Vannak más karakterek, amelyekhez feltétlenül szükségünk van az escape karakterre, például n, t, stb.,
Mi az a BOM és DOM?
Böngészőobjektum-modell (BOM): minden böngészőben megtalálható az aktuális böngészőablak BOM-ja. Ez tartalmazza a legfelső ablak objektumunkat, amely a böngészőablak manipulálására szolgál.
Document Object Model (DOM): a böngészők létrehozzák a DOM-ot, amikor a HTML betöltődik a fastruktúrába. A HTML elemeket a DOM API segítségével tudjuk manipulálni.
Mi az a képernyőobjektum?
A képernyőobjektum a globális ablakobjektum egyik tulajdonsága. Különböző tulajdonságait tartalmazza annak a képernyőnek, amelyen az aktuális böngészőablak megjelenik. Néhány tulajdonság a szélesség, magasság, tájolás, pixelDepth stb.,
Következtetés
A fenti kérdések mindegyikéhez lehetnek további kérdések. Tehát elő kell készítenie a fogalmakat a fenti kérdések köré.
Felfedezhet néhány gyakran ismételt Java interjúkérdést és választ is.
Jó tanulást 🙂