javascript - অ্যারে থেকে প্যারামিটারগুলি পাস করে, ক্রম প্রতিশ্রুতিগুলি কীভাবে সম্পাদন করবেন?



(4)

var myArray = [1, 2, 3, 4, 5, 6]

function myPrommise(num){
  return new Promise(res => {
    window.setTimeout(()=>{
      res(  console.log("done: " + num)  )
    },2000)
  })
}


myPrommise(myArray[0])
  .then(x => myPrommise(myArray[1]))
  .then(x => myPrommise(myArray[2]))
  .then(x => myPrommise(myArray[3]))
  .then(x => myPrommise(myArray[4]))
  .then(x => myPrommise(myArray[5]))

এখনই যদি আমি উপরের বিবৃতিটি কার্যকর করি তবে এটি ক্রমান্বয়ে চলবে। আমার আসল ব্যবহারের ক্ষেত্রে অ্যারেটি গতিশীলভাবে জনবহুল এবং myPromise() প্রতিটি সদস্যের জন্য আমার myPromise() ফাংশন সম্পাদন করা দরকার।

আমি কীভাবে "বিরতিযুক্ত লুপ" তৈরি করতে পারি যা অ্যারের প্রতিটি আইটেমের জন্য লুপ তৈরি করবে, myPromise এবং পরবর্তী পুনরাবৃত্তিটি চালিয়ে যাওয়ার আগে প্রতিশ্রুতিটি সমাধান হওয়ার জন্য অপেক্ষা করবে?

https://ffff65535.com


আপনি Array.reduce ব্যবহার করতে পারেন।

//type: [number]
var myArray = [1, 2, 3, 4, 5, 6] //doesn't really matter

//type: number -> Promise<number>
function myPromise(num){
  return new Promise((resolve) => {
    window.setTimeout(()=>{
      resolve(console.log("done: " + num)  )
    },2000)
  })
}

//Array.reduce has type: [a] ~> ((b, a) -> b), b) -> b
//So it can have type:
//[number] ~> ((Promise<number>, number) -> Promise<number>), Promise<number>) -> Promise<number>
//Therefore we need to give reduce a function that takes a Promise 
//resolving to a number and a number which makes a new promise.
//This is the function we want:

function sequencePromises(promise, number) {
  return new Promise((resolve) => {
    resolve(promise.then(_ => myPromise(number)));
  });
} 

myArray.reduce(sequencePromises, Promise.resolve());

অবশ্যই, যদি আপনার কাছে এমন কোনও প্রতিশ্রুতি থাকে যা ত্রুটি করতে পারে বা আপনার যদি পূর্ববর্তী ফলাফলের প্রয়োজন হয় তবে এই সরল কৌশলটি কার্যকর হবে না, যাতে আপনি sequencePromises তৈরি করতে চাইতে পারেন আরও জেনেরিক:

function genericSequencePromises(promiseFunction) {
  return (promise, parameter) => {
    return new Promise((resolve, reject) => 
                         return promiseFunction(resolve, 
                                                reject, 
                                                promise, 
                                                parameter));
  }
}

তারপরে আপনি যতক্ষণ প্রতিশ্রুতি ফিরিয়েছেন ততক্ষণ আপনি যা কিছু করতে পারেন।

অবশেষে, আপনি এই সামান্য সহায়ক থেকে উপকৃত হতে পারেন:

function promiseSeries(array, reducer) {
  return array.reduce(reducer, Promise.resolve());
}

এগুলি সব একত্রিত করা:

let sequencePromises = genericSequencePromises((resolve, reject, promise, num) => {
  resolve(promise.then(_ => console.log(`done: ${num}`)));
}

promiseSeries(myArray, sequencePromises);

এইভাবে, আপনি কেবল আপনার প্রশ্নে মামলাটি পরিচালনা করতে পারবেন না, তবে আরও জটিল ক্ষেত্রে।


আপনি উপাদানগুলির অ্যারের উপরে পুনরাবৃত্তি করতে পারেন এবং এই জাতীয় প্যারামগুলি পাস করতে পারেন:

const arr = [1, 2, 3, 4, 5, 6];
const MyPromiseFunction = num => new Promise((resolve, reject) => {
  // Your logic...
  setTimeout(() => num <= 4 
    ? resolve('Success!') 
    : reject('Rejected!'), 1000 * num);
});
const logMessage = (num, msg) => console.log(`For number ${num} promise result: ${msg}`);

arr.forEach(
  num => MyPromiseFunction(num)
    .then(message => logMessage(num, message))
    .catch(reason => logMessage(num, reason))
);


আমি babel ব্যবহার করব এবং এটি এইভাবে করব:

    let args = [1, 2, 3];
    
    const myPromise = async x => console.log('arg:',x);
    
    const test = async () => {
      for (let task of args.map(myPromise)) 
        await task;
    }
  
    test().then(console.log('Done'));
<script src="https://unpkg.com/[email protected]/babel.min.js"></script>


এছাড়াও আপনি এটি পুনরাবৃত্তির পদ্ধতির মাধ্যমে করতে পারেন - executeSequentially নিজেই কল করে:

function createPromise(x) {
  return new Promise(res => {
    setTimeout(() => {
      console.log(x)
      res(x);
    }, x * 1000)
  })
}

function executeSequentially(array) {  
  return createPromise(array.shift())
    .then(x => array.length == 0 ? x : executeSequentially(array));
}

console.time('executeSequentially');
executeSequentially([1, 2, 3]).then(x => {
  console.log('last value: ' + x);
  console.timeEnd('executeSequentially');
});





javascript