Adott egy szinkron függvény és egy időtartam milliszázadokban. Vissza kell adni ennek a függvénynek egy új változatát, amelynek végrehajtását a megadott idő korlátozza. Ha a függvény a megadott időn belül lefut, a promise megoldódik a kapott adatokkal. Ha nem, a promise elutasításra kerül a 'time limit exceeded' szöveggel.
Miért lehet szükség az apply módszerre a runOnce megoldásban?
/** * Szükséges írni egy aszinkron függvényt, * amely "alszik" a megadott millimásodpercig, * majd sikeresen befejeződik * / function sleep(duration) { } // Példa const startTime = Date.now(); console.log("alvás kezdete..."); sleep(2000).then(() => { console.log("Felébredtem 2 másodperc után!"); console.log("Eltelt idő: ", Date.now() - startTime); }); sleep(1000).then(() => { console.log("Felébredtem 1 másodperc után!"); console.log("Eltelt idő: ", Date.now() - startTime); });
Problémák vannak az beépített objektumok prototípusainak új módszerekkel való bővítésében?
/** * Valósítsa meg a sumPromises függvényt, amely * ígéreteket fogad argumentumként, és visszaadja * azok eredményeinek összegét. * * A függvény bármennyi argumentumot elfogadhat. * Bármilyen ígéret API-t használhat. */ // Kód itt // Használati példa const promise1 = Promise.resolve(1); const promise2 = Promise.resolve(2); sumPromises(promise1, promise2).then(console.log); // 3
/** * Valósítsa meg a runOnce csomagoló függvényt, amely * elfogad egy függvényt, és egy újat ad vissza. Az új * függvény csak egyszer hívható meg, minden * további hívás undefined-et ad vissza. * * A becsomagolt függvény argumentumokat fogadhat * és eredményt adhat vissza. */ function runOnce(fn) { // a kódod } const logHello = (name) => { console.log(`szia, ${name}!`) }; const logHelloOnce = runOnce(logHello); console.clear(); logHelloOnce('Oleg'); // 'szia, Oleg!' logHelloOnce('Olga'); // undefined
/* Szükséges írni egy függvényt, amely kiszámítja egy tömb összes numerikus értékének összegét. A érvényes numerikus értékek szintén stringek, amelyek számjegyekkel kezdődnek. Ebben az esetben ezt az első számjegyekből álló szekvenciát kell numerikus értékként használni. A tömb bármilyen adattípust tartalmazhat, és nem feltétlenül lapos. **Nem szabad beépített módszereket, például .flat, .flatMap használni** */ function sum(arr) { // ... } console.log(sum([1, 'x', '2x', ['3', ['x2', '5']]]));
[név] kérdezte: Mennyibe került a játékos MVP-verziójának megvalósítása?
/** * Az `asyncAuth(callback)` függvény egy callback-et fogad, amelybe * hibát (első argumentumként) és adatokat * a backendből (második argumentumként) lehet átadni. * asyncAuth((error, data) => {}); * * Implementálnod kell az `auth()` függvényt, * amely meghívja az `asyncAuth()`-ot, de Promise-t ad vissza. * * @returns {Promise} */ function auth() { return new Promise((resolve, reject) => { asyncAuth((error, data) => { if (error) { reject(error) } else { resolve(data) } }); }) } /** * A `tryAuth()` függvény az `auth()`-ot használja, és hibát esetén * N további próbálkozást tesz. * Ha mindegyik kudarcot vall, visszaadja az utolsó hibát. * * @returns {Promise} */ function tryAuth(n) { }
/** * Három kódrészlet van megadva. Meg kell írni minden console.log eredményét. */ var n = 1; function F(n) { n = 3; } F(n); console.log(n); var obj = { a: 1 }; function F1(o) { o.a = 5; } F1(obj); console.log(obj); var obj = { a: 1 }; function F2(o) { o = { hello: 1 }; } F2(obj); console.log(obj);
Milyen újdonságokat tartalmaz az ES6 szabvány a megírt kódban? Mi az az arguments objektum, és miben különbözik a rest-paraméterektől?
Hogyan alakítsuk át az arguments-t régi módon (ES5), Array.from és spread-operator nélkül?
El tudná mondani azokat az architekturális megközelítéseket, amelyeket a projektben alkalmazott? Ismeri a Feature-Sliced Design (FSD) módszert?
[név] kérdezte: Valaha írtál extra feladatokat a pipeline-ba saját magad?
[név] kérdezte: Valaha dolgoztál a szolgáltatások sebességmérőinek optimalizálásán?
[név] kérdezte: Általában hogyan szervezted a munkát egy adott feladaton: ki hozta és készítette el, hogyan zajlott az elfogadási folyamat, milyen kérdések merültek fel a megvalósítás során, és hogyan oldottad meg ezeket?
Mi történik, ha nem tisztítjuk meg a timeout-ot a funkció sikeres végrehajtása után? Hogyan lehet ezt kijavítani, és melyik ígéret módszer lenne alkalmas a timeout tisztítására minden esetben (siker és hiba)?
Valósítsa meg az asyncAuth függvényt visszahívási felülettel, amely Promise-t ad vissza. Ezután valósítsa meg a tryAuth(n) függvényt, amely az asyncAuth-t használja, és hibát esetén n további próbálkozást tesz. Ha minden próbálkozás kudarcot vall, visszaadja az utolsó hibát.
/** * Az `asyncAuth(callback)` függvény egy callback-et fogad, amelybe * hibát (első argumentumként) és adatokat * a backendből (második argumentumként) lehet átadni. * asyncAuth((error, data) => {}); * * Implementálnod kell az `auth()` függvényt, * amely meghívja az `asyncAuth()`-ot, de Promise-t ad vissza. * * @returns {Promise} */ function auth() { // asyncAuth((error, data) => {}); } /** * A `tryAuth()` függvény az `auth()`-ot használja, és hibát esetén * N további próbálkozást tesz. * Ha mindegyik sikertelen, visszaadja az utolsó hibát. * * @returns {Promise} */ function tryAuth(n) { }
Valósítsa meg a withTimeout függvényt, amely egy függvényt és egy időt (milliszekundum) fogad, és egy új függvényt ad vissza. Ha az eredeti függvény nem fut le a megadott időn belül, a promise-t el kell utasítani.
