প্রত্যাশিত প্রতিশ্রুতি। সমস্ত () এবং একাধিক প্রতীক্ষার মধ্যে কোনও পার্থক্য?

Question

এর মধ্যে কোনও পার্থক্য আছে:

const [result1, result2] = await Promise.all([task1(), task2()]);

এবং

const t1 = task1();
const t2 = task2();

const result1 = await t1;
const result2 = await t2;

এবং

const [t1, t2] = [task1(), task2()];
const [result1, result2] = [await t1, await t2];

Comments

নিবিড়ভাবে সম্পর্কিত: একাধিক

— যুগপত

Answer 1

দ্রষ্টব্য :

এই উত্তরটি কেবল awaitসিরিজ এবং এর মধ্যে সময়ের পার্থক্যকে কভার করে Promise.all। @ মাইক্যাপের বিস্তৃত উত্তরটি অবশ্যই পড়তে ভুলবেন না যা ত্রুটি পরিচালনার ক্ষেত্রে আরও গুরুত্বপূর্ণ পার্থক্যকে আচ্ছাদন করে ।

---

এই উত্তরের উদ্দেশ্যে আমি কয়েকটি উদাহরণ পদ্ধতি ব্যবহার করব:

• res(ms) এটি এমন একটি ফাংশন যা মিলিসেকেন্ডগুলির পূর্ণসংখ্যা নেয় এবং এমন প্রতিশ্রুতি দেয় যা অনেক মিলিসেকেন্ডের পরে সমাধান হয়।
• rej(ms) এমন একটি ফাংশন যা মিলিসেকেন্ডগুলির পূর্ণসংখ্যা নেয় এবং এমন প্রতিশ্রুতি দেয় যা অনেক মিলিসেকেন্ড পরে প্রত্যাখ্যান করে।

কলিং resটাইমার শুরু হয়। ব্যবহার Promise.allবিলম্ব থাবা জন্য অপেক্ষা পরে বিলম্ব শেষ করেছি সমাধান হবে, কিন্তু তারা একই সময়ে চালানো মনে রাখা:

