নিয়ন্ত্রণ প্রবাহ

কন্ট্রোল ফ্লো হল সেই ক্রম যেখানে জাভাস্ক্রিপ্ট ইন্টারপ্রেটার স্টেটমেন্ট এক্সিকিউট করে। যদি একটি স্ক্রিপ্টে বিবৃতিগুলি অন্তর্ভুক্ত না করে যা এর প্রবাহকে পরিবর্তন করে, তবে এটি শুরু থেকে শেষ পর্যন্ত চালানো হয়, একবারে একটি লাইন। কন্ট্রোল স্ট্রাকচারগুলি নির্ধারিত মানদণ্ডের সেটের উপর ভিত্তি করে বিবৃতিগুলির একটি সেট কার্যকর করা হয় কিনা তা নির্ধারণ করতে, বিবৃতিগুলির একটি সেট বারবার কার্যকর করা বা বিবৃতিগুলির একটি ক্রমকে বাধা দেওয়ার জন্য ব্যবহৃত হয়।

শর্তসাপেক্ষ বিবৃতি

শর্তসাপেক্ষ বিবৃতি নির্ধারণ করে যে কোড এক বা একাধিক শর্তের উপর ভিত্তি করে কার্যকর করা উচিত কিনা। একটি শর্তসাপেক্ষ বিবৃতি এটিতে থাকা কোডটি কার্যকর করে যদি সংশ্লিষ্ট শর্ত (বা শর্তের সেট) true মূল্যায়ন করে। অন্যথায়, কোডটি এড়িয়ে গেছে।

if … else

একটি if বিবৃতি অনুসরণ করা মিলিত বন্ধনীর ভিতরে একটি শর্ত মূল্যায়ন করে। যদি বন্ধনীর ভিতরের শর্তটি true মূল্যায়ন করা হয়, তাহলে বিবৃতি বা ব্লক স্টেটমেন্ট যা মিলিত বন্ধনী অনুসরণ করে তা কার্যকর করা হয়:

if ( true ) console.log( "True." );
> "True."

if ( true ) {
    const myString = "True.";
    console.log( myString );
}
> "True."

যদি বন্ধনীর ভিতরের শর্তটি false বলে মূল্যায়ন করে, তাহলে যে বিবৃতিটি অনুসরণ করে তা উপেক্ষা করা হয়:

if ( false ) console.log( "True." );

একটি if স্টেটমেন্ট এবং এর শর্তসাপেক্ষে-নির্বাহিত বিবৃতিটি অবিলম্বে অনুসরণ করে একটি else কীওয়ার্ড যদি if শর্তটি false বলে মূল্যায়ন করে তাহলে বিবৃতিটি কার্যকর করা হবে তা নির্দিষ্ট করে:

if ( false ) console.log( "True." )''
else console.log( "False" );
> "False."

একাধিক if স্টেটমেন্ট একসাথে চেইন করতে, আপনি শর্তসাপেক্ষে নির্বাহিত বিবৃতি তৈরি করতে পারেন else if স্টেটমেন্ট অনুসরণ করে:

const myCondition = 2;
if ( myCondition === 5 ) console.log( "Five." );
else if ( myCondition === 2 ) console.log( "Two." );

আমরা পঠনযোগ্যতা উন্নত করতে নিম্নলিখিত শর্তাবলী ব্লক স্টেটমেন্ট সিনট্যাক্স ব্যবহার করার দৃঢ়ভাবে সুপারিশ করি, কিন্তু else if ধারাগুলি প্রায়শই এর ব্যতিক্রম হয়:

if ( myCondition === 5 ) {
    console.log( "Five." );
} else if ( myCondition === 3 ) {
    console.log( "Three" );
} else {
    console.log( "Neither five nor three." );
}
> "Neither five nor three."

টার্নারি অপারেটর

if শর্তসাপেক্ষে একটি বিবৃতি কার্যকর করে। টারনারি অপারেটর (আরো সঠিকভাবে কিন্তু কম সাধারণভাবে বলা হয় টারনারি কন্ডিশনাল অপারেটর ) শর্তসাপেক্ষে একটি এক্সপ্রেশন চালানোর জন্য শর্টহ্যান্ড ব্যবহার করা হয়। নাম থেকে বোঝা যায়, টারনারি অপারেটর হল একমাত্র জাভাস্ক্রিপ্ট অপারেটর যা তিনটি অপারেন্ড ব্যবহার করে:

• একটি শর্ত যা মূল্যায়ন করা হবে, তার পরে একটি প্রশ্ন চিহ্ন ( ? )।
• যদি শর্তটি true মূল্যায়ন করা হয়, তাহলে একটি কোলন ( : ) দ্বারা অনুসরণ করা হয়।
• এক্সপ্রেশন এক্সিকিউট করতে হবে যদি শর্তটি false মূল্যায়ন করে।

এটি প্রায়শই শর্তসাপেক্ষে একটি মান সেট বা পাস করতে ব্যবহৃত হয়:

const myFirstResult  = true  ? "First value." : "Second value.";
const mySecondResult = false ? "First value." : "Second value.";

myFirstResult;
> "First value."

mySecondResult;
> "Second value."

switch … case

এক বা একাধিক case কীওয়ার্ড ব্যবহার করে সংজ্ঞায়িত সম্ভাব্য মানের তালিকার সাথে একটি অভিব্যক্তির মান তুলনা করতে switch বিবৃতি ব্যবহার করুন। এই সিনট্যাক্সটি অস্বাভাবিক কারণ এটি জাভাস্ক্রিপ্টের প্রথম দিকের ডিজাইনের কিছু সিদ্ধান্ত থেকে আসে। switch … case সিনট্যাক্স switch কীওয়ার্ড ব্যবহার করে, তার পরে একটি অভিব্যক্তিকে বন্ধনীতে মোড়ানো মূল্যায়ন করা হয়, তারপরে একটি মিলিত জোড়া কোঁকড়া ধনুর্বন্ধনী দ্বারা অনুসরণ করা হয়। switch বডিতে case কীওয়ার্ড থাকতে পারে, সাধারণত এক বা একাধিক, তার পরে একটি এক্সপ্রেশন বা মান, তারপরে একটি কোলন ( : ) থাকে।

দোভাষী যখন switch কীওয়ার্ড অনুসরণ করে বন্ধনীতে মূল্যায়ন করা অভিব্যক্তির সাথে মিলে যাওয়া মান সহ একটি case পৌঁছায়, তখন এটি সেই case ক্লজ অনুসরণ করে এমন যেকোনো বিবৃতি কার্যকর করে:

switch ( 2 + 2 === 4 ) {
  case false:
    console.log( "False." );
  case true:
    console.log( "True." );
}
> "True."

ম্যাচিং case অনুসরণকারী সমস্ত বিবৃতি কার্যকর করা হয়, এমনকি যদি সেগুলি একটি ব্লক স্টেটমেন্টে আবদ্ধ থাকে।

switch ( 2 + 2 === 4 ) {
    case false:
    console.log( "False." );
  case true:
    let myVariable = "True.";
    console.log( myVariable );

}
> "True."

switch…case ব্যবহার করার একটি সমস্যা হল, মিল পাওয়া গেলে, জাভাস্ক্রিপ্ট ইন্টারপ্রেটার যে কোনো স্টেটমেন্ট এক্সিকিউট করে যা মিলিত case অনুসরণ করে, এমনকি অন্য case ক্লজের মধ্যেও। একে পরবর্তী case "পতনের মাধ্যমে" বলা হয়:

switch ( 2 + 2 === 7 ) {
    case false:
    console.log( "False." );
  case true:
    console.log( "True." );
}
> "False."
> "True."

পতন রোধ করতে, break কীওয়ার্ড দিয়ে প্রতিটি কেস শেষ করুন, যা অবিলম্বে switch বডির মূল্যায়ন বন্ধ করে দেয়:

switch ( 2 + 2 === 7 ) {
    case false:
    console.log( "False." );
    break;
  case true:
    console.log( "True." );
    break;
}
> "False."

যদি কোনো case শর্তসাপেক্ষ মানের সাথে মেলে না, তাহলে switch default ধারা নির্বাচন করে যদি একটি থাকে:

switch ( 20 ) {
    case 5:
    console.log( "The value was five." );
    break;
  case 10:
    console.log( "The value was ten." );
    break;
  default:
    console.log( "The value was something unexpected." );
}
> "The value was something unexpected."

যাইহোক, ফল-থ্রু default ক্ষেত্রেও প্রযোজ্য, সম্ভাব্যভাবে অপ্রত্যাশিত ফলাফলের দিকে নিয়ে যায়। এটি ঠিক করতে, break দিয়ে আপনার default বিবৃতিটি শেষ করুন, বা কেসগুলির তালিকায় এটিকে শেষ করুন৷

switch ( 20 ) {
  default:
    console.log( "The value was something unexpected." );
  case 10:
    console.log( "The value was ten." );
    break;
  case 5:
    console.log( "The value was five." );
    break;
}
> The value was something unexpected.
> The value was ten.

কারণ case ক্লজগুলির একাধিক স্টেটমেন্ট গ্রুপ করার জন্য ব্লক স্টেটমেন্টের প্রয়োজন হয় না, case এবং default ক্লজগুলি নিজেরাই আভিধানিক সুযোগ তৈরি করে না:

let myVariable;
switch ( true ) {
  case true:
    let myVariable = "True.";
    break;
  default:
    let myVariable = "False.";
    break;
}
> Uncaught SyntaxError: redeclaration of let myVariable

সুযোগ পরিচালনা করতে, ব্লক বিবৃতি ব্যবহার করুন:

let myVariable;
switch ( true ) {
  case true: {
    let myVariable = "True.";
    break;
  }
  default: {
    let myVariable = "False.";
    break;
  }
}

লুপ এবং পুনরাবৃত্তি

যতক্ষণ পর্যন্ত একটি শর্ত পূরণ হয় ততক্ষণ বা একটি শর্ত পূরণ না হওয়া পর্যন্ত লুপগুলি আপনাকে বিবৃতিগুলির একটি সেট পুনরাবৃত্তি করতে দেয়। নির্দেশের একটি সেটকে নির্দিষ্ট সংখ্যক বার চালানোর জন্য লুপ ব্যবহার করুন, যতক্ষণ না একটি নির্দিষ্ট ফলাফল পাওয়া যায়, অথবা যতক্ষণ না দোভাষী একটি পুনরাবৃত্তিযোগ্য ডেটা কাঠামোর শেষ পর্যন্ত পৌঁছায় (উদাহরণস্বরূপ, একটি অ্যারে, মানচিত্র বা সেটের চূড়ান্ত উপাদান, একটি বস্তুর চূড়ান্ত সম্পত্তি, বা একটি স্ট্রিং মধ্যে শেষ অক্ষর)।

লুপগুলি লুপ তৈরি করতে ব্যবহৃত সিনট্যাক্সের উপর নির্ভর করে এক বা একাধিক শর্ত পূরণ না হওয়া পর্যন্ত বিবৃতিগুলির একটি সেটের উপর পুনরাবৃত্তি করে একটি স্ক্রিপ্টের সম্পাদনের "উপর থেকে নীচে" প্রবাহকে বাধা দেয়। লুপ শেষ হওয়ার পরে, এটি অনুসরণ করা বিবৃতিতে মৃত্যুদন্ড অব্যাহত থাকে। নিম্নলিখিত উদাহরণে, দোভাষী এগিয়ে যাওয়ার আগে লুপের বডিতে বিবৃতিগুলি তিনবার কার্যকর করা হয়:

let iterationCount = 0;
console.log( "Pre-loop." );
while( iterationCount < 3 ) {
  iterationCount++;
  console.log( "Loop iteration." );
}
console.log( "Continuing on." );
> "Pre-loop."
> "Loop iteration."
> "Loop iteration."
> "Loop iteration."
> "Continuing on."

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

যতক্ষণ বুলিয়ান মান true থাকে ততক্ষণ নিচের উদাহরণটি কার্যকর হয় true কারণ বুলিয়ান মান অপরিবর্তনীয় , এটি একটি অসীম লুপ তৈরি করে।

সতর্কতা: নিম্নলিখিত কোডটি কার্যকর করা আপনার ব্রাউজারকে ধীর করে দিতে পারে বা আপনার বর্তমান ব্রাউজার ট্যাব ক্র্যাশ করতে পারে।

console.log( "Pre-loop." );
while( true ) {
console.log( "Loop iteration." );
}
> "Pre-loop."
> "Loop iteration."
> "Loop iteration."
> "Loop iteration."
> "Loop iteration."
> "Loop iteration."
…

আপনার প্রোডাকশন কোডে অসীম লুপ রেখে যাওয়া এড়িয়ে চলুন। আপনি যদি ডেভেলপমেন্টের সময় ভুলবশত একটি তৈরি করেন, তাহলে আপনি এটিতে চলমান ব্রাউজার ট্যাবটি বন্ধ করে, আপনার কোড আপডেট করে যাতে লুপ আর অসীম না থাকে, এবং পৃষ্ঠাটি পুনরায় খোলার মাধ্যমে এটি ঠিক করতে পারেন৷

while

একটি while লুপ তৈরি করা হয় while কীওয়ার্ড ব্যবহার করে এবং তার পরে একজোড়া মিলে যাওয়া বন্ধনীর সাথে মূল্যায়ন করার শর্ত রয়েছে। যদি নির্দিষ্ট শর্তটি প্রাথমিকভাবে true মূল্যায়ন করা হয়, তাহলে সেই বন্ধনী অনুসরণকারী বিবৃতি (বা ব্লক স্টেটমেন্ট ) কার্যকর করা হয়। যদি না হয়, লুপ কখনই চলে না। প্রতিটি পুনরাবৃত্তির পরে, শর্তটি পুনরায় মূল্যায়ন করা হয়, এবং যদি এটি এখনও true হয়, লুপ পুনরাবৃত্তি হয়।

let iterationCount = 0;
while( iterationCount < 3 ) {
  iterationCount++;
  console.log( `Loop ${ iterationCount }.` );
}
> "Loop 1."
> "Loop 2."

যদি দোভাষী while লুপের মধ্যে একটি continue বিবৃতি খুঁজে পায়, তবে এটি সেই পুনরাবৃত্তি বন্ধ করে, অবস্থার পুনর্মূল্যায়ন করে এবং সম্ভব হলে লুপটি চালিয়ে যায়:

let iterationCount = 0;
while( iterationCount <= 5 ) {
  iterationCount++;
  if( iterationCount === 3 ) {
    continue;
  }
  console.log( `Loop ${ iterationCount }.` );
}
console.log( "Loop ended." );
> "Loop 1."
> "Loop 2."
> "Loop 4."
> "Loop 5."
> "Loop ended."

যদি দোভাষী while লুপের মধ্যে একটি break বিবৃতি খুঁজে পায়, তবে সেই পুনরাবৃত্তি বন্ধ হয়ে যায় এবং শর্তটি পুনরায় মূল্যায়ন করা হয় না, দোভাষীকে এগিয়ে যেতে দেয়:

let iterationCount = 1;
while( iterationCount <= 5 ) {
  if( iterationCount === 3 ) {
    console.log(`Iteration skipped.``);`
    break;
  }
  console.log( `Loop ${ iterationCount }.` );
  iterationCount++;
}
console.log( "Loop ended." );
> "Loop 1."
> "Loop 2."
> "Iteration skipped.
> "Loop ended."

আপনি একটি নির্দিষ্ট সংখ্যক বার পুনরাবৃত্তি করতে while ব্যবহার করতে পারেন, যেমনটি আগের উদাহরণে দেখা গেছে, তবে while জন্য সবচেয়ে সাধারণ ব্যবহারের ক্ষেত্রে হল অনির্দিষ্ট দৈর্ঘ্যের একটি লুপ:

let randomize = () => Math.floor( Math.random() * 10 );
let randomNum = randomize();
while( randomNum !== 3 ){
  console.log( `The number is not ${ randomNum }.` );
  randomNum = randomize();
}
console.log( `The correct number, ${ randomNum }, was found.` );
> "The number is not 0."
> "The number is not 6."
> "The number is not 1."
> "The number is not 8."
> "The correct number, 3, was found."

do … while

do … while হল while লুপের একটি রূপ যেখানে লুপের প্রতিটি পুনরাবৃত্তির শেষে শর্তসাপেক্ষ মূল্যায়ন হয়। এর মানে লুপের বডি সর্বদা অন্তত একবার কার্যকর করা হয়।

একটি do … while লুপ তৈরি করতে, লুপের প্রতিটি পুনরাবৃত্তির জন্য বিবৃতি (বা ব্লক স্টেটমেন্ট ) দ্বারা অনুসরণ করা do কীওয়ার্ডটি ব্যবহার করুন। সেই বিবৃতিটির পরপরই, মূল্যায়ন করার শর্তযুক্ত while এবং মিলিত বন্ধনী যোগ করুন। যখন এই শর্তটি আর true মূল্যায়ন করা হয় না, তখন লুপ শেষ হয়।

let iterationCount = 1;
do {
  console.log( `Loop ${ iterationCount }.` );
  iterationCount++;
} while ( iterationCount < 3 );
> "Loop 1."
> "Loop 2."
> "Loop 3."

a while loop এর মত, do এর জন্য সবচেয়ে সাধারণ ব্যবহার কেস … while is a loop of indeterminate length:

let randomNum;
do {
  randomNum = ( () => Math.floor( Math.random() * 10 ) )();
  console.log( `Is the number ${ randomNum }?` );
} while ( randomNum !== 3 );
console.log( `Yes, ${ randomNum } was the correct number.` );
> "Is the number 9?"
> "Is the number 2?"
> "Is the number 8?"
> "Is the number 2?"
> "Is the number 3?"
> "Yes, 3 was the correct number."

for

একটি পরিচিত পরিমাণে পুনরাবৃত্তি করতে লুপগুলির for ব্যবহার করুন৷ লিগ্যাসি কোডবেসগুলিতে, এটি প্রায়শই একটি অ্যারের উপাদানগুলির উপর পুনরাবৃত্তি করতে ব্যবহৃত হত।

একটি লুপ তৈরি করতে, for for কীওয়ার্ডটি ব্যবহার করুন, তারপরে বন্ধনীর একটি সেট যা নিম্নলিখিত তিনটি অভিব্যক্তিকে ক্রমানুসারে গ্রহণ করে এবং সেমিকোলন দ্বারা পৃথক করে:

1. লুপ শুরু হলে মূল্যায়ন করা একটি অভিব্যক্তি
2. একটি শর্ত যা লুপ চালিয়ে যেতে হবে কিনা তা নির্ধারণ করে
3. প্রতিটি লুপের উপসংহারে একটি এক্সপ্রেশন কার্যকর করা হবে

এই বন্ধনীর পরে, লুপের সময় সম্পাদিত বিবৃতি (সাধারণত একটি ব্লক বিবৃতি ) যোগ করুন।

for( let i = 0; i < 3; i++ ) {
  console.log( "This loop will run three times.")
}

প্রথম অভিব্যক্তিটি একটি ভেরিয়েবল শুরু করে যা একটি কাউন্টার হিসাবে কাজ করে। এই অভিব্যক্তিটি একবার মূল্যায়ন করা হয়, লুপের প্রথম পুনরাবৃত্তির আগে। আপনি অন্যান্য ভেরিয়েবলের মত let (বা var , ঐতিহাসিকভাবে) ব্যবহার করে এই ভেরিয়েবলটিকে আরম্ভ করতে পারেন এবং এর সুযোগ হল লুপের বডি। এই ভেরিয়েবলের যেকোন বৈধ শনাক্তকারী থাকতে পারে, কিন্তু এগুলিকে প্রায়ই "পুনরাবৃত্তি" বা "সূচী" এর জন্য i বলা হয়। এটি অনুমানযোগ্য শনাক্তকারী নামের জন্য প্রতিষ্ঠিত সর্বোত্তম-অভ্যাসের বিরোধিতা বলে মনে হয়, তবে কনভেনশনটি এক নজরে অন্যান্য বিকাশকারীদের কাছে পরিষ্কার হওয়ার জন্য যথেষ্ট প্রতিষ্ঠিত। যেহেতু সূচীকৃত সংগ্রহগুলি শূন্য সূচীযুক্ত , এই ভেরিয়েবলগুলির প্রায় সর্বদা প্রাথমিক মান 0 থাকে।

লুপের অন্যান্য রূপগুলির মতো, শর্ত হল একটি অভিব্যক্তি যা লুপটি কার্যকর করা উচিত কিনা তা নির্ধারণ করে। এটি প্রায়শই পুনরাবৃত্তি কাউন্টারের জন্য একটি উপরের সীমা সেট করতে ব্যবহৃত হয়। দোভাষী প্রথমবারের জন্য for চালানোর আগে শর্তটি মূল্যায়ন করে৷ যদি শর্তটি প্রাথমিকভাবে true মূল্যায়ন না করে, তাহলে লুপের বডিটি কার্যকর করা হয় না৷

লুপের মাধ্যমে প্রতিটি পুনরাবৃত্তির শেষে চূড়ান্ত এক্সপ্রেশনটি কার্যকর করা হয়। এটি সাধারণত শনাক্তকারীকে এক দ্বারা বৃদ্ধি করতে ব্যবহৃত হয়।

আপনি সাধারণত পুরানো কোডবেসে অ্যারেগুলির মাধ্যমে পুনরাবৃত্তি করা for দেখতে পাবেন। এই ক্ষেত্রে, লুপটি চালিয়ে যাওয়ার জন্য নির্দিষ্ট করা শর্তটি হল একটি পুনরাবৃত্তি গণনা যার মাধ্যমে পুনরাবৃত্তি করা অ্যারের দৈর্ঘ্যের চেয়ে কম বা সমান। বর্তমান পুনরাবৃত্তি গণনা ট্র্যাক করতে ব্যবহৃত ভেরিয়েবলটি অ্যারেতে সেই সূচকের সাথে সম্পর্কিত মানটি সন্ধান করতে ব্যবহৃত হয়, অ্যারের প্রতিটি উপাদানকে ক্রমানুসারে কাজ করার অনুমতি দেয়:

var myArray = [ true, false, true ];
for( let i = 0; i <= myArray.length; i++ ) {
  console.log( myArray[ i ] );
}
> true
> false
> true

পুনরাবৃত্তিযোগ্য ডেটা স্ট্রাকচারের মাধ্যমে লুপ করার জন্য আরও আধুনিক পদ্ধতির পক্ষে এই পদ্ধতিটি ব্যবহারের বাইরে পড়ে গেছে।

of for […]

একটি পুনরাবৃত্ত ডেটা স্ট্রাকচার , যেমন একটি অ্যারে, সেট বা মানচিত্রের মধ্যে সংরক্ষিত মানগুলির উপর পুনরাবৃত্তি করার জন্য … for … লুপগুলি ব্যবহার করুন of

A for … of … লুপ ব্যবহার করে for কীওয়ার্ড এর পরে একটি ভেরিয়েবল সম্বলিত বন্ধনীর সেট, এর পরে of পরে ডেটা স্ট্রাকচারটি পুনরাবৃত্তি করা হচ্ছে। ভেরিয়েবলটি এখানে let , const , বা var ব্যবহার করে সম্পাদিত একটি ঘোষণা হতে পারে, একটি ভেরিয়েবল যা পূর্বে বর্তমান সুযোগের মধ্যে ঘোষণা করা হয়েছে, একটি অবজেক্ট প্রপার্টি, বা ডিস্ট্রাকচারিং অ্যাসাইনমেন্টের একটি উদাহরণ। এটিতে উপাদানটির মান রয়েছে যা লুপের বর্তমান পুনরাবৃত্তির সাথে সামঞ্জস্যপূর্ণ।

const myIterable = [ true, false, true ];
for( const myElement of myIterable ) {
  console.log( myElement );
}
> true
> false
> true

এই উদাহরণে, myElement এর জন্য const ব্যবহার করা কাজ করে যদিও myElement লুপের প্রতিটি পুনরাবৃত্তিতে একটি নতুন মান দেওয়া হয়। এর কারণ হল let বা const দিয়ে ঘোষিত ভেরিয়েবলগুলি লুপের মধ্যে ব্লক স্টেটমেন্টে স্কোপ করা হয়েছে। ভেরিয়েবলটি প্রতিটি পুনরাবৃত্তির শুরুতে শুরু করা হয় এবং সেই পুনরাবৃত্তির শেষে সরানো হয়।

for … in …

গননাযোগ্য উত্তরাধিকারসূত্রে প্রাপ্ত বৈশিষ্ট্য সহ একটি অবজেক্টের গণনাযোগ্য বৈশিষ্ট্যগুলির উপর পুনরাবৃত্তি করার for … in … লুপ ব্যবহার করুন। যেমন a for … of … loop, a for … in … loop ব্যবহার করে for keyword এর পরে একটি ভেরিয়েবল সম্বলিত বন্ধনীর সেট যা লুপের বর্তমান পুনরাবৃত্তির সাথে সম্পর্কিত প্রপার্টি কী-এর মান ধারণ করে। এই ভেরিয়েবলটি in কীওয়ার্ড দ্বারা অনুসরণ করা হয়, তারপরে বস্তুটি পুনরাবৃত্তি করা হচ্ছে:

const myObject = { "myProperty" : true, "mySecondProperty" : false };
for( const myKey in myObject ) {
  console.log( myKey );
}
> "myProperty"
> "mySecondProperty"

আবার, লুপের প্রতিটি পুনরাবৃত্তির সাথে myKey এর মান পরিবর্তন হওয়া সত্ত্বেও, আপনি ত্রুটি ছাড়াই const ব্যবহার করতে পারেন কারণ প্রতিটি পুনরাবৃত্তির শেষে ভেরিয়েবলটি কার্যকরভাবে বাতিল করা হয়, তারপর শুরুতে পুনরায় তৈরি করা হয়।

প্রতিটি প্রপার্টি কী এর সাথে যুক্ত মান সরাসরি … in … সিনট্যাক্সের for উপলব্ধ নয়। যাইহোক, যেহেতু লুপের প্রতিটি পুনরাবৃত্তিতে একটি প্রপার্টি কী অ্যাক্সেস আছে, আপনি সেই কীটি ব্যবহার করতে পারেন তার মান "লুক আপ" করতে:

const myObject = { "myProperty" : true, "mySecondProperty" : false };
for( const myKey in myObject ) {
  const myValue = myObject[ myKey ];
  console.log( `${ myKey } : ${ myValue }` );
}
> "myProperty : true"
> "mySecondProperty : false"

অন্তর্নির্মিত কনস্ট্রাক্টর থেকে উত্তরাধিকারসূত্রে প্রাপ্ত বৈশিষ্ট্যগুলি অ-গণনাযোগ্য, যার অর্থ for … in … Object কনস্ট্রাক্টর থেকে উত্তরাধিকারসূত্রে প্রাপ্ত বৈশিষ্ট্যগুলির মাধ্যমে পুনরাবৃত্তি হয় না। যাইহোক, বস্তুর প্রোটোটাইপ চেইনের মধ্যে যে কোনো গণনাযোগ্য বৈশিষ্ট্য অন্তর্ভুক্ত করা হয়েছে:

const myPrototype = { "protoProperty" : true };
const myObject = Object.create( myPrototype, {
    myProperty: {
    value: true,
    enumerable: true
    }
});
for ( const myKey in myObject ) {
  const myValue = myObject[ myKey ];
  console.log( `${ myKey } : ${ myValue }` );
}
> "myProperty : true"
> "protoProperty : true"

জাভাস্ক্রিপ্ট বস্তুর প্রোটোটাইপ চেইনের একটি সম্পত্তির পরিবর্তে বস্তুর সরাসরি সম্পত্তি কিনা তা নির্ধারণের জন্য অন্তর্নির্মিত পদ্ধতি প্রদান করে: আধুনিক Object.hasOwn() এবং উত্তরাধিকার Object.prototype.hasOwnProperty() পদ্ধতি। এই পদ্ধতিগুলি একটি নির্দিষ্ট সম্পত্তি উত্তরাধিকার সূত্রে প্রাপ্ত (বা অঘোষিত) কিনা তা মূল্যায়ন করে, শুধুমাত্র একটি নির্দিষ্ট বস্তুর তাত্ক্ষণিক বৈশিষ্ট্যের জন্য true ফিরে আসে:

const myPrototype = { "protoProperty" : true };
const myObject = Object.create( myPrototype, {
    myProperty: {
    value: true,
    enumerable: true
    }
});
for ( const myKey in myObject ) {
  const myValue = myObject[ myKey ];
  if ( Object.hasOwn( myObject, myKey ) ) {
    console.log( `${ myKey } : ${ myValue }` );
  }
}
> "myProperty : true"

এছাড়াও তিনটি স্ট্যাটিক পদ্ধতি রয়েছে যেগুলির প্রত্যেকটি একটি অবজেক্টের গণনাযোগ্য কী ( Object.keys() ), মান ( Object.values() ), বা কী-মান জোড়া ( Object.entries() দ্বারা গঠিত একটি অ্যারে প্রদান করে :

const myObject = { "myProperty" : true, "mySecondProperty" : false };
Object.keys( myObject );
> Array [ "myProperty", "mySecondProperty" ]

এটি আপনাকে অবজেক্টের প্রোটোটাইপের মালিকানাধীন বৈশিষ্ট্যগুলি অন্তর্ভুক্ত না করেই অবজেক্ট কী, মান বা কী-মানের জোড়া ( ডিস্ট্রাকচারিং অ্যাসাইনমেন্ট ব্যবহার করে) পুনরাবৃত্তি করতে দেয়:

const myPrototype = { "protoProperty" : "Non-enumerable property value." };
const myObject = Object.create( myPrototype, {
    myProperty: {
    value: "Enumerable property value.",
    enumerable: true
    }
});

for ( const propKey of Object.keys( myObject ) ) {
  console.log( propKey );
}
> "myProperty"

for ( const propValue of Object.values( myObject ) ) {
  console.log( propValue );
}
> "Enumerable property value."

for ( const [ propKey, propValue ] of Object.entries( myObject ) ) {
  console.log( `${ propKey } : ${ propValue }` );
}
> "myProperty : Enumerable property value."

forEach()

অ্যারে , ম্যাপ , সেট এবং নোডলিস্ট কনস্ট্রাক্টরদের দ্বারা প্রদত্ত forEach() পদ্ধতিগুলি একটি কলব্যাক ফাংশনের প্রেক্ষাপটে একটি ডেটা কাঠামোর উপর পুনরাবৃত্তি করার জন্য একটি দরকারী শর্টহ্যান্ড প্রদান করে। লুপের অন্যান্য রূপের বিপরীতে, যেকোনো forEach() পদ্ধতির সাহায্যে তৈরি একটি লুপ break বা continue ব্যবহার করে বাধা দেওয়া যাবে না।

forEach হল একটি পদ্ধতি যা প্রতিটি ডেটা স্ট্রাকচারের প্রোটোটাইপের মালিকানাধীন। প্রতিটি forEach পদ্ধতি একটি আর্গুমেন্ট হিসাবে একটি কলব্যাক ফাংশন আশা করে, যদিও সেই ফাংশনটি কল করার সময় অন্তর্ভুক্ত আর্গুমেন্টগুলির পরিপ্রেক্ষিতে তারা সামান্য পরিবর্তিত হয়। একটি দ্বিতীয়, ঐচ্ছিক যুক্তি কলব্যাক ফাংশনের জন্য আহ্বানকারী প্রসঙ্গ হিসাবে ব্যবহার করার জন্য this মানটিকে নির্দিষ্ট করে।

Array.forEach এর সাথে ব্যবহৃত কলব্যাক ফাংশনটি বর্তমান উপাদানের মান, বর্তমান উপাদানের সূচী এবং forEach পদ্ধতিতে যে বিন্যাসটি চালু করা হয়েছিল তার মধ্যে প্যারামিটার প্রদান করে:

const myArray = [ true, false ];
myArray.forEach( ( myElement, i, originalArray ) => {
  console.log( i, myElement, originalArray  );
});
> 0 true Array(3) [ true, false ]
> 1 false Array(3) [ true, false ]

Map.forEach এর সাথে ব্যবহৃত কলব্যাক ফাংশনটি বর্তমান উপাদানের সাথে যুক্ত মান, বর্তমান উপাদানের সাথে যুক্ত কী, এবং Map the forEach পদ্ধতিতে যে মানটি ব্যবহার করা হয়েছিল তা প্রদান করে:

const myMap = new Map([
  ['myKey', true],
  ['mySecondKey', false ],
]);
myMap.forEach( ( myValue, myKey, originalMap ) => {
    console.log( myValue, myKey, originalMap  );
});
> true "myKey" Map { myKey → true, mySecondKey → false }
> false "mySecondKey" Map { myKey → true, mySecondKey → false }

একটি Set.forEach কলব্যাকের অনুরূপ পরামিতি অন্তর্ভুক্ত। যেহেতু Set-এ মান থেকে আলাদা কোনো সূচী বা কী নেই, তাই দ্বিতীয় যুক্তিটি পরিবর্তে একটি অপ্রয়োজনীয়, উপেক্ষাযোগ্য মান প্রদান করে, কঠোরভাবে সিনট্যাক্সটিকে অন্যান্য forEach পদ্ধতির সাথে সামঞ্জস্যপূর্ণ রাখতে।

const mySet = new Set([ true, false ]);
mySet.forEach( ( myValue, myKey, originalSet ) => {
  console.log( myValue, myKey, originalSet  );
});
> true true Set [ true, false ]
> false false Set [ true, false ]

পুনরাবৃত্তিকারী

একটি পুনরাবৃত্তিযোগ্য হল পৃথক উপাদান দ্বারা গঠিত যে কোনও ডেটা কাঠামো যা পূর্বে বিস্তারিত পদ্ধতিগুলি ব্যবহার করে পুনরাবৃত্তি করা যেতে পারে। একটি পুনরাবৃত্ত হল একটি পুনরাবৃত্তিযোগ্য বস্তু যা ইটারেটর প্রোটোকল অনুসরণ করে, যার মানে এটিকে অবশ্যই একটি next() পদ্ধতি প্রয়োগ করতে হবে যা এটিতে একটি সময়ে একটি উপাদানের মাধ্যমে অগ্রসর হয়, প্রতিবার যখন সেই পদ্ধতিটি কল করা হয়, একটি নির্দিষ্টভাবে প্রতিটি অনুক্রমিক উপাদানের জন্য একটি বস্তু ফেরত দেয়। বিন্যাস

জাভাস্ক্রিপ্টের অন্তর্নির্মিত পুনরাবৃত্তিযোগ্য ডেটা স্ট্রাকচারগুলি (যেমন অ্যারে , মানচিত্র এবং সেট ) নিজেদের মধ্যে পুনরাবৃত্তিকারী নয়, তবে তারা সকলেই একটি iterator পদ্ধতির উত্তরাধিকারী, @@iterator সুপরিচিত প্রতীক ব্যবহার করে অ্যাক্সেসযোগ্য, যা একটি পুনরাবৃত্তিকারী প্রদান করে। পুনরাবৃত্তিযোগ্য ডেটা কাঠামো থেকে তৈরি বস্তু:

const myIterable = [ 1, 2, 3 ];
const myIterator = myIterable[ Symbol.iterator ]();

myIterable;
> (3) [1, 2, 3]

myIterator;
> Array Iterator {}

একটি পুনরাবৃত্তের next() পদ্ধতিতে কল করা উপাদানগুলির মাধ্যমে ধাপে ধাপে এটিতে একটি সময়ে একটি রয়েছে, প্রতিটি কলে দুটি বৈশিষ্ট্য সম্বলিত একটি বস্তু ফিরে আসে: value , যার মধ্যে বর্তমান উপাদানটির মান রয়েছে এবং done , একটি বুলিয়ান যা আমাদের বলে যদি পুনরাবৃত্তিকারী ডেটা কাঠামোর শেষ উপাদানটি পাস করেছে। done মানটি তখনই true হয় যখন next() এ একটি কলের ফলে পুনরাবৃত্তিকারীর শেষ উপাদানের বাইরে একটি উপাদান অ্যাক্সেস করার চেষ্টা করা হয়।

const myIterable = [ 1, 2, 3 ];
const myIterator = myIterable[ Symbol.iterator ]();

myIterator.next();
> Object { value: 1, done: false }

myIterator.next();
> Object { value: 2, done: false }

myIterator.next();
> Object { value: 3, done: false }

myIterator.next();
> Object { value: undefined, done: true }

জেনারেটরের কার্যাবলী

একটি জেনারেটর ফাংশন ঘোষণা করতে বা একটি জেনারেটর ফাংশন এক্সপ্রেশন সংজ্ঞায়িত করতে function* কীওয়ার্ড (তারকাটি নোট করুন) ব্যবহার করুন:

function* myGeneratorFunction() { };

পুনরাবৃত্তির মত, জেনারেটর ফাংশন অবস্থা বজায় রাখে। একটি জেনারেটর ফাংশন কল করা একটি নতুন জেনারেটর অবজেক্ট প্রদান করে কিন্তু ফাংশনের মূল অংশে কোডটি অবিলম্বে কার্যকর করে না:

function* myGeneratorFunction() {
  console.log( "Generator function body ")
};
const myGeneratorObject = myGeneratorFunction();

myGeneratorObject;
> Generator {  }

typeof myGeneratorObject;
> "object"

জেনারেটর অবজেক্ট ইটারেটর প্রোটোকল অনুসরণ করে। একটি জেনারেটর ফাংশনে প্রতিটি কল next() রিটার্নের মান একটি yield এক্সপ্রেশন দ্বারা নির্ধারিত হয়, যা জেনারেটর ফাংশন এক্সিকিউশনকে বিরতি দেয় এবং yield কীওয়ার্ড ধারণ করে এক্সপ্রেশনের মান প্রদান করে। পরবর্তীতে next() এ কল করা হলে ফাংশনের এক্সিকিউশন চালিয়ে যায়, পরবর্তী yield এক্সপ্রেশনে বিরতি দেয় এবং সংশ্লিষ্ট মান ফেরত দেয়।

function* myGeneratorFunction() {
  yield "My first yielded value.";
  yield "My second yielded value.";
};
const myGeneratorObject = myGeneratorFunction();

myGeneratorObject.next();
> Object { value: "My first yielded value.", done: false }

myGeneratorObject.next();
> Object { value: "My second yielded value.", done: false }

yield , return , or throw (একটি ত্রুটির ক্ষেত্রে) ব্যবহার করে আর কোন মান নির্দিষ্ট না করার পরে next() কল করা হলে, ফাংশনের বডির অবশিষ্টাংশ কার্যকর হয়, এবং প্রত্যাবর্তিত অবজেক্টের একটি value থাকে undefined এবং একটি done সম্পত্তি true :

function* myGeneratorFunction() {
    console.log( "Start of the generator function." );
    yield "First";
    console.log( "Second part of the generator function."  );
    yield "Second";
    console.log( "Third part of the generator function." );
    yield "Third";
};
const myGeneratorObject = myGeneratorFunction();

myGeneratorObject.next();
> "Start of the generator function."
> Object { value: "First", done: false }

myGeneratorObject.next();
> "Second part of the generator function."
> Object { value: "Second", done: false }

myGeneratorObject.next();
> "Third part of the generator function."
> Object { value: "Third", done: false }

myGeneratorObject.next();
> Object { value: undefined, done: true }

next() ব্যবহার করুন শুধুমাত্র অবজেক্টে জেনারেটর ফাংশনটি রিটার্ন করে, জেনারেটর ফাংশনটি নয়। অন্যথায়, জেনারেটর ফাংশনে প্রতিটি কল একটি নতুন জেনারেটর অবজেক্ট তৈরি করে:

function* myGeneratorFunction() {
  yield "First";
  yield "Second";
};

myGeneratorFunction().next();
> Object { value: "First", done: false }

myGeneratorFunction().next();
> Object { value: "First", done: false }

যেকোনো ফাংশনের মতো, জেনারেটর ফাংশনটি যখন return কীওয়ার্ডের মুখোমুখি হয় তখন এটি বন্ধ হয়ে যায়। এটি তখন একটি অবজেক্টকে আহ্বানকারী প্রসঙ্গে ফেরত দেয় যাতে প্রত্যাবর্তিত মান এবং মান true সহ একটি done সম্পত্তি রয়েছে।

function* myGeneratorFunction() {
  yield 1;
  yield 2;
  return 3;
};
const myGeneratorObject = myGeneratorFunction();

myGeneratorObject.next().done;
> Object { value: 1, done: false }

myGeneratorObject.next().done;
> Object { value: 2, done: false }

myGeneratorObject.next();
> Object { value: 3, done: true }

একটি yield অভিব্যক্তি একটি শনাক্তকারীর কিছু শব্দার্থকে গ্রহণ করতে পারে, যা জেনারেটর ফাংশনের স্থগিত অংশ থেকে এবং পিছনে দ্বিমুখী "যোগাযোগ" করার অনুমতি দেয়। যখন একটি মান একটি জেনারেটরের next() পদ্ধতিতে একটি আর্গুমেন্ট হিসাবে প্রেরণ করা হয়, এটি পূর্ববর্তী, স্থগিত yield অভিব্যক্তির সাথে যুক্ত মানটিকে প্রতিস্থাপন করে:

function* myGeneratorFunction() {
    const firstYield = yield;
    yield firstYield + 10;
};
const myGeneratorObject = myGeneratorFunction();

myGeneratorObject.next();
> Object { value: undefined, done: false }

myGeneratorObject.next( 5 );
> Object { value: 15, done: false }

মনে রাখবেন যে এটি পূর্ববর্তী yield সাথে যুক্ত সম্পূর্ণ অভিব্যক্তিকে প্রতিস্থাপন করে এবং শুধুমাত্র next() এ উল্লিখিত মানের সাথে পূর্ববর্তী yield মান পুনরায় নির্ধারণ করে না :

function* myGeneratorFunction() {
    const firstYield = yield;
    const secondYield = yield firstYield + 100;
    yield secondYield + 10;
};
const myGeneratorObject = myGeneratorFunction();

myGeneratorObject.next();
> Object { value: undefined, done: false }

myGeneratorObject.next( 10 ); // Can be thought of as changing the value of the `firstYield` variable to `10
> Object { value: 110, done: false }

myGeneratorObject.next( 20 ); // Can be thought of as changing the value of the `secondYield` variable to `20`, _not_ `20 + 100;`
> Object { value: 30, done: false }

next() এ প্রথম কলে পাস করা যেকোনো আর্গুমেন্ট উপেক্ষা করা হয়, কারণ সেই মানটি গ্রহণ করার জন্য কোনো পূর্বের yield এক্সপ্রেশন নেই। অন্য যেকোন ফাংশনের মতো, প্রাথমিক জেনারেটর ফাংশন কলে পাস করা আর্গুমেন্টগুলি জেনারেটর ফাংশনের বডির সমস্ত স্কোপ জুড়ে পাওয়া যায়:

function* myGeneratorFunction( startingValue ) {
    let newValue = yield startingValue + 1;
    newValue = yield newValue + 10;
    yield startingValue + 20;
};
const myGeneratorObject = myGeneratorFunction( 2 );

myGeneratorObject.next( 1 );
> Object { value: 3, done: false }

myGeneratorObject.next( 5 );
> Object { value: 15, done: false }

myGeneratorObject.next( 10 );
Object { value: 22, done: false }

yield* (তারকাটি দ্রষ্টব্য) অপারেটরটি পুনরাবৃত্তিযোগ্য, যেমন অন্য জেনারেটর ফাংশনের সাথে ব্যবহার করা হয়, প্রতিটি মানের অপারেন্ড রিটার্ন করার জন্য পুনরাবৃত্তি করতে এবং ফল দেয়:

function* mySecondaryGenerator() {
  yield 2;
  yield 3;
}

function* myGenerator() {
  yield 1;
  yield* mySecondaryGenerator();
  yield 4;
  return 5;
}

const myIterator = myGenerator();

myIterator.next();
> Object { value: 1, done: false }

myIterator.next();
> Object { value: 2, done: false }

myIterator.next();
> Object { value: 3, done: false }

myIterator.next();
> Object { value: 4, done: false }

myIterator.next();
> Object { value: 5, done: true }

অ্যাসিঙ্ক্রোনাস জাভাস্ক্রিপ্ট

যদিও জাভাস্ক্রিপ্ট কার্যকর করার ক্ষেত্রে মৌলিকভাবে সিঙ্ক্রোনাস , সেখানে এমন ব্যবস্থা রয়েছে যা ডেভেলপারদের অ্যাসিঙ্ক্রোনাস কাজগুলি সম্পাদন করতে ইভেন্ট লুপের সুবিধা নিতে দেয়।

প্রতিশ্রুতি

একটি প্রতিশ্রুতি এমন একটি মানের জন্য একটি স্থানধারক যা প্রতিশ্রুতি তৈরি করার সময় জানা যায় না। এটি এমন একটি ধারক যা একটি অ্যাসিঙ্ক্রোনাস অপারেশন নির্দেশ করে, যে শর্তগুলির দ্বারা অপারেশনটিকে সফল বা ব্যর্থতা হিসাবে বিবেচনা করা হয়, উভয় ক্ষেত্রেই গৃহীত পদক্ষেপগুলি এবং ফলাফলের মান।

বিল্ট-ইন Promise কনস্ট্রাক্টর ফাংশন সহ new অপারেটর ব্যবহার করে একটি প্রতিশ্রুতি উদাহরণ তৈরি করুন। এই কনস্ট্রাক্টর একটি আর্গুমেন্ট হিসাবে নির্বাহক নামক একটি ফাংশন গ্রহণ করে। সেই নির্বাহক ফাংশনটি সাধারণত এক বা একাধিক অ্যাসিঙ্ক্রোনাস ক্রিয়া সম্পাদন করতে ব্যবহৃত হয়, তারপর সেই শর্তগুলি নির্দেশ করে যার দ্বারা প্রতিশ্রুতি সফলভাবে পূর্ণ বা প্রত্যাখ্যান করা উচিত বলে বিবেচিত হয়। এক্সিকিউটর ফাংশন চলাকালীন একটি প্রতিশ্রুতি মুলতুবি হিসাবে সংজ্ঞায়িত করা হয়। নির্বাহক শেষ হওয়ার পরে, একটি প্রতিশ্রুতি পূর্ণ বলে বিবেচিত হয় (বা সমাধান করা হয় , ডকুমেন্টেশনের কিছু উত্সে) যদি নির্বাহক ফাংশন এবং এটি সঞ্চালিত অ্যাসিঙ্ক্রোনাস অ্যাকশন সফলভাবে সম্পন্ন হয়, এবং প্রত্যাখ্যান করা হয় যদি নির্বাহক ফাংশন একটি ত্রুটির সম্মুখীন হয়, বা সঞ্চালিত অ্যাসিঙ্ক্রোনাস অ্যাকশন ব্যর্থ হয় . একটি প্রতিশ্রুতি পূর্ণ বা প্রত্যাখ্যান করার পরে, এটি নিষ্পত্তি বলে বিবেচিত হয়।

const myPromise = new Promise( () => { });

কনস্ট্রাক্টর দুটি আর্গুমেন্ট সহ এক্সিকিউটর ফাংশনকে কল করে। এই আর্গুমেন্টগুলি এমন ফাংশন যা আপনাকে ম্যানুয়ালি প্রতিশ্রুতি পূরণ বা প্রত্যাখ্যান করতে দেয়:

const  myPromise = new Promise( ( fulfill, reject ) => { });

একটি প্রতিশ্রুতি পূরণ বা প্রত্যাখ্যান করার জন্য ব্যবহৃত ফাংশনগুলিকে একটি যুক্তি হিসাবে প্রতিশ্রুতির ফলের মান দিয়ে বলা হয় (সাধারণত প্রত্যাখ্যানের জন্য একটি ত্রুটি):

const myPromise = new Promise( ( fulfill, reject ) => {
  const myResult = true;
  setTimeout(() => {
    if( myResult === true ) {
        fulfill( "This Promise was successful." );    
    } else {
        reject( new Error( "This Promise has been rejected." ) );
    }
  }, 10000);
});

myPromise;
> Promise { <state>: "pending" }

myPromise;
> Promise { <state>: "fulfilled", <value>: "This Promise was successful." }

প্রমিজ চেইনিং

প্রমিস কনস্ট্রাক্টরের কাছ থেকে উত্তরাধিকারসূত্রে প্রাপ্ত then() , catch() এবং finally() পদ্ধতি ব্যবহার করে ফলস্বরূপ প্রতিশ্রুতি বস্তুটি কাজ করা যেতে পারে। এই পদ্ধতিগুলির প্রত্যেকটি একটি প্রতিশ্রুতি প্রদান করে, যা অবিলম্বে then() , catch() , বা finally() দিয়ে আবার কাজ করা যেতে পারে, আপনাকে ফলাফলের প্রতিশ্রুতিগুলিকে চেইন করতে দেয়।

then() আর্গুমেন্ট হিসাবে দুটি কলব্যাক ফাংশন প্রদান করে। ফলস্বরূপ প্রতিশ্রুতি পূরণ করতে প্রথমটি ব্যবহার করুন এবং দ্বিতীয়টি প্রত্যাখ্যান করুন। উভয় পদ্ধতি একটি একক যুক্তি গ্রহণ করে যা ফলস্বরূপ প্রতিশ্রুতিকে তার মূল্য দেয়।

const myPromise = new Promise( ( fulfill, reject ) => {
  const myResult = true;
  setTimeout(() => {
    if( myResult === true ) {
        fulfill( "This Promise was fulfilled." );    
    } else {
        reject( new Error( "This Promise has been rejected." ) );
    }
  }, 100);
});

myPromise.then( successfulResult => console.log( successfulResult ), failedResult => console.error( failedResult ) );
> "This Promise was successful."

আপনি then() ব্যবহার করতে পারেন শুধুমাত্র পরিপূর্ণ অবস্থা পরিচালনা করতে, এবং প্রত্যাখ্যাত অবস্থা পরিচালনা করতে catch । প্রতিশ্রুতি প্রত্যাখ্যান পদ্ধতিতে প্রদত্ত মান ধারণকারী একটি একক যুক্তি সহ কল catch :

const myPromise = new Promise( ( fulfill, reject ) => {
  const myResult = false;
  setTimeout(() => {
    if( myResult === true ) {
        fulfill( "This Promise was fulfilled." );    
    } else {
        reject( new Error( "This Promise has been rejected." ) );
    }
  }, 100);
});

myPromise
  .then( fulfilledResult => console.log(fulfilledResult ) )
  .catch( rejectedResult => console.log( rejectedResult ) )
  .finally( () => console.log( "The Promise has settled." ) );
> "Error: This Promise has been rejected."
> "The Promise has settled."

then এবং catch বিপরীতে, যা একটি প্রতিশ্রুতি পূর্ণ বা প্রত্যাখ্যান করার সময় একটি হ্যান্ডলার ফাংশন চালানোর অনুমতি দেয়, প্রতিশ্রুতি পূরণ বা প্রত্যাখ্যান করা নির্বিশেষে finally পদ্ধতিতে একটি যুক্তি হিসাবে পাস করা একটি ফাংশন বলা হয়। হ্যান্ডলার ফাংশনকে কোন আর্গুমেন্ট ছাড়াই বলা হয়, কারণ এটি প্রতিশ্রুতি থেকে পাস করা মানগুলির সাথে কাজ করার উদ্দেশ্যে নয়, শুধুমাত্র প্রতিশ্রুতি সম্পূর্ণ হওয়ার পরে কোড চালানোর জন্য।

সঙ্গতি

প্রতিশ্রুতি কনস্ট্রাক্টর একাধিক সম্পর্কিত প্রতিশ্রুতির সাথে কাজ করার জন্য চারটি পদ্ধতি প্রদান করে, একটি পুনরাবৃত্তিযোগ্য প্রতিশ্রুতিযুক্ত বস্তু ব্যবহার করে। এই পদ্ধতিগুলি প্রতিটি একটি প্রতিশ্রুতি প্রদান করে, যা এটিকে দেওয়া প্রতিশ্রুতির অবস্থার উপর ভিত্তি করে পূর্ণ বা প্রত্যাখ্যান করা হয়। Promise.all() , উদাহরণস্বরূপ, একটি প্রতিশ্রুতি তৈরি করে যা শুধুমাত্র সেই পদ্ধতিতে পাস করা প্রতিটি প্রতিশ্রুতি পূর্ণ হলেই পূর্ণ হয়:

const firstPromise  = new Promise( ( fulfill, reject ) => fulfill( "Successful. ") );
const secondPromise = new Promise( ( fulfill, reject ) => fulfill( "Successful. ") );
const thirdPromise  = new Promise( ( fulfill, reject ) => fulfill( "Successful. ") );
const failedPromise = new Promise( ( fulfill, reject ) => reject( "Failed.") );
const successfulPromises = [ firstPromise, secondPromise, thirdPromise ];
const oneFailedPromise = [ failedPromise, ...successfulPromises ];

Promise.all( successfulPromises )
  .then( ( allValues ) => {
    console.log( allValues );
  })
  .catch( ( failValue ) => {
    console.error( failValue );
  });
> Array(3) [ "Successful. ", "Successful. ", "Successful. " ]

Promise.all( oneFailedPromise  )
    .then( ( allValues ) => {
      console.log( allValues );
    })
    .catch( ( failValue ) => {
     console.error( failValue );
    });
> "Failed."

প্রতিশ্রুতি সহযোগি পদ্ধতিগুলি নিম্নরূপ:

Promise.all()

সমস্ত সরবরাহ করা প্রতিশ্রুতি পূর্ণ হলেই পূরণ করা হয়।

Promise.any()

সরবরাহকৃত প্রতিশ্রুতিগুলির মধ্যে যেকোন একটি পূরণ করা হলে তা পূরণ করা হয় এবং সমস্ত প্রতিশ্রুতি প্রত্যাখ্যান করা হলেই তা প্রত্যাখ্যান করা হয়।

Promise.allSettled()

প্রতিশ্রুতি স্থির হয়ে গেলে পূর্ণ হয়, তাদের ফলাফল নির্বিশেষে।

Promise.race()

মীমাংসা করার প্রথম প্রতিশ্রুতির ফলাফলের উপর ভিত্তি করে প্রত্যাখ্যান বা পূর্ণ করা, পরবর্তীতে নিষ্পত্তি হওয়া সমস্ত প্রতিশ্রুতি উপেক্ষা করে।

async / await

যখন আপনি একটি ফাংশন ঘোষণা বা ফাংশন এক্সপ্রেশনের আগে async কীওয়ার্ড ব্যবহার করেন, যে কোনো মান যে ফাংশনটি ফেরত দেয় তা সেই মান ধারণকারী একটি পূর্ণ প্রতিশ্রুতি হিসাবে ফেরত দেওয়া হয়। এটি আপনাকে সিঙ্ক্রোনাস ডেভেলপমেন্টের মতো একই ওয়ার্কফ্লো ব্যবহার করে অ্যাসিঙ্ক্রোনাস অপারেশন চালাতে এবং পরিচালনা করতে দেয়।

async function myFunction() {
  return "This is my returned value.";
}

myFunction().then( myReturnedValue => console.log( myReturnedValue ) );
> "This is my returned value."

await এক্সপ্রেশনটি একটি অ্যাসিঙ্ক্রোনাস ফাংশনের সম্পাদনে বিরতি দেয় যখন সংশ্লিষ্ট প্রতিশ্রুতি নিষ্পত্তি হয়। প্রতিশ্রুতি নিষ্পত্তি হওয়ার পরে, await অভিব্যক্তির মান হল প্রতিশ্রুতির পূর্ণ বা প্রত্যাখ্যান করা মান।

async function myFunction() {
  const myPromise  = new Promise( ( fulfill, reject ) => { setTimeout( () => fulfill( "Successful. "), 5000 ); });
  const myPromisedResult = await myPromise;
  return myPromisedResult;
}

myFunction()
  .then( myResult => console.log( myResult ) )
  .catch( myFailedResult => console.error( myFailedResult ) );
> "Successful."

await অভিব্যক্তিতে অন্তর্ভুক্ত যেকোনো অ-প্রতিশ্রুতি মান একটি পূর্ণ প্রতিশ্রুতি হিসাবে ফেরত দেওয়া হয়:

async function myFunction() {
  const myPromisedResult = await "String value.";
  return myPromisedResult;
}

myFunction()
  .then( myResult => console.log( myResult ) )
  .catch( myFailedResult => console.error( myFailedResult ) );
> "String value."

আপনার উপলব্ধি পরীক্ষা করুন

কোন ধরনের লুপ আপনি একটি পরিচিত পরিমাণের উপর পুনরাবৃত্তি করতে ব্যবহার করেন?

for

while

do...while