ਆਉ ਉਦਾਹਰਣਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ JavaScript ਵਿੱਚ Async/Await ਨੂੰ ਵੇਖੀਏ

ਲੇਖ ਦਾ ਲੇਖਕ JavaScript ਵਿੱਚ Async/Await ਦੀਆਂ ਉਦਾਹਰਣਾਂ ਦੀ ਜਾਂਚ ਕਰਦਾ ਹੈ। ਕੁੱਲ ਮਿਲਾ ਕੇ, ਅਸਿੰਕ੍ਰੋਨਸ ਕੋਡ ਲਿਖਣ ਦਾ ਇੱਕ ਸੁਵਿਧਾਜਨਕ ਤਰੀਕਾ ਹੈ ਅਸਿੰਕ/ਉਡੀਕ। ਇਸ ਵਿਸ਼ੇਸ਼ਤਾ ਦੇ ਪ੍ਰਗਟ ਹੋਣ ਤੋਂ ਪਹਿਲਾਂ, ਅਜਿਹਾ ਕੋਡ ਕਾਲਬੈਕ ਅਤੇ ਵਾਅਦਿਆਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਲਿਖਿਆ ਜਾਂਦਾ ਸੀ। ਮੂਲ ਲੇਖ ਦਾ ਲੇਖਕ ਵੱਖ-ਵੱਖ ਉਦਾਹਰਣਾਂ ਦਾ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰਕੇ Async/Await ਦੇ ਫਾਇਦਿਆਂ ਦਾ ਖੁਲਾਸਾ ਕਰਦਾ ਹੈ।

ਅਸੀਂ ਯਾਦ ਦਿਵਾਉਂਦੇ ਹਾਂ: "Habr" ਦੇ ਸਾਰੇ ਪਾਠਕਾਂ ਲਈ - "Habr" ਪ੍ਰਚਾਰ ਕੋਡ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਕਿਸੇ ਵੀ ਸਕਿੱਲਬਾਕਸ ਕੋਰਸ ਵਿੱਚ ਦਾਖਲਾ ਲੈਣ ਵੇਲੇ 10 ਰੂਬਲ ਦੀ ਛੋਟ।

ਸਕਿੱਲਬਾਕਸ ਸਿਫ਼ਾਰਿਸ਼ ਕਰਦਾ ਹੈ: ਵਿਦਿਅਕ ਔਨਲਾਈਨ ਕੋਰਸ "ਜਾਵਾ ਡਿਵੈਲਪਰ".

ਕਾਲਬੈਕ

ਕਾਲਬੈਕ ਇੱਕ ਫੰਕਸ਼ਨ ਹੈ ਜਿਸਦੀ ਕਾਲ ਅਣਮਿੱਥੇ ਸਮੇਂ ਲਈ ਦੇਰੀ ਹੁੰਦੀ ਹੈ। ਪਹਿਲਾਂ, ਕੋਡ ਦੇ ਉਹਨਾਂ ਖੇਤਰਾਂ ਵਿੱਚ ਕਾਲਬੈਕ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾਂਦੀ ਸੀ ਜਿੱਥੇ ਨਤੀਜਾ ਤੁਰੰਤ ਪ੍ਰਾਪਤ ਨਹੀਂ ਕੀਤਾ ਜਾ ਸਕਦਾ ਸੀ।

ਇੱਥੇ Node.js ਵਿੱਚ ਇੱਕ ਫਾਈਲ ਨੂੰ ਅਸਿੰਕਰੋਨਸ ਰੀਡਿੰਗ ਦੀ ਇੱਕ ਉਦਾਹਰਨ ਹੈ:

fs.readFile(__filename, 'utf-8', (err, data) => {
  if (err) {
    throw err;
  }
  console.log(data);
});

ਸਮੱਸਿਆਵਾਂ ਉਦੋਂ ਪੈਦਾ ਹੁੰਦੀਆਂ ਹਨ ਜਦੋਂ ਤੁਹਾਨੂੰ ਇੱਕੋ ਸਮੇਂ ਕਈ ਅਸਿੰਕ੍ਰੋਨਸ ਓਪਰੇਸ਼ਨ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਆਓ ਇਸ ਦ੍ਰਿਸ਼ ਦੀ ਕਲਪਨਾ ਕਰੀਏ: ਅਰਫਾਟ ਉਪਭੋਗਤਾ ਡੇਟਾਬੇਸ ਨੂੰ ਇੱਕ ਬੇਨਤੀ ਕੀਤੀ ਗਈ ਹੈ, ਤੁਹਾਨੂੰ ਇਸ ਦੇ profile_img_url ਖੇਤਰ ਨੂੰ ਪੜ੍ਹਨ ਅਤੇ someserver.com ਸਰਵਰ ਤੋਂ ਇੱਕ ਚਿੱਤਰ ਡਾਊਨਲੋਡ ਕਰਨ ਦੀ ਲੋੜ ਹੈ।
ਡਾਊਨਲੋਡ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਅਸੀਂ ਚਿੱਤਰ ਨੂੰ ਕਿਸੇ ਹੋਰ ਫਾਰਮੈਟ ਵਿੱਚ ਬਦਲਦੇ ਹਾਂ, ਉਦਾਹਰਨ ਲਈ PNG ਤੋਂ JPEG ਵਿੱਚ। ਜੇਕਰ ਪਰਿਵਰਤਨ ਸਫਲ ਸੀ, ਤਾਂ ਉਪਭੋਗਤਾ ਦੇ ਈਮੇਲ 'ਤੇ ਇੱਕ ਪੱਤਰ ਭੇਜਿਆ ਜਾਂਦਾ ਹੈ। ਅੱਗੇ, ਘਟਨਾ ਬਾਰੇ ਜਾਣਕਾਰੀ transformations.log ਫਾਈਲ ਵਿੱਚ ਦਰਜ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਮਿਤੀ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈ।