_{উদাহরণ # 1}

const data = await Promise.all([res(3000), res(2000), res(1000)])
//                              ^^^^^^^^^  ^^^^^^^^^  ^^^^^^^^^
//                               delay 1    delay 2    delay 3
//
// ms ------1---------2---------3
// =============================O delay 1
// ===================O           delay 2
// =========O                     delay 3
//
// =============================O Promise.all

async function example() {
  const start = Date.now()
  let i = 0
  function res(n) {
    const id = ++i
    return new Promise((resolve, reject) => {
      setTimeout(() => {
        resolve()
        console.log(`res #${id} called after ${n} milliseconds`, Date.now() - start)
      }, n)
    })
  }

  const data = await Promise.all([res(3000), res(2000), res(1000)])
  console.log(`Promise.all finished`, Date.now() - start)
}

example()

এর অর্থ এটি Promise.all3 সেকেন্ড পরে অভ্যন্তরীণ প্রতিশ্রুতি থেকে ডেটা দিয়ে সমাধান করবে।

তবে, Promise.allএকটি "ব্যর্থ দ্রুত" আচরণ রয়েছে :

_{উদাহরণ # 2}

const data = await Promise.all([res(3000), res(2000), rej(1000)])
//                              ^^^^^^^^^  ^^^^^^^^^  ^^^^^^^^^
//                               delay 1    delay 2    delay 3
//
// ms ------1---------2---------3
// =============================O delay 1
// ===================O           delay 2
// =========X                     delay 3
//
// =========X                     Promise.all

async function example() {
  const start = Date.now()
  let i = 0
  function res(n) {
    const id = ++i
    return new Promise((resolve, reject) => {
      setTimeout(() => {
        resolve()
        console.log(`res #${id} called after ${n} milliseconds`, Date.now() - start)
      }, n)
    })
  }
  
  function rej(n) {
    const id = ++i
    return new Promise((resolve, reject) => {
      setTimeout(() => {
        reject()
        console.log(`rej #${id} called after ${n} milliseconds`, Date.now() - start)
      }, n)
    })
  }
  
  try {
    const data = await Promise.all([res(3000), res(2000), rej(1000)])
  } catch (error) {
    console.log(`Promise.all finished`, Date.now() - start)
  }
}

example()

আপনি যদি এর async-awaitপরিবর্তে ব্যবহার করেন তবে আপনাকে প্রতিটি প্রতিশ্রুতি ধারাবাহিকভাবে সমাধানের জন্য অপেক্ষা করতে হবে, যা ততটা দক্ষ নাও হতে পারে:

_{উদাহরণ # 3}

const delay1 = res(3000)
const delay2 = res(2000)
const delay3 = rej(1000)

const data1 = await delay1
const data2 = await delay2
const data3 = await delay3

// ms ------1---------2---------3
// =============================O delay 1
// ===================O           delay 2
// =========X                     delay 3
//
// =============================X await

async function example() {
  const start = Date.now()
  let i = 0
  function res(n) {
    const id = ++i
    return new Promise((resolve, reject) => {
      setTimeout(() => {
        resolve()
        console.log(`res #${id} called after ${n} milliseconds`, Date.now() - start)
      }, n)
    })
  }
  
  function rej(n) {
    const id = ++i
    return new Promise((resolve, reject) => {
      setTimeout(() => {
        reject()
        console.log(`rej #${id} called after ${n} milliseconds`, Date.now() - start)
      }, n)
    })
  }
  
  try {
    const delay1 = res(3000)
    const delay2 = res(2000)
    const delay3 = rej(1000)

    const data1 = await delay1
    const data2 = await delay2
    const data3 = await delay3
  } catch (error) {
    console.log(`await finished`, Date.now() - start)
  }
}

example()

Comments

সুতরাং মূলত পার্থক্যটি কেবল প্রতিশ্রুতির সমস্ত "ব্যর্থ দ্রুত" বৈশিষ্ট্য?

— ম্যাথু

@mclzc উদাহরণস্বরূপ # 3 আরও কোড এক্সিকিউশনটি বিলম্ব 1 সমাধান না হওয়া অবধি বন্ধ রয়েছে। এমনকি এটি পাঠ্যটিতে "যদি আপনি এর পরিবর্তে অ্যাসিঙ্ক-প্রতীক্ষা ব্যবহার করেন তবে আপনাকে প্রতিটি প্রতিশ্রুতি ধারাবাহিকভাবে সমাধানের জন্য অপেক্ষা করতে হবে"

— হাগিস

@ কিউব্যাক, একটি লাইভ কোড স্নিপেট রয়েছে যা আচরণটি দেখায়। এটি চালানো এবং কোডটি পুনরায় পড়ার বিষয়টি বিবেচনা করুন। প্রতিশ্রুতির ক্রম কীভাবে আচরণ করে তা ভুল বোঝার আপনি প্রথম ব্যক্তি নন। আপনি আপনার ডেমোতে যে ভুলটি করেছেন তা হ'ল আপনি একই সাথে আপনার প্রতিশ্রুতি শুরু করছেন না।

— zzzzBov

@ZzzBov ঠিক বলেছেন আপনি এটি একই সময়ে শুরু করছেন। দুঃখিত, আমি অন্য কারণে এই প্রশ্নে এসেছি এবং আমি এটি উপেক্ষা করেছি।

— কিউব্যাক

" এটি ততটা দক্ষ নাও হতে পারে " - এবং আরও গুরুত্বপূর্ণভাবে unhandledrejectionত্রুটি ঘটায় । আপনি এটি ব্যবহার করতে চাইবেন না। আপনার উত্তরে এটি যোগ করুন।

— বার্গি

Answer 2

প্রথম পার্থক্য - দ্রুত ব্যর্থ

আমি @ zzzzBov এর উত্তরের সাথে একমত, কিন্তু প্রতিশ্রুতির "দ্রুত ব্যর্থ" সুবিধাটি সমস্তই কেবল একটি পার্থক্য নয়। কিছু ব্যবহারকারী মন্তব্য করার সময় কেন প্রতিশ্রুতিটি ব্যবহার করবেন তা জিজ্ঞাসা করেন when যখন এটি কেবল নেতিবাচক দৃশ্যে দ্রুত হয় (যখন কোনও কাজ ব্যর্থ হয়)। আর আমি জিজ্ঞাসা করি কেন? যদি আমার দুটি স্বতন্ত্র এ্যাসিঙ্ক সমান্তরাল কাজ হয় এবং প্রথমটি খুব দীর্ঘ সময়ে সমাধান করা হয় তবে দ্বিতীয়টি খুব অল্প সময়ের মধ্যে প্রত্যাখ্যান করা হয় তবে ব্যবহারকারীরা কেন "খুব অল্প সময়ের" পরিবর্তে ত্রুটি বার্তা "খুব দীর্ঘ সময়" জন্য অপেক্ষা করবেন? বাস্তব জীবনের অ্যাপ্লিকেশনগুলিতে আমাদের অবশ্যই নেতিবাচক দৃশ্য বিবেচনা করতে হবে। তবে ঠিক আছে - এই প্রথম পার্থক্যে আপনি সিদ্ধান্ত নিতে পারবেন কোন বিকল্পটি প্রতিশ্রুতি ব্যবহার করতে হবে all সমস্ত বনাম একাধিক অপেক্ষা it

দ্বিতীয় পার্থক্য - ত্রুটি পরিচালনা

তবে ত্রুটিটি পরিচালনা করার বিষয়ে বিবেচনা করার সময় আপনি অবশ্যই প্রতিশ্রুতি ব্যবহার করুন। একাধিক প্রতীক্ষার সাথে ট্রিগার করা অ্যাসিঙ্ক সমান্তরাল কার্যগুলির ত্রুটিগুলি সঠিকভাবে পরিচালনা করা সম্ভব নয়। নেতিবাচক দৃশ্যে আপনি সর্বদা শেষ হয়ে যাবেন UnhandledPromiseRejectionWarningএবং PromiseRejectionHandledWarningআপনি কোথাও চেষ্টা / ধরা ব্যবহার করেন। এজন্য প্রতিশ্রুতি.আল ডিজাইন করা হয়েছিল। অবশ্যই কেউ বলতে পারে যে আমরা ত্রুটিগুলি ব্যবহার করে দমন করতে পারি process.on('unhandledRejection', err => {})এবং process.on('rejectionHandled', err => {})এটি ভাল অনুশীলন নয়। আমি ইন্টারনেটে এমন অনেকগুলি উদাহরণ পেয়েছি যা দুটি বা ততোধিক স্বতঃসন্ধিক সমান্তরাল কাজের জন্য ত্রুটি পরিচালনার বিষয়টি মোটেও বিবেচনা করে না বা এটিকে ভুল উপায়ে বিবেচনা করে - কেবল চেষ্টা / ধরা এবং এটি আশা করে ত্রুটি ধরা পড়বে। ভাল অনুশীলন খুঁজে পাওয়া প্রায় অসম্ভব। এজন্য আমি এই উত্তরটি লিখছি।

সারসংক্ষেপ

দুই বা ততোধিক স্বতঃসন্ধিক সমান্তরাল কার্যগুলির জন্য একাধিক প্রতীক্ষা কখনই ব্যবহার করবেন না কারণ আপনি ত্রুটিগুলি গুরুত্ব সহকারে পরিচালনা করতে পারবেন না। এই ব্যবহারের ক্ষেত্রে সর্বদা প্রতিশ্রুতি.আল () ব্যবহার করুন। আশ্বাস / প্রতীক্ষা প্রতিশ্রুতি প্রতিস্থাপন নয়। প্রতিশ্রুতিগুলি কীভাবে ব্যবহার করবেন এটি কেবল দুর্দান্ত উপায় ... অ্যাসিঙ্ক কোডটি সিঙ্ক স্টাইলে লেখা হয় এবং আমরা thenপ্রতিশ্রুতিতে একাধিক এড়াতে পারি ।

কিছু লোক বলেছেন যে প্রতিশ্রুতি। সমস্ত () ব্যবহার করে আমরা কার্য ত্রুটিগুলি পৃথকভাবে পরিচালনা করতে পারি না তবে কেবল প্রথম প্রত্যাখ্যাত প্রতিশ্রুতি থেকে ত্রুটি (হ্যাঁ, কিছু ব্যবহারের ক্ষেত্রে লগিংয়ের জন্য পৃথক হ্যান্ডলিং প্রয়োজন হতে পারে)। এটি সমস্যা নয় - নীচে "সংযোজন" শিরোনাম দেখুন।

উদাহরণ

এই অ্যাসিঙ্ক কার্যটি বিবেচনা করুন ...

const task = function(taskNum, seconds, negativeScenario) {
  return new Promise((resolve, reject) => {
    setTimeout(_ => {
      if (negativeScenario)
        reject(new Error('Task ' + taskNum + ' failed!'));
      else
        resolve('Task ' + taskNum + ' succeed!');
    }, seconds * 1000)
  });
};

---

আপনি যখন ইতিবাচক দৃশ্যে কাজ পরিচালনা করেন তখন প্রতিশ্রুতি.আল এবং একাধিক প্রতীক্ষার মধ্যে কোনও পার্থক্য নেই। উভয় উদাহরণ Task 1 succeed! Task 2 succeed!5 সেকেন্ড পরে শেষ হয় ।

// Promise.all alternative
const run = async function() {
  // tasks run immediate in parallel and wait for both results
  let [r1, r2] = await Promise.all([
    task(1, 5, false),
    task(2, 5, false)
  ]);
  console.log(r1 + ' ' + r2);
};
run();
// at 5th sec: Task 1 succeed! Task 2 succeed!

// multiple await alternative
const run = async function() {
  // tasks run immediate in parallel
  let t1 = task(1, 5, false);
  let t2 = task(2, 5, false);
  // wait for both results
  let r1 = await t1;
  let r2 = await t2;
  console.log(r1 + ' ' + r2);
};
run();
// at 5th sec: Task 1 succeed! Task 2 succeed!

---

যখন প্রথম টাস্কটি ইতিবাচক দৃশ্যে 10 সেকেন্ড নেয় এবং সেকেন্ডের কার্যটি নেতিবাচক দৃশ্যে 5 সেকেন্ড সময় নেয় সেখানে ত্রুটি জারি করার ক্ষেত্রে পার্থক্য রয়েছে।

// Promise.all alternative
const run = async function() {
  let [r1, r2] = await Promise.all([
      task(1, 10, false),
      task(2, 5, true)
  ]);
  console.log(r1 + ' ' + r2);
};
run();
// at 5th sec: UnhandledPromiseRejectionWarning: Error: Task 2 failed!

// multiple await alternative
const run = async function() {
  let t1 = task(1, 10, false);
  let t2 = task(2, 5, true);
  let r1 = await t1;
  let r2 = await t2;
  console.log(r1 + ' ' + r2);
};
run();
// at 5th sec: UnhandledPromiseRejectionWarning: Error: Task 2 failed!
// at 10th sec: PromiseRejectionHandledWarning: Promise rejection was handled asynchronously (rejection id: 1)
// at 10th sec: UnhandledPromiseRejectionWarning: Error: Task 2 failed!

আমাদের ইতিমধ্যে এখানে লক্ষ্য করা উচিত যে সমান্তরালভাবে একাধিক প্রতীক্ষা ব্যবহার করার সময় আমরা কিছু ভুল করছি। অবশ্যই ত্রুটিগুলি এড়াতে আমাদের এটি পরিচালনা করা উচিত! আসুন চেষ্টা করি ...

---

// Promise.all alternative
const run = async function() {
  let [r1, r2] = await Promise.all([
    task(1, 10, false),
    task(2, 5, true)
  ]);
  console.log(r1 + ' ' + r2);
};
run().catch(err => { console.log('Caught error', err); });
// at 5th sec: Caught error Error: Task 2 failed!

আপনি যেমন সফলভাবে ত্রুটিটি পরিচালনা করতে দেখতে পান আমাদের runফাংশনে মাত্র একটি ক্যাচ যুক্ত করতে হবে এবং ক্যাচ লজিক সহ কোড কলব্যাকে রয়েছে ( অ্যাসিঙ্ক স্টাইল )। runফাংশনের অভ্যন্তরে আমাদের হ্যান্ডেল ত্রুটির প্রয়োজন নেই কারণ অ্যাসিঙ্ক ফাংশন এটি স্বয়ংক্রিয়ভাবে ঘটে - taskফাংশন প্রত্যাখ্যানের কারণে runফাংশন প্রত্যাখ্যান হয়। কলব্যাক এড়ানোর জন্য আমরা সিঙ্ক শৈলীটি ব্যবহার করতে পারি (async / انتظار / চেষ্টা / চেষ্টা করুন) try { await run(); } catch(err) { }তবে এই উদাহরণে এটি সম্ভব নয় কারণ আমরা awaitমূল থ্রেডে ব্যবহার করতে পারি না - এটি কেবল async ফাংশনে ব্যবহার করা যেতে পারে (এটি যৌক্তিক কারণ কেউই চায় না মূল থ্রেড ব্লক করুন)। হ্যান্ডলিং সিঙ্ক স্টাইলে কাজ করে কিনা তা পরীক্ষা করতে আমরা কল করতে পারিrunঅন্য ASYNC ফাংশন বা ব্যবহার IIFE (অবিলম্বে প্রার্থনা ফাংশন এক্সপ্রেশন) থেকে ফাংশন: (async function() { try { await run(); } catch(err) { console.log('Caught error', err); }; })();।

এটি কেবলমাত্র দুটি সঠিক সংস্থান সমান্তরাল কাজগুলি পরিচালনা করতে এবং ত্রুটিগুলি পরিচালনা করতে পারে correct আপনার নীচের উদাহরণগুলি এড়ানো উচিত।

---

// multiple await alternative
const run = async function() {
  let t1 = task(1, 10, false);
  let t2 = task(2, 5, true);
  let r1 = await t1;
  let r2 = await t2;
  console.log(r1 + ' ' + r2);
};

আমরা বিভিন্ন উপায়ে কোড হ্যান্ডেল করার চেষ্টা করতে পারি ...

try { run(); } catch(err) { console.log('Caught error', err); };
// at 5th sec: UnhandledPromiseRejectionWarning: Error: Task 2 failed!
// at 10th sec: UnhandledPromiseRejectionWarning: Error: Task 2 failed!
// at 10th sec: PromiseRejectionHandledWarning: Promise rejection was handled 

... কিছুই ধরা পড়েনি কারণ এটি সিঙ্ক কোডটি পরিচালনা করে তবে runএটি অ্যাসিঙ্ক

run().catch(err => { console.log('Caught error', err); });
// at 5th sec: UnhandledPromiseRejectionWarning: Error: Task 2 failed!
// at 10th sec: Caught error Error: Task 2 failed!
// at 10th sec: PromiseRejectionHandledWarning: Promise rejection was handled asynchronously (rejection id: 1)

... ডব্লিউটিএফ? আমরা প্রথমত দেখতে পাই যে টাস্ক 2 এর জন্য ত্রুটিটি পরিচালনা করা হয়নি এবং পরে এটি ধরা পড়ে। বিভ্রান্তিকর এবং এখনও কনসোলে ত্রুটি পূর্ণ। এইভাবে ব্যবহারযোগ্য নয়।

(async function() { try { await run(); } catch(err) { console.log('Caught error', err); }; })();
// at 5th sec: UnhandledPromiseRejectionWarning: Error: Task 2 failed!
// at 10th sec: Caught error Error: Task 2 failed!
// at 10th sec: PromiseRejectionHandledWarning: Promise rejection was handled asynchronously (rejection id: 1)

... উপরের মতই ব্যবহারকারী @ কিওয়ার্টি তার মুছে দেওয়া উত্তরে এই অদ্ভুত আচরণ সম্পর্কে জিজ্ঞাসা করেছেন যা ধরা পড়েছে বলে মনে হয় তবে অনাবৃত ত্রুটিগুলিও রয়েছে। আমরা ত্রুটিটি ধরছি কারণ অপেক্ষা (মূলোত্তর) কীওয়ার্ডের সাথে লাইনে রান () প্রত্যাখ্যান করা হয়েছে এবং রান () কল করার সময় ট্র্যাচ / ক্যাচ ব্যবহার করে ক্যাচ করা যায়। আমরা আনহ্যান্ডলড ত্রুটিও পেয়েছি কারণ আমরা অ্যাসিঙ্ক টাস্ক ফাংশনটিকে সিঙ্ক্রোনসিভভাবে কল করছি (কীওয়ার্ডের অপেক্ষা না করে) এবং এই টাস্কটি রান () ফাংশনের বাইরে চলে এবং বাইরেও ব্যর্থ হয়। এটি একই রকম হয় যখন সেট টাইমআউটটিতে কোডের কোন অংশটি চালিত হয় এমন কোনও সিঙ্ক ফাংশন কল করার সময় আমরা চেষ্টা / ধরার মাধ্যমে ত্রুটি পরিচালনা করতে সক্ষম হই না function test() { setTimeout(function() { console.log(causesError); }, 0); }; try { test(); } catch(e) { /* this will never catch error */ }।

const run = async function() {
  try {
    let t1 = task(1, 10, false);
    let t2 = task(2, 5, true);
    let r1 = await t1;
    let r2 = await t2;
  }
  catch (err) {
    return new Error(err);
  }
  console.log(r1 + ' ' + r2);
};
run().catch(err => { console.log('Caught error', err); });
// at 5th sec: UnhandledPromiseRejectionWarning: Error: Task 2 failed!
// at 10th sec: PromiseRejectionHandledWarning: Promise rejection was handled asynchronously (rejection id: 1)

... "কেবল" দুটি ত্রুটি (তৃতীয়টি অনুপস্থিত) তবে কিছুই ধরা পড়েনি।

---

সংযোজন (পৃথকভাবে কার্য ত্রুটিগুলি পরিচালনা করুন এবং প্রথম ব্যর্থ ত্রুটিও হ্যান্ডেল করুন)

const run = async function() {
  let [r1, r2] = await Promise.all([
    task(1, 10, true).catch(err => { console.log('Task 1 failed!'); throw err; }),
    task(2, 5, true).catch(err => { console.log('Task 2 failed!'); throw err; })
  ]);
  console.log(r1 + ' ' + r2);
};
run().catch(err => { console.log('Run failed (does not matter which task)!'); });
// at 5th sec: Task 2 failed!
// at 5th sec: Run failed (does not matter which task)!
// at 10th sec: Task 1 failed!

... নোট করুন যে এই উদাহরণে আমি নেগেটিভ সেনেরিও = সত্যই ব্যবহার করেছি উভয় কাজের জন্য আরও ভাল প্রদর্শনের জন্য যা ঘটে ( throw errচূড়ান্ত ত্রুটি থেকে আগুনে ব্যবহৃত হয়)

Comments

এই উত্তর গৃহীত উত্তরের চেয়ে ভাল কারণ বর্তমানে গৃহীত উত্তর ত্রুটি পরিচালনার খুব গুরুত্বপূর্ণ বিষয়টিকে মিস করে

— chrishiestand

Answer 3

সাধারণত, Promise.all()সমান্তরালভাবে "async" রিকোয়েস্ট ব্যবহার করে । ব্যবহার awaitসমান্তরাল চলতে পারে বা "সিঙ্ক" ব্লক করা হতে পারে।

নীচে টেস্ট 1 এবং টেস্ট 2 ফাংশনগুলি দেখায় যে কীভাবে awaitঅ্যাসিঙ্ক বা সিঙ্ক চালানো যায়।

test3 দেখায় Promise.all()যে async।

সময়সীমার ফলাফল সহ jsfiddle - পরীক্ষার ফলাফল দেখতে ব্রাউজার কনসোল খুলুন

সিঙ্ক আচরণ। সমান্তরালে চলে না, লাগে takes 1800ms :

const test1 = async () => {
  const delay1 = await Promise.delay(600); //runs 1st
  const delay2 = await Promise.delay(600); //waits 600 for delay1 to run
  const delay3 = await Promise.delay(600); //waits 600 more for delay2 to run
};

অ্যাসিঙ্ক আচরণ প্যারালেলে চালিত হয় , ~ 600ms লাগে :

const test2 = async () => {
  const delay1 = Promise.delay(600);
  const delay2 = Promise.delay(600);
  const delay3 = Promise.delay(600);
  const data1 = await delay1;
  const data2 = await delay2;
  const data3 = await delay3; //runs all delays simultaneously
}

অ্যাসিঙ্ক আচরণ সমান্তরালভাবে চলে, ~ 600ms লাগে :

const test3 = async () => {
  await Promise.all([
  Promise.delay(600), 
  Promise.delay(600), 
  Promise.delay(600)]); //runs all delays simultaneously
};

TLDR; আপনি যদি এটি ব্যবহার করেন তবে Promise.all()এটি "দ্রুত-ব্যর্থ "ও হবে - অন্তর্ভুক্ত ফাংশনগুলির প্রথম ব্যর্থতার সময়ে চলমান বন্ধ করুন ।

Comments

স্নিপেটস 1 এবং 2 এ হুডের নীচে কী ঘটে যায় তার বিশদ বিবরণ আমি কোথায় পেতে পারি? আমি এত বিস্মিত হয়েছি যে এগুলি চালানোর জন্য আলাদা উপায় আছে কারণ আমি আশা করছিলাম যে আচরণগুলি একই হবে।

— গ্রেগর্ডি

@ গ্রেগর্ডি হ্যাঁ অবাক করা। আমি কোডারদের নতুন কিছু মাথা ব্যথার জন্য নতুন করে সংরক্ষণ করার জন্য এই উত্তরটি পোস্ট করেছি। যখন জেএস অপেক্ষাটির মূল্যায়ন করে তখন এটাই হয়, আপনি ভেরিয়েবলগুলি কীভাবে নির্ধারণ করেন। গভীরতার অ্যাসিঙ্ক

— গ্যাভিনবেলসন ২১

Answer 4

আপনি নিজের জন্য পরীক্ষা করতে পারেন।

এই ভাঙ্গনে আমি বাধা দেওয়ার প্রকৃতিটি প্রদর্শনের জন্য একটি পরীক্ষা চালিয়েছি , যার awaitবিপরীতে Promise.allসমস্ত প্রতিশ্রুতি শুরু হবে এবং একজন অপেক্ষায় থাকা অবস্থায় এটি অন্যদের সাথে চলবে।

Comments

প্রকৃতপক্ষে, আপনার প্রশ্নটি তাঁর প্রশ্নের সমাধান করে না। মূল কলটিতে যেমন ব্যবহার করছেন আপনি যা পরীক্ষা করছেন তার বিপরীতে কল করা t1 = task1(); t2 = task2()এবং তারপরে তাঁর প্রশ্নের মতো এই awaitদুজনের জন্যই তার ব্যবহারের মধ্যে পার্থক্য রয়েছে । তার প্রশ্নের কোডটি একবারে সমস্ত প্রতিশ্রুতি শুরু করে। পার্থক্যটি, উত্তরগুলি দেখায়, এটি হ'ল ব্যর্থতাগুলি দ্রুততরভাবে রিপোর্ট করা হবে । result1 = await t1; result2 = await t2;awaitresult1 = await task1(); result2 = await task2();Promise.all

— ব্রায়ানগ্রিজসাকাক

আপনার উত্তরটি বিষয়গুলি বন্ধ রয়েছে যেমন @ ব্রায়ানগ্রিজসাক মন্তব্য করেছেন। ব্যবহারকারীদের বিভ্রান্তি এড়ানোর জন্য আপনার বরং এটি মুছে ফেলা উচিত।

— মাইকেপ

Answer 5

প্রতিশ্রুতির ক্ষেত্রে অপেক্ষা করুন.এল ([টাস্ক 1 (), টাস্ক 2 ()]); "টাস্ক 1 ()" এবং "টাস্ক ২ ()" সমান্তরালভাবে চলবে এবং উভয় প্রতিশ্রুতি শেষ না হওয়া পর্যন্ত অপেক্ষা করবে (হয় সমাধান বা বাতিল) rejected যেখানে ক্ষেত্রে

const result1 = await t1;
const result2 = await t2;

t2 কেবলমাত্র T1 কার্যকর হয়ে গেলে (সমাধান করা বা প্রত্যাখ্যান করা) চালানো হবে। টি 1 এবং টি 2 উভয়ই সমান্তরালভাবে চলবে না।