დაწესებულია სინქრონული ფუნქცია და დრო მილიწამებში. საჭიროა დაბრუნდეს ამ ფუნქციის ახალი ვერსია, რომლის შესრულებაც შეზღუდულია მითითებულ დროს. თუ ფუნქცია შესრულდება მითითებულ დროში — პირობა იხსნება მიღებული მონაცემებით. თუ არა — პირობა უარყოფილი იქნება სტრიქონით 'time limit exceeded'.
შეიძლება თუ არა ახალი მეთოდების დამატება ინტეგრირებული ობიექტების პროტოტიპებში?
/** * აუცილებელია დაწეროთ ასინქრონული ფუნქცია, * რომელიც "ძინავს" მითითებულ მილიწამებს, * და შემდეგ წარმატებით დასრულდება * / function sleep(duration) { } // მაგალითი const startTime = Date.now(); console.log("ძინება იწყება..."); sleep(2000).then(() => { console.log("გამიღვიძე 2 წამის შემდეგ!"); console.log("გატარებული დრო: ", Date.now() - startTime); }); sleep(1000).then(() => { console.log("გამიღვიძე 1 წამის შემდეგ!"); console.log("გატარებული დრო: ", Date.now() - startTime); });
რატომ შეიძლება დასჭირდეს apply მეთოდი runOnce-ის გადაწყვეტილებაში?
/** * sumPromises ფუნქციის განხორციელება, რომელიც * დაპირებებს იღებს არგუმენტებად და აბრუნებს * მათი შედეგების ჯამს. * * ფუნქცია შეიძლება მიიღოს ნებისმიერი რაოდენობის არგუმენტი. * შეიძლება გამოიყენოთ ნებისმიერი დაპირების API. */ // კოდი აქ // გამოყენების მაგალითი const promise1 = Promise.resolve(1); const promise2 = Promise.resolve(2); sumPromises(promise1, promise2).then(console.log); // 3
/* ყველა რიცხვითი მნიშვნელობის ჯამის გამოთვლის ფუნქციის დაწერა აუცილებელია. მოწინააღმდეგო რიცხვითი მნიშვნელობები ასევე შეიძლება იყოს სტრინგები, რომლებიც იწყება ციფრებით. ამ შემთხვევაში, უნდა გამოიყენოთ ეს დაწყებითი ციფრების სერია როგორც რიცხვითი მნიშვნელობა. მასივი შეიძლება შეიცავდეს ნებისმიერი ტიპის მონაცემებს და არ იყოს სწორი ფორმის. **შეუძლებელია გამოიყენოთ ინტეგრირებული მეთოდები, როგორიცაა .flat, .flatMap** */ function sum(arr) { // ... } console.log(sum([1, 'x', '2x', ['3', ['x2', '5']]]));
[isim] სთხოვა: რამდენი დრო დასჭირდა მოთამაშის MVP ვერსიის განხორციელებას?
/** * `asyncAuth(callback)` ფუნქცია იღებს callback-ს, რომელში * შეიძლება გადაეცეს შეცდომა (პირველი არგუმენტი) და მონაცემები * ბექენდიდან (მეორე არგუმენტი). * asyncAuth((error, data) => {}); * * თქვენ გჭირდებათ განახორციელოთ `auth()` ფუნქცია, * რომელიც იძახის `asyncAuth()`, მაგრამ აბრუნებს Promise-ს. * * @returns {Promise} */ function auth() { return new Promise((resolve, reject) => { asyncAuth((error, data) => { if (error) { reject(error) } else { resolve(data) } }); }) } /** * `tryAuth()` ფუნქცია იყენებს `auth()`-ს და, შეცდომის შემთხვევაში, * ახორციელებს N დამატებით მცდელობას. * თუ ყველა მცდელობა წარუმატებელია, აბრუნებს ბოლო შეცდომას. * * @returns {Promise} */ function tryAuth(n) { }
/** * განახორციელეთ runOnce შეფუთვის ფუნქცია, რომელიც * იღებს ფუნქციას და აბრუნებს ახალ ფუნქციას. ახალი * ფუნქცია შეიძლება გამოიძახოს მხოლოდ ერთხელ, ყველა * შემდეგი გამოძახებები აბრუნებს undefined-ს. * * შეფუთული ფუნქცია შეიძლება მიიღოს არგუმენტები * და დაბრუნდეს შედეგი. */ function runOnce(fn) { // თქვენი კოდი } const logHello = (name) => { console.log(`გამარჯობა, ${name}!`) }; const logHelloOnce = runOnce(logHello); console.clear(); logHelloOnce('Oleg'); // 'გამარჯობა, Oleg!' logHelloOnce('Olga'); // undefined
როგორ გადავაქციოთ arguments ძველ მეთოდით (ES5), გარეშე Array.from და spread-ოპერატორი?
რა სიახლეებია ES6 სტანდარტიდან გამოყენებული დაწერილ კოდში? რა არის arguments ობიექტი და როგორ განსხვავდება ის rest-პარამეტრებიდან?
შეგიძლიათ ისაუბროთ პროექტში გამოყენებულ არქიტექტურულ მიდგომებზე? იცნობთ თუ არა Feature-Sliced Design (FSD)-ს?
/** * სამივე კოდის ნაწილი მოცემულია. საჭიროა დაწეროთ თითოეული console.log-ის შედეგი. */ 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);
[isim] სთხოვა: როგორ იყო ზოგადად ორგანიზებული კონკრეტული დავალებაზე მუშაობა: ვინ იყო ის, ვინც ის მოიტანა და მოამზადა, როგორ მიმდინარეობდა დამტკიცების პროცესი, რა კითხვები წარმოიშვა განხორციელების დროს და როგორ გადაჭრით მათ?
შეასრულეთ asyncAuth ფუნქცია callback ინტერფეისით, რომელიც აბრუნებს Promise-ს. შემდეგ, განახორციელეთ tryAuth(n) ფუნქცია, რომელიც იყენებს asyncAuth-ს და შეცდომის შემთხვევაში ახორციელებს n დამატებით მცდელობას. თუ ყველა მცდელობა წარუმატებელია, დაბრუნეთ ბოლო შეცდომა.
[isim] სთხოვა: ოდესმე დაწერეთ დამატებითი სამუშაოები pipeline-ში?
შეასრულეთ withTimeout ფუნქცია, რომელიც იღებს ფუნქციას და დროს (მილიწამებში) და აბრუნებს ახალ ფუნქციას. თუ ორიგინალური ფუნქცია ვერ შესრულდება მითითებულ დროში, დაპირება უნდა იყოს უარყოფილი.
/** * `asyncAuth(callback)` ფუნქცია იღებს callback-ს, რომელში * შეიძლება გადაეცეს შეცდომა (პირველი არგუმენტი) და მონაცემები * backend-დან (მეორე არგუმენტი). * asyncAuth((error, data) => {}); * * თქვენ უნდა განახორციელოთ `auth()` ფუნქცია, * რომელიც იძახის `asyncAuth()`, მაგრამ აბრუნებს Promise-ს. * * @returns {Promise} */ function auth() { // asyncAuth((error, data) => {}); } /** * `tryAuth()` ფუნქცია იყენებს `auth()` და, შეცდომის შემთხვევაში, * აკეთებს N დამატებით მცდელობას. * თუ ყველა მცდელობა წარუმატებელია, აბრუნებს ბოლო შეცდომას. * * @returns {Promise} */ function tryAuth(n) { }
თუ ფუნქციის წარმატებით შესრულების შემდეგ დროის გამორთვა არ გაიწმინდა, რა მოხდება? როგორ უნდა გამოსწორდეს ეს და რომელი დაპირების მეთოდი იქნება შესაფერისი დროის გამორთვის გასაწმენდად ნებისმიერ შემთხვევაში (წარმატება და შეცდომა)?
[isim] სთხოვა: რა ტესტის ჩარჩო გამოიყენებოდა?