ਕੋਡ ਦੇ ਅੰਤਮ ਹਿੱਸੇ ਵਿੱਚ ਕਾਲਬੈਕ ਦੇ ਓਵਰਲੈਪ ਅਤੇ } ਦੀ ਵੱਡੀ ਸੰਖਿਆ ਵੱਲ ਧਿਆਨ ਦੇਣ ਯੋਗ ਹੈ। ਇਸਨੂੰ ਕਾਲਬੈਕ ਹੈਲ ਜਾਂ ਪਿਰਾਮਿਡ ਆਫ਼ ਡੂਮ ਕਿਹਾ ਜਾਂਦਾ ਹੈ।

ਇਸ ਵਿਧੀ ਦੇ ਨੁਕਸਾਨ ਸਪੱਸ਼ਟ ਹਨ:

• ਇਹ ਕੋਡ ਪੜ੍ਹਨਾ ਔਖਾ ਹੈ।
• ਗਲਤੀਆਂ ਨੂੰ ਸੰਭਾਲਣਾ ਵੀ ਮੁਸ਼ਕਲ ਹੈ, ਜੋ ਅਕਸਰ ਮਾੜੀ ਕੋਡ ਗੁਣਵੱਤਾ ਵੱਲ ਖੜਦਾ ਹੈ।

ਇਸ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ, ਵਾਅਦਿਆਂ ਨੂੰ JavaScript ਵਿੱਚ ਜੋੜਿਆ ਗਿਆ ਸੀ। ਉਹ ਤੁਹਾਨੂੰ ਕਾਲਬੈਕ ਦੇ ਡੂੰਘੇ ਆਲ੍ਹਣੇ ਨੂੰ ਸ਼ਬਦ ਨਾਲ ਬਦਲਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦੇ ਹਨ .ਫਿਰ.

ਵਾਅਦਿਆਂ ਦਾ ਸਕਾਰਾਤਮਕ ਪਹਿਲੂ ਇਹ ਹੈ ਕਿ ਉਹ ਕੋਡ ਨੂੰ ਖੱਬੇ ਤੋਂ ਸੱਜੇ ਦੀ ਬਜਾਏ ਉੱਪਰ ਤੋਂ ਹੇਠਾਂ ਤੱਕ ਬਹੁਤ ਵਧੀਆ ਪੜ੍ਹਨਯੋਗ ਬਣਾਉਂਦੇ ਹਨ। ਹਾਲਾਂਕਿ, ਵਾਅਦਿਆਂ ਦੀਆਂ ਸਮੱਸਿਆਵਾਂ ਵੀ ਹਨ:

• ਤੁਹਾਨੂੰ ਬਹੁਤ ਸਾਰਾ ਜੋੜਨ ਦੀ ਲੋੜ ਹੈ .ਫਿਰ.
• ਕੋਸ਼ਿਸ਼/ਕੈਚ ਦੀ ਬਜਾਏ, ਸਾਰੀਆਂ ਤਰੁੱਟੀਆਂ ਨੂੰ ਸੰਭਾਲਣ ਲਈ .catch ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।
• ਇੱਕ ਲੂਪ ਦੇ ਅੰਦਰ ਕਈ ਵਾਅਦਿਆਂ ਨਾਲ ਕੰਮ ਕਰਨਾ ਹਮੇਸ਼ਾਂ ਸੁਵਿਧਾਜਨਕ ਨਹੀਂ ਹੁੰਦਾ; ਕੁਝ ਮਾਮਲਿਆਂ ਵਿੱਚ, ਉਹ ਕੋਡ ਨੂੰ ਗੁੰਝਲਦਾਰ ਬਣਾਉਂਦੇ ਹਨ।

ਇੱਥੇ ਇੱਕ ਸਮੱਸਿਆ ਹੈ ਜੋ ਆਖਰੀ ਬਿੰਦੂ ਦਾ ਅਰਥ ਦਿਖਾਏਗੀ.

ਮੰਨ ਲਓ ਕਿ ਸਾਡੇ ਕੋਲ ਇੱਕ ਲੂਪ ਹੈ ਜੋ ਬੇਤਰਤੀਬ ਅੰਤਰਾਲਾਂ (0–n ਸਕਿੰਟਾਂ) 'ਤੇ 10 ਤੋਂ 0 ਤੱਕ ਸੰਖਿਆਵਾਂ ਦਾ ਕ੍ਰਮ ਪ੍ਰਿੰਟ ਕਰਦਾ ਹੈ। ਵਾਅਦਿਆਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਤੁਹਾਨੂੰ ਇਸ ਲੂਪ ਨੂੰ ਬਦਲਣ ਦੀ ਲੋੜ ਹੈ ਤਾਂ ਜੋ ਨੰਬਰ 0 ਤੋਂ 10 ਤੱਕ ਕ੍ਰਮ ਵਿੱਚ ਛਾਪੇ ਜਾਣ। ਇਸ ਲਈ, ਜੇਕਰ ਇੱਕ ਜ਼ੀਰੋ ਨੂੰ ਪ੍ਰਿੰਟ ਕਰਨ ਵਿੱਚ 6 ਸਕਿੰਟ ਅਤੇ ਇੱਕ ਨੂੰ ਪ੍ਰਿੰਟ ਕਰਨ ਲਈ 2 ਸਕਿੰਟ ਲੱਗਦੇ ਹਨ, ਤਾਂ ਜ਼ੀਰੋ ਨੂੰ ਪਹਿਲਾਂ ਛਾਪਣਾ ਚਾਹੀਦਾ ਹੈ, ਅਤੇ ਫਿਰ ਇੱਕ ਨੂੰ ਛਾਪਣ ਲਈ ਕਾਊਂਟਡਾਊਨ ਸ਼ੁਰੂ ਹੋ ਜਾਵੇਗਾ।

ਅਤੇ ਬੇਸ਼ੱਕ, ਅਸੀਂ ਇਸ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ Async/Await ਜਾਂ .sort ਦੀ ਵਰਤੋਂ ਨਹੀਂ ਕਰਦੇ ਹਾਂ। ਇੱਕ ਉਦਾਹਰਨ ਹੱਲ ਅੰਤ ਵਿੱਚ ਹੈ.

ਅਸਿੰਕ ਫੰਕਸ਼ਨ

ES2017 (ES8) ਵਿੱਚ ਅਸਿੰਕ ਫੰਕਸ਼ਨਾਂ ਦੇ ਜੋੜ ਨੇ ਵਾਅਦਿਆਂ ਨਾਲ ਕੰਮ ਕਰਨ ਦੇ ਕੰਮ ਨੂੰ ਸਰਲ ਬਣਾਇਆ ਹੈ। ਮੈਂ ਨੋਟ ਕਰਦਾ ਹਾਂ ਕਿ ਅਸਿੰਕ ਫੰਕਸ਼ਨ ਵਾਅਦਿਆਂ ਦੇ "ਸਿਖਰ 'ਤੇ" ਕੰਮ ਕਰਦੇ ਹਨ। ਇਹ ਫੰਕਸ਼ਨ ਗੁਣਾਤਮਕ ਤੌਰ 'ਤੇ ਵੱਖਰੀਆਂ ਧਾਰਨਾਵਾਂ ਨੂੰ ਨਹੀਂ ਦਰਸਾਉਂਦੇ ਹਨ। ਅਸਿੰਕ ਫੰਕਸ਼ਨਾਂ ਦਾ ਉਦੇਸ਼ ਕੋਡ ਦੇ ਵਿਕਲਪ ਵਜੋਂ ਹੈ ਜੋ ਵਾਅਦੇ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ।

Async/Await ਇੱਕ ਸਮਕਾਲੀ ਸ਼ੈਲੀ ਵਿੱਚ ਅਸਿੰਕ੍ਰੋਨਸ ਕੋਡ ਨਾਲ ਕੰਮ ਨੂੰ ਸੰਗਠਿਤ ਕਰਨਾ ਸੰਭਵ ਬਣਾਉਂਦਾ ਹੈ।

ਇਸ ਤਰ੍ਹਾਂ, ਵਾਅਦਿਆਂ ਨੂੰ ਜਾਣਨਾ Async/Await ਦੇ ਸਿਧਾਂਤਾਂ ਨੂੰ ਸਮਝਣਾ ਆਸਾਨ ਬਣਾਉਂਦਾ ਹੈ।

ਸੰਟੈਕਸ

ਆਮ ਤੌਰ 'ਤੇ, ਇਸ ਵਿੱਚ ਦੋ ਕੀਵਰਡ ਹੁੰਦੇ ਹਨ: async ਅਤੇ await. ਪਹਿਲਾ ਸ਼ਬਦ ਫੰਕਸ਼ਨ ਨੂੰ ਅਸਿੰਕ੍ਰੋਨਸ ਵਿੱਚ ਬਦਲਦਾ ਹੈ। ਅਜਿਹੇ ਫੰਕਸ਼ਨ ਉਡੀਕ ਦੀ ਵਰਤੋਂ ਦੀ ਆਗਿਆ ਦਿੰਦੇ ਹਨ. ਕਿਸੇ ਹੋਰ ਮਾਮਲੇ ਵਿੱਚ, ਇਸ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਨ ਨਾਲ ਇੱਕ ਗਲਤੀ ਪੈਦਾ ਹੋਵੇਗੀ।

// With function declaration
 
async function myFn() {
  // await ...
}
 
// With arrow function
 
const myFn = async () => {
  // await ...
}
 
function myFn() {
  // await fn(); (Syntax Error since no async)
}
 

Async ਫੰਕਸ਼ਨ ਘੋਸ਼ਣਾ ਦੇ ਬਿਲਕੁਲ ਸ਼ੁਰੂ ਵਿੱਚ, ਅਤੇ ਇੱਕ ਤੀਰ ਫੰਕਸ਼ਨ ਦੇ ਮਾਮਲੇ ਵਿੱਚ, “=” ਚਿੰਨ੍ਹ ਅਤੇ ਬਰੈਕਟ ਦੇ ਵਿਚਕਾਰ ਪਾਇਆ ਜਾਂਦਾ ਹੈ।

ਇਹਨਾਂ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਇੱਕ ਵਸਤੂ ਵਿੱਚ ਵਿਧੀਆਂ ਦੇ ਰੂਪ ਵਿੱਚ ਰੱਖਿਆ ਜਾ ਸਕਦਾ ਹੈ ਜਾਂ ਇੱਕ ਕਲਾਸ ਘੋਸ਼ਣਾ ਵਿੱਚ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ।

// As an object's method
 
const obj = {
  async getName() {
    return fetch('https://www.example.com');
  }
}
 
// In a class
 
class Obj {
  async getResource() {
    return fetch('https://www.example.com');
  }
}

NB! ਇਹ ਯਾਦ ਰੱਖਣ ਯੋਗ ਹੈ ਕਿ ਕਲਾਸ ਕੰਸਟਰਕਟਰ ਅਤੇ ਗੇਟਰ/ਸੈਟਰ ਅਸਿੰਕ੍ਰੋਨਸ ਨਹੀਂ ਹੋ ਸਕਦੇ ਹਨ।

ਅਰਥ ਵਿਗਿਆਨ ਅਤੇ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਨਿਯਮ

ਅਸਿੰਕ ਫੰਕਸ਼ਨ ਅਸਲ ਵਿੱਚ ਸਟੈਂਡਰਡ ਜੇਐਸ ਫੰਕਸ਼ਨਾਂ ਦੇ ਸਮਾਨ ਹਨ, ਪਰ ਅਪਵਾਦ ਹਨ।

ਇਸ ਤਰ੍ਹਾਂ, ਅਸਿੰਕ ਫੰਕਸ਼ਨ ਹਮੇਸ਼ਾ ਵਾਅਦੇ ਵਾਪਸ ਕਰਦੇ ਹਨ:

async function fn() {
  return 'hello';
}
fn().then(console.log)
// hello

