अनुक्रमिक लाने और हल करने के 5 तरीके

तकनीकी साक्षात्कार में, सैद्धांतिक ज्ञान की जांच करने के अलावा, उम्मीदवार के व्यावहारिक ज्ञान के स्तर, कोड लिखने की उसकी क्षमता और तार्किक और एल्गोरिथम सोचने की क्षमता का आकलन करने के लिए कार्यों को निर्धारित करने के लिए प्रथागत है। अक्सर, इस सूची में एल्गोरिथम समस्याएं शामिल हैं। हर कोई उनके लिए आदी हो गया है और, तैयारी करते समय, सबसे पहले, वे उन्हें देखते हैं। सूची लंबी है, लेकिन मुख्य चीज जो सबसे अधिक बार पाई जाती है वह कुछ इस तरह दिखती है:

• कारख़ाने का
• फाइबोनैचि संख्या
• सरणी तत्वों की विशिष्टता
• पाठ के भीतर कोष्ठक के लिए जाँच
• (mergeSort, insertionSort, bubbleSort, quickSort)
• ( / / )

, 70 JavaScript, , , , ( , ).

, :

, , .

:

, :

:
fetch(url1) => fetch(url2, resultsUrl1) => fetch(url3, resultsUrl2)

-
compose(res2 => fetch(url3, res2), res1 => fetch(url2, res1), () => fetch(url1))

?

, ( ):

• async/await

, , ( reduce, ).

, ; , - ; ; .

, . . , , , .

, reduce , Array. :

• reduce

, fetch , :

function fakeFetch (url, params='-') {
    //           
    console.log(`fakeFetch to: ${url} with params: ${params}`);
    return new Promise(resolve => {
        setTimeout(() => resolve(`${url} is DONE`), 1000);
    })
};

( ):

const urls = ['url1', 'url2', 'url3'];

( 1), . then().then().then() await; await; await; .

, callback. :

fetchSeries(result => console.log(`result: ${result}`))

, . , , .

, , . , , , .

function generatorWay(callback) {
    function* generateSequence() {
        let results;
        for (let i = 0; i < urls.length; i++) {
            results = yield fakeFetch(urls[i], results);
        }
        return results;
    }
    function execute(generator, yieldValue) {
        let next = generator.next(yieldValue);
        if (!next.done) {  
            return next.value
                .then(result => execute(generator, result));
        } else {
            callback(next.value);
        }
    }
    execute(generateSequence())
}

:

• generateSequence yield' , .
• execute(generator), next, — , , , next.
• execute , callback.

, while:

async function asyncGeneratorWay(callback) {
    async function* generateSequence() {
        let results;
        for (let i = 0; i < urls.length; i++) {
            results = yield await fakeFetch(urls[i], results);
        }
        return results;
    }
    let generator = generateSequence();
    let result;
    while (!result || !result.done) {
        result = await generator.next(result && result.value);
    }
    callback(result.value);
}

( ).

for await of , 2.

Async/await

. , async/await. , async, .

async function asyncAwaitWay(callback) {
    const series = async () => {
        let results;
        for (let i = 0; i < urls.length; i++) {  
            results = await fakeFetch(urls[i], results);
        }
        return results;
    }
    const result = await series();
    callback(result);
}

fakeFetch await;

Recursion

, reduce ( ), recursion . . , :

function recursionWay(callback) {  
    const recursion = (arr = [], promise = Promise.resolve()) => {
        if (!arr.length) { 
            return promise;
        }
        const [url, ...restUrls] = arr;
        return promise
            .then(res => recursion(restUrls, fakeFetch(url, res)));
    }
    recursion(urls)
        .then(result => callback(result));
}

shift , . .

Promise.resolve(), -, , , .

Reduce

, , . , , .

function reduceWay(callback) {
    urls
        .reduce((accum, item) => {
            return accum
                .then(res => fakeFetch(item, res))
        }, Promise.resolve())
        .then(result => callback(result));
}

:

• fakeFetch then;
• , Promise.resolve(), -, , (Promise) , . :

function reduceWay(callback) {
    urls
        .reduce((accum, item) => {
            if (!accum) {
                return fakeFetch(item);
            }
            return accum
                .then(res => fakeFetch(item, res));
        })
        .then(result => callback(result));
}

2 .

. , :

"", , reduce. , ( ). , , :

const reduceWay = callback => urls.reduce(
    (acc, item) => acc.then(res => fakeFetch(item, res)),  
    Promise.resolve())
    .then(result => callback(result));  
}

, , , .

, — . async/await — , . reduce / .

, , … .

जेनरेटर

अतुल्यकालिक जेनरेटर

सरणी: कम करने पर पुनरावृति

प्रत्यावर्तन

Async / प्रतीक्षा करें

वादे

वादा श्रृंखला

टिप्पणी के बाद यूपीडी मैं एसिंक्स / वेट विधि के लिए कुछ समायोजन करता है। वास्तव में, एक विधि को छोटा कर सकता है और इसे अधिक दृश्यता दे सकता है for of:

async function asyncAwaitWay(callback) {
    let results;
    for (const url of urls) {  
        results = await fakeFetch(url, results);
        }
    callback(result);
}