ਖਾਸ ਤੌਰ 'ਤੇ, fn ਸਤਰ ਹੈਲੋ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਖੈਰ, ਕਿਉਂਕਿ ਇਹ ਇੱਕ ਅਸਿੰਕਰੋਨਸ ਫੰਕਸ਼ਨ ਹੈ, ਸਟ੍ਰਿੰਗ ਮੁੱਲ ਇੱਕ ਕੰਸਟਰਕਟਰ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਵਾਅਦੇ ਵਿੱਚ ਲਪੇਟਿਆ ਜਾਂਦਾ ਹੈ।

ਇੱਥੇ Async ਤੋਂ ਬਿਨਾਂ ਇੱਕ ਵਿਕਲਪਿਕ ਡਿਜ਼ਾਈਨ ਹੈ:

function fn() {
  return Promise.resolve('hello');
}
 
fn().then(console.log);
// hello

ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਵਾਅਦਾ "ਹੱਥੀਂ" ਵਾਪਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਇੱਕ ਅਸਿੰਕ੍ਰੋਨਸ ਫੰਕਸ਼ਨ ਹਮੇਸ਼ਾ ਇੱਕ ਨਵੇਂ ਵਾਅਦੇ ਵਿੱਚ ਲਪੇਟਿਆ ਜਾਂਦਾ ਹੈ।

ਜੇਕਰ ਵਾਪਸੀ ਦਾ ਮੁੱਲ ਇੱਕ ਮੁੱਢਲਾ ਹੈ, ਤਾਂ async ਫੰਕਸ਼ਨ ਇਸ ਨੂੰ ਇੱਕ ਵਾਅਦੇ ਵਿੱਚ ਲਪੇਟ ਕੇ ਮੁੱਲ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਜੇਕਰ ਵਾਪਸੀ ਮੁੱਲ ਇੱਕ ਵਾਅਦਾ ਵਸਤੂ ਹੈ, ਤਾਂ ਇਸਦਾ ਰੈਜ਼ੋਲੂਸ਼ਨ ਇੱਕ ਨਵੇਂ ਵਾਅਦੇ ਵਿੱਚ ਵਾਪਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

const p = Promise.resolve('hello')
p instanceof Promise;
// true
 
Promise.resolve(p) === p;
// true
 

ਪਰ ਕੀ ਹੁੰਦਾ ਹੈ ਜੇਕਰ ਕਿਸੇ ਅਸਿੰਕ੍ਰੋਨਸ ਫੰਕਸ਼ਨ ਦੇ ਅੰਦਰ ਕੋਈ ਗਲਤੀ ਹੁੰਦੀ ਹੈ?

async function foo() {
  throw Error('bar');
}
 
foo().catch(console.log);

ਜੇਕਰ ਇਸ 'ਤੇ ਕਾਰਵਾਈ ਨਹੀਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਤਾਂ foo() ਅਸਵੀਕਾਰ ਕਰਕੇ ਇੱਕ ਵਾਅਦਾ ਵਾਪਸ ਕਰੇਗਾ। ਇਸ ਸਥਿਤੀ ਵਿੱਚ, Promise.resolve ਦੀ ਬਜਾਏ ਇੱਕ ਗਲਤੀ ਵਾਲਾ Promise.reject ਵਾਪਸ ਕੀਤਾ ਜਾਵੇਗਾ।

Async ਫੰਕਸ਼ਨ ਹਮੇਸ਼ਾ ਇੱਕ ਵਾਅਦਾ ਆਉਟਪੁੱਟ ਕਰਦਾ ਹੈ, ਚਾਹੇ ਜੋ ਵੀ ਵਾਪਸ ਕੀਤਾ ਗਿਆ ਹੋਵੇ।

ਅਸਿੰਕ੍ਰੋਨਸ ਫੰਕਸ਼ਨ ਹਰ ਉਡੀਕ 'ਤੇ ਰੁਕ ਜਾਂਦੇ ਹਨ।

ਉਡੀਕ ਸਮੀਕਰਨਾਂ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕਰਦੀ ਹੈ। ਇਸ ਲਈ, ਜੇਕਰ ਸਮੀਕਰਨ ਇੱਕ ਵਾਅਦਾ ਹੈ, ਤਾਂ async ਫੰਕਸ਼ਨ ਨੂੰ ਮੁਅੱਤਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਜਦੋਂ ਤੱਕ ਵਾਅਦਾ ਪੂਰਾ ਨਹੀਂ ਹੁੰਦਾ। ਜੇਕਰ ਸਮੀਕਰਨ ਇੱਕ ਵਾਅਦਾ ਨਹੀਂ ਹੈ, ਤਾਂ ਇਸਨੂੰ Promise.resolve ਦੁਆਰਾ ਇੱਕ ਵਾਅਦੇ ਵਿੱਚ ਬਦਲਿਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਫਿਰ ਪੂਰਾ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

// utility function to cause delay
// and get random value
 
const delayAndGetRandom = (ms) => {
  return new Promise(resolve => setTimeout(
    () => {
      const val = Math.trunc(Math.random() * 100);
      resolve(val);
    }, ms
  ));
};
 
async function fn() {
  const a = await 9;
  const b = await delayAndGetRandom(1000);
  const c = await 5;
  await delayAndGetRandom(1000);
 
  return a + b * c;
}
 
// Execute fn
fn().then(console.log);

ਅਤੇ ਇੱਥੇ ਇੱਕ ਵਰਣਨ ਹੈ ਕਿ fn ਫੰਕਸ਼ਨ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ।

• ਇਸ ਨੂੰ ਕਾਲ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਪਹਿਲੀ ਲਾਈਨ const a = await 9 ਤੋਂ ਬਦਲ ਜਾਂਦੀ ਹੈ; const a = ਉਡੀਕ ਕਰੋ Promise.resolve(9);
• Await ਦੀ ਵਰਤੋਂ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਫੰਕਸ਼ਨ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਨੂੰ ਉਦੋਂ ਤੱਕ ਮੁਅੱਤਲ ਕਰ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ ਜਦੋਂ ਤੱਕ ਇੱਕ ਇਸਦਾ ਮੁੱਲ ਪ੍ਰਾਪਤ ਨਹੀਂ ਕਰਦਾ (ਮੌਜੂਦਾ ਸਥਿਤੀ ਵਿੱਚ ਇਹ 9 ਹੈ)।
• delayAndGetRandom(1000) fn ਫੰਕਸ਼ਨ ਦੇ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਨੂੰ ਉਦੋਂ ਤੱਕ ਰੋਕਦਾ ਹੈ ਜਦੋਂ ਤੱਕ ਇਹ ਆਪਣੇ ਆਪ ਪੂਰਾ ਨਹੀਂ ਹੋ ਜਾਂਦਾ (1 ਸਕਿੰਟ ਤੋਂ ਬਾਅਦ)। ਇਹ ਅਸਰਦਾਰ ਢੰਗ ਨਾਲ fn ਫੰਕਸ਼ਨ ਨੂੰ 1 ਸਕਿੰਟ ਲਈ ਰੋਕਦਾ ਹੈ।
• delayAndGetRandom(1000) ਰੈਜ਼ੋਲਿਊਸ਼ਨ ਰਾਹੀਂ ਇੱਕ ਬੇਤਰਤੀਬ ਮੁੱਲ ਵਾਪਸ ਕਰਦਾ ਹੈ, ਜੋ ਫਿਰ ਵੇਰੀਏਬਲ b ਨੂੰ ਨਿਰਧਾਰਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।
• ਖੈਰ, ਵੇਰੀਏਬਲ c ਦਾ ਕੇਸ ਵੇਰੀਏਬਲ a ਦੇ ਕੇਸ ਵਰਗਾ ਹੈ। ਉਸ ਤੋਂ ਬਾਅਦ, ਸਭ ਕੁਝ ਇੱਕ ਸਕਿੰਟ ਲਈ ਰੁਕ ਜਾਂਦਾ ਹੈ, ਪਰ ਹੁਣ delayAndGetRandom(1000) ਕੁਝ ਵੀ ਵਾਪਸ ਨਹੀਂ ਕਰਦਾ ਕਿਉਂਕਿ ਇਸਦੀ ਲੋੜ ਨਹੀਂ ਹੈ।
• ਨਤੀਜੇ ਵਜੋਂ, ਮੁੱਲਾਂ ਦੀ ਗਣਨਾ ਫਾਰਮੂਲਾ a + b * c ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਨਤੀਜਾ Promise.resolve ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਵਾਅਦੇ ਵਿੱਚ ਲਪੇਟਿਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਫੰਕਸ਼ਨ ਦੁਆਰਾ ਵਾਪਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

ਇਹ ਵਿਰਾਮ ES6 ਵਿੱਚ ਜਨਰੇਟਰਾਂ ਦੀ ਯਾਦ ਦਿਵਾਉਂਦਾ ਹੋ ਸਕਦਾ ਹੈ, ਪਰ ਇਸ ਵਿੱਚ ਕੁਝ ਹੈ ਤੁਹਾਡੇ ਕਾਰਨ.

ਸਮੱਸਿਆ ਦਾ ਹੱਲ

ਖੈਰ, ਆਓ ਹੁਣ ਉੱਪਰ ਦੱਸੀ ਸਮੱਸਿਆ ਦਾ ਹੱਲ ਵੇਖੀਏ.

FinishMyTask ਫੰਕਸ਼ਨ queryDatabase, sendEmail, logTaskInFile, ਅਤੇ ਹੋਰਾਂ ਵਰਗੇ ਕਾਰਜਾਂ ਦੇ ਨਤੀਜਿਆਂ ਦੀ ਉਡੀਕ ਕਰਨ ਲਈ ਉਡੀਕ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ। ਜੇ ਤੁਸੀਂ ਇਸ ਹੱਲ ਦੀ ਤੁਲਨਾ ਉਸ ਨਾਲ ਕਰੋ ਜਿੱਥੇ ਵਾਅਦੇ ਵਰਤੇ ਗਏ ਸਨ, ਤਾਂ ਸਮਾਨਤਾਵਾਂ ਸਪੱਸ਼ਟ ਹੋ ਜਾਣਗੀਆਂ। ਹਾਲਾਂਕਿ, Async/Await ਸੰਸਕਰਣ ਸਾਰੀਆਂ ਸਿੰਟੈਕਟਿਕ ਜਟਿਲਤਾਵਾਂ ਨੂੰ ਬਹੁਤ ਸਰਲ ਬਣਾਉਂਦਾ ਹੈ। ਇਸ ਕੇਸ ਵਿੱਚ, .then/.catch ਵਰਗੇ ਕਾਲਬੈਕ ਅਤੇ ਚੇਨਾਂ ਦੀ ਕੋਈ ਵੱਡੀ ਗਿਣਤੀ ਨਹੀਂ ਹੈ।

ਇੱਥੇ ਸੰਖਿਆਵਾਂ ਦੇ ਆਉਟਪੁੱਟ ਦੇ ਨਾਲ ਇੱਕ ਹੱਲ ਹੈ, ਦੋ ਵਿਕਲਪ ਹਨ.

const wait = (i, ms) => new Promise(resolve => setTimeout(() => resolve(i), ms));
 
// Implementation One (Using for-loop)
const printNumbers = () => new Promise((resolve) => {
  let pr = Promise.resolve(0);
  for (let i = 1; i <= 10; i += 1) {
    pr = pr.then((val) => {
      console.log(val);
      return wait(i, Math.random() * 1000);
    });
  }
  resolve(pr);
});
 
// Implementation Two (Using Recursion)
 
const printNumbersRecursive = () => {
  return Promise.resolve(0).then(function processNextPromise(i) {
 
    if (i === 10) {
      return undefined;
    }
 
    return wait(i, Math.random() * 1000).then((val) => {
      console.log(val);
      return processNextPromise(i + 1);
    });
  });
};

ਅਤੇ ਇੱਥੇ async ਫੰਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਹੱਲ ਹੈ।

async function printNumbersUsingAsync() {
  for (let i = 0; i < 10; i++) {
    await wait(i, Math.random() * 1000);
    console.log(i);
  }
}

ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਤਰੁੱਟੀ

ਅਣਹੋਂਦ ਦੀਆਂ ਗਲਤੀਆਂ ਨੂੰ ਰੱਦ ਕੀਤੇ ਵਾਅਦੇ ਵਿੱਚ ਲਪੇਟਿਆ ਜਾਂਦਾ ਹੈ। ਹਾਲਾਂਕਿ, ਅਸਿੰਕ ਫੰਕਸ਼ਨ ਸਮਕਾਲੀ ਤਰੁੱਟੀਆਂ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਕੋਸ਼ਿਸ਼/ਕੈਚ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹਨ।

async function canRejectOrReturn() {
  // wait one second
  await new Promise(res => setTimeout(res, 1000));
 
// Reject with ~50% probability
  if (Math.random() > 0.5) {
    throw new Error('Sorry, number too big.')
  }
 
return 'perfect number';
}

canRejectOrReturn() ਇੱਕ ਅਸਿੰਕਰੋਨਸ ਫੰਕਸ਼ਨ ਹੈ ਜੋ ਜਾਂ ਤਾਂ ਸਫਲ ਹੁੰਦਾ ਹੈ ("ਸੰਪੂਰਨ ਸੰਖਿਆ") ਜਾਂ ਇੱਕ ਗਲਤੀ ਨਾਲ ਅਸਫਲ ਹੁੰਦਾ ਹੈ ("ਮਾਫ਼ ਕਰਨਾ, ਨੰਬਰ ਬਹੁਤ ਵੱਡਾ")।

async function foo() {
  try {
    await canRejectOrReturn();
  } catch (e) {
    return 'error caught';
  }
}

ਕਿਉਂਕਿ ਉਪਰੋਕਤ ਉਦਾਹਰਨ canRejectOrReturn ਨੂੰ ਚਲਾਉਣ ਦੀ ਉਮੀਦ ਕਰਦੀ ਹੈ, ਇਸਦੀ ਆਪਣੀ ਅਸਫਲਤਾ ਦੇ ਨਤੀਜੇ ਵਜੋਂ ਕੈਚ ਬਲਾਕ ਨੂੰ ਲਾਗੂ ਕੀਤਾ ਜਾਵੇਗਾ। ਨਤੀਜੇ ਵਜੋਂ, ਫੰਕਸ਼ਨ foo ਜਾਂ ਤਾਂ ਪਰਿਭਾਸ਼ਿਤ (ਜਦੋਂ ਕੋਸ਼ਿਸ਼ ਬਲਾਕ ਵਿੱਚ ਕੁਝ ਨਹੀਂ ਵਾਪਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ) ਜਾਂ ਇੱਕ ਗਲਤੀ ਫੜੇ ਜਾਣ ਨਾਲ ਖਤਮ ਹੋ ਜਾਵੇਗਾ। ਨਤੀਜੇ ਵਜੋਂ, ਇਹ ਫੰਕਸ਼ਨ ਫੇਲ ਨਹੀਂ ਹੋਵੇਗਾ ਕਿਉਂਕਿ ਕੋਸ਼ਿਸ਼/ਕੈਚ ਫੰਕਸ਼ਨ foo ਨੂੰ ਆਪਣੇ ਆਪ ਹੈਂਡਲ ਕਰੇਗਾ।

ਇੱਥੇ ਇੱਕ ਹੋਰ ਉਦਾਹਰਨ ਹੈ:

async function foo() {
  try {
    return canRejectOrReturn();
  } catch (e) {
    return 'error caught';
  }
}

ਇਹ ਇਸ ਤੱਥ ਵੱਲ ਧਿਆਨ ਦੇਣ ਯੋਗ ਹੈ ਕਿ ਉਦਾਹਰਣ ਵਿੱਚ, canRejectOrReturn ਨੂੰ foo ਤੋਂ ਵਾਪਸ ਕੀਤਾ ਗਿਆ ਹੈ। ਇਸ ਮਾਮਲੇ ਵਿੱਚ Foo ਜਾਂ ਤਾਂ ਸੰਪੂਰਨ ਸੰਖਿਆ ਨਾਲ ਸਮਾਪਤ ਹੁੰਦਾ ਹੈ ਜਾਂ ਇੱਕ ਤਰੁੱਟੀ ਵਾਪਸ ਕਰਦਾ ਹੈ ("ਮਾਫ਼ ਕਰਨਾ, ਨੰਬਰ ਬਹੁਤ ਵੱਡਾ")। ਕੈਚ ਬਲਾਕ ਨੂੰ ਕਦੇ ਵੀ ਲਾਗੂ ਨਹੀਂ ਕੀਤਾ ਜਾਵੇਗਾ।

ਸਮੱਸਿਆ ਇਹ ਹੈ ਕਿ foo canRejectOrReturn ਤੋਂ ਪਾਸ ਕੀਤੇ ਵਾਅਦੇ ਨੂੰ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਇਸ ਲਈ foo ਦਾ ਹੱਲ canRejectOrReturn ਦਾ ਹੱਲ ਬਣ ਜਾਂਦਾ ਹੈ। ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਕੋਡ ਵਿੱਚ ਸਿਰਫ ਦੋ ਲਾਈਨਾਂ ਹੋਣਗੀਆਂ:

try {
    const promise = canRejectOrReturn();
    return promise;
}

ਜੇਕਰ ਤੁਸੀਂ ਉਡੀਕ ਅਤੇ ਵਾਪਸੀ ਦੀ ਵਰਤੋਂ ਇਕੱਠੇ ਕਰਦੇ ਹੋ ਤਾਂ ਇੱਥੇ ਕੀ ਹੁੰਦਾ ਹੈ:

async function foo() {
  try {
    return await canRejectOrReturn();
  } catch (e) {
    return 'error caught';
  }
}

ਉਪਰੋਕਤ ਕੋਡ ਵਿੱਚ, foo ਇੱਕ ਸੰਪੂਰਨ ਸੰਖਿਆ ਅਤੇ ਇੱਕ ਗਲਤੀ ਫੜੇ ਜਾਣ ਦੇ ਨਾਲ ਸਫਲਤਾਪੂਰਵਕ ਬਾਹਰ ਆ ਜਾਵੇਗਾ। ਇੱਥੇ ਕੋਈ ਇਨਕਾਰ ਨਹੀਂ ਹੋਵੇਗਾ। ਪਰ foo canRejectOrReturn ਨਾਲ ਵਾਪਸ ਆਵੇਗਾ, ਨਾ ਕਿ undefined ਨਾਲ। ਆਉ ਵਾਪਸੀ ਦੀ ਉਡੀਕ canRejectOrReturn() ਲਾਈਨ ਨੂੰ ਹਟਾ ਕੇ ਇਹ ਯਕੀਨੀ ਕਰੀਏ:

try {
    const value = await canRejectOrReturn();
    return value;
}
// …

ਆਮ ਗਲਤੀਆਂ ਅਤੇ ਕਮੀਆਂ

ਕੁਝ ਮਾਮਲਿਆਂ ਵਿੱਚ, Async/Await ਦੀ ਵਰਤੋਂ ਕਰਨ ਨਾਲ ਗਲਤੀਆਂ ਹੋ ਸਕਦੀਆਂ ਹਨ।

ਇੰਤਜ਼ਾਰ ਭੁੱਲ ਗਏ

ਇਹ ਅਕਸਰ ਵਾਪਰਦਾ ਹੈ - ਉਡੀਕ ਕੀਵਰਡ ਵਾਅਦੇ ਤੋਂ ਪਹਿਲਾਂ ਭੁੱਲ ਜਾਂਦਾ ਹੈ:

async function foo() {
  try {
    canRejectOrReturn();
  } catch (e) {
    return 'caught';
  }
}

ਜਿਵੇਂ ਕਿ ਤੁਸੀਂ ਵੇਖ ਸਕਦੇ ਹੋ, ਕੋਡ ਵਿੱਚ ਕੋਈ ਉਡੀਕ ਜਾਂ ਵਾਪਸੀ ਨਹੀਂ ਹੈ। ਇਸਲਈ foo ਹਮੇਸ਼ਾ ਬਿਨਾਂ 1 ਸਕਿੰਟ ਦੇ ਦੇਰੀ ਦੇ ਨਾਲ ਪਰਿਭਾਸ਼ਿਤ ਨਾਲ ਬਾਹਰ ਨਿਕਲਦਾ ਹੈ। ਪਰ ਵਾਅਦਾ ਪੂਰਾ ਕੀਤਾ ਜਾਵੇਗਾ। ਜੇਕਰ ਇਹ ਕੋਈ ਗਲਤੀ ਜਾਂ ਅਸਵੀਕਾਰ ਕਰਦਾ ਹੈ, ਤਾਂ UnhandledPromiseRejectionWarning ਨੂੰ ਬੁਲਾਇਆ ਜਾਵੇਗਾ।

ਕਾਲਬੈਕਸ ਵਿੱਚ ਅਸਿੰਕ ਫੰਕਸ਼ਨ

Async ਫੰਕਸ਼ਨ ਅਕਸਰ .map ਜਾਂ .filter ਵਿੱਚ ਕਾਲਬੈਕ ਵਜੋਂ ਵਰਤੇ ਜਾਂਦੇ ਹਨ। ਇੱਕ ਉਦਾਹਰਨ fetchPublicReposCount(username) ਫੰਕਸ਼ਨ ਹੈ, ਜੋ GitHub 'ਤੇ ਖੁੱਲ੍ਹੀਆਂ ਰਿਪੋਜ਼ਟਰੀਆਂ ਦੀ ਸੰਖਿਆ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਮੰਨ ਲਓ ਕਿ ਇੱਥੇ ਤਿੰਨ ਉਪਭੋਗਤਾ ਹਨ ਜਿਨ੍ਹਾਂ ਦੇ ਮੈਟ੍ਰਿਕਸ ਦੀ ਸਾਨੂੰ ਲੋੜ ਹੈ। ਇੱਥੇ ਇਸ ਕੰਮ ਲਈ ਕੋਡ ਹੈ:

const url = 'https://api.github.com/users';
 
// Utility fn to fetch repo counts
const fetchPublicReposCount = async (username) => {
  const response = await fetch(`${url}/${username}`);
  const json = await response.json();
  return json['public_repos'];
}

ਸਾਨੂੰ ArfatSalman, octocat, norvig ਖਾਤਿਆਂ ਦੀ ਲੋੜ ਹੈ। ਇਸ ਕੇਸ ਵਿੱਚ ਅਸੀਂ ਕਰਦੇ ਹਾਂ:

const users = [
  'ArfatSalman',
  'octocat',
  'norvig'
];
 
const counts = users.map(async username => {
  const count = await fetchPublicReposCount(username);
  return count;
});

ਇਹ .map ਕਾਲਬੈਕ ਵਿੱਚ ਉਡੀਕ ਵੱਲ ਧਿਆਨ ਦੇਣ ਯੋਗ ਹੈ। ਇੱਥੇ ਗਿਣਤੀ ਵਾਅਦਿਆਂ ਦੀ ਇੱਕ ਲੜੀ ਹੈ, ਅਤੇ .map ਹਰੇਕ ਨਿਸ਼ਚਿਤ ਉਪਭੋਗਤਾ ਲਈ ਇੱਕ ਅਗਿਆਤ ਕਾਲਬੈਕ ਹੈ।

ਉਡੀਕ ਦੀ ਬਹੁਤ ਜ਼ਿਆਦਾ ਲਗਾਤਾਰ ਵਰਤੋਂ

ਆਓ ਇਸ ਕੋਡ ਨੂੰ ਇੱਕ ਉਦਾਹਰਨ ਵਜੋਂ ਲੈਂਦੇ ਹਾਂ:

async function fetchAllCounts(users) {
  const counts = [];
  for (let i = 0; i < users.length; i++) {
    const username = users[i];
    const count = await fetchPublicReposCount(username);
    counts.push(count);
  }
  return counts;
}

ਇੱਥੇ ਰੈਪੋ ਨੰਬਰ ਕਾਉਂਟ ਵੇਰੀਏਬਲ ਵਿੱਚ ਰੱਖਿਆ ਗਿਆ ਹੈ, ਫਿਰ ਇਸ ਨੰਬਰ ਨੂੰ ਕਾਉਂਟ ਐਰੇ ਵਿੱਚ ਜੋੜਿਆ ਜਾਂਦਾ ਹੈ। ਕੋਡ ਦੇ ਨਾਲ ਸਮੱਸਿਆ ਇਹ ਹੈ ਕਿ ਜਦੋਂ ਤੱਕ ਸਰਵਰ ਤੋਂ ਪਹਿਲੇ ਉਪਭੋਗਤਾ ਦਾ ਡੇਟਾ ਨਹੀਂ ਆਉਂਦਾ, ਉਸ ਤੋਂ ਬਾਅਦ ਦੇ ਸਾਰੇ ਉਪਭੋਗਤਾ ਸਟੈਂਡਬਾਏ ਮੋਡ ਵਿੱਚ ਹੋਣਗੇ. ਇਸ ਤਰ੍ਹਾਂ, ਇੱਕ ਸਮੇਂ ਵਿੱਚ ਸਿਰਫ਼ ਇੱਕ ਉਪਭੋਗਤਾ 'ਤੇ ਕਾਰਵਾਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।

ਜੇ, ਉਦਾਹਰਨ ਲਈ, ਇੱਕ ਉਪਭੋਗਤਾ ਨੂੰ ਪ੍ਰਕਿਰਿਆ ਕਰਨ ਵਿੱਚ ਲਗਭਗ 300 ms ਲੱਗਦੇ ਹਨ, ਤਾਂ ਸਾਰੇ ਉਪਭੋਗਤਾਵਾਂ ਲਈ ਇਹ ਪਹਿਲਾਂ ਹੀ ਇੱਕ ਸਕਿੰਟ ਹੈ; ਰੇਖਿਕ ਤੌਰ 'ਤੇ ਬਿਤਾਇਆ ਗਿਆ ਸਮਾਂ ਉਪਭੋਗਤਾਵਾਂ ਦੀ ਸੰਖਿਆ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ। ਪਰ ਕਿਉਂਕਿ ਰੈਪੋ ਦੀ ਸੰਖਿਆ ਪ੍ਰਾਪਤ ਕਰਨਾ ਇੱਕ ਦੂਜੇ 'ਤੇ ਨਿਰਭਰ ਨਹੀਂ ਕਰਦਾ, ਪ੍ਰਕਿਰਿਆਵਾਂ ਨੂੰ ਸਮਾਨਾਂਤਰ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਇਸ ਲਈ .map ਅਤੇ Promise.all ਨਾਲ ਕੰਮ ਕਰਨ ਦੀ ਲੋੜ ਹੈ:

async function fetchAllCounts(users) {
  const promises = users.map(async username => {
    const count = await fetchPublicReposCount(username);
    return count;
  });
  return Promise.all(promises);
}

Promise.all ਇੰਪੁੱਟ ਦੇ ਤੌਰ 'ਤੇ ਵਾਅਦਿਆਂ ਦੀ ਇੱਕ ਲੜੀ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ ਅਤੇ ਇੱਕ ਵਾਅਦਾ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਬਾਅਦ ਵਾਲੇ ਨੂੰ ਐਰੇ ਵਿਚਲੇ ਸਾਰੇ ਵਾਅਦੇ ਪੂਰੇ ਹੋਣ ਜਾਂ ਪਹਿਲੇ ਅਸਵੀਕਾਰ ਹੋਣ 'ਤੇ ਪੂਰਾ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਇਹ ਹੋ ਸਕਦਾ ਹੈ ਕਿ ਉਹ ਸਾਰੇ ਇੱਕੋ ਸਮੇਂ ਸ਼ੁਰੂ ਨਾ ਹੋਣ - ਇੱਕੋ ਸਮੇਂ ਸ਼ੁਰੂ ਹੋਣ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ, ਤੁਸੀਂ ਪੀ-ਮੈਪ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ।

ਸਿੱਟਾ

ਅਸਿੰਕ ਫੰਕਸ਼ਨ ਵਿਕਾਸ ਲਈ ਤੇਜ਼ੀ ਨਾਲ ਮਹੱਤਵਪੂਰਨ ਹੁੰਦੇ ਜਾ ਰਹੇ ਹਨ। ਖੈਰ, ਅਸਿੰਕ ਫੰਕਸ਼ਨਾਂ ਦੀ ਅਨੁਕੂਲ ਵਰਤੋਂ ਲਈ, ਤੁਹਾਨੂੰ ਵਰਤਣਾ ਚਾਹੀਦਾ ਹੈ ਅਸਿੰਕ ਇਟਰੇਟਰ. ਇੱਕ JavaScript ਡਿਵੈਲਪਰ ਨੂੰ ਇਸ ਵਿੱਚ ਚੰਗੀ ਤਰ੍ਹਾਂ ਜਾਣੂ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ।

ਸਕਿੱਲਬਾਕਸ ਸਿਫ਼ਾਰਿਸ਼ ਕਰਦਾ ਹੈ:

• ਪ੍ਰੈਕਟੀਕਲ ਕੋਰਸ "ਮੋਬਾਈਲ ਡਿਵੈਲਪਰ ਪ੍ਰੋ".
• ਆਨਲਾਈਨ ਕੋਰਸ ਅਪਲਾਈ ਕੀਤਾ "ਪਾਈਥਨ ਵਿੱਚ ਡੇਟਾ ਐਨਾਲਿਸਟ".
• ਦੋ ਸਾਲਾ ਪ੍ਰੈਕਟੀਕਲ ਕੋਰਸ "ਮੈਂ ਇੱਕ ਪ੍ਰੋ ਵੈੱਬ ਡਿਵੈਲਪਰ ਹਾਂ".

ਸਰੋਤ: www.habr.com