ஜாவாஸ்கிரிப்டில்

Arthur Petit

வியாழன், 10 அக்டோபர், 2024 ’அன்று’ முற்பகல் 8:13:38

ஜாவாஸ்கிரிப்ட் ஒத்திசைவு/நேரத்தில் நடத்தைக்காக காத்திருக்கிறது

நவீன ஜாவாஸ்கிரிப்ட் வளர்ச்சியில், ஒத்திசைவு/காத்திருங்கள் ஒத்திசைவற்ற குறியீட்டைக் கையாளுவதற்கு இன்றியமையாத கருவியாக மாறியுள்ளது. அதன் பயன் இருந்தபோதிலும், பல டெவலப்பர்கள் இந்த நுட்பங்களைப் பயன்படுத்தி செயல்பாடுகளில் வெளியீடுகளின் சரியான நேரத்தைக் கணிக்கும்போது குழப்பத்தை எதிர்கொள்கின்றனர். அடாஃபேஸ் போன்ற குறியீட்டு மதிப்பீடுகளில் இது குறிப்பாக உண்மையாகும், இதில் ஒத்திசைவற்ற செயல்பாடுகளின் ஓட்டத்தைப் புரிந்துகொள்வது முக்கியமானது.

நீங்கள் பணிபுரியும் பிரச்சனையானது ஒரே மாதிரியான நடத்தைகளுடன் இரண்டு ஒத்திசைவற்ற செயல்பாடுகளை வழங்குகிறது, ஆனால் நேரத்தின் அடிப்படையில் வேறுபட்ட விளைவுகளைக் கொண்டுள்ளது. முதல் பார்வையில், செயல்பாடுகள் இரண்டுக்கும் 10 வினாடிகள் ஆகலாம், ஆனால் உண்மையான பதில் பல டெவலப்பர்களை ஆச்சரியப்படுத்துகிறது, ஏனெனில் வாக்குறுதிகள் எவ்வாறு தீர்க்கப்படுகின்றன என்பதைப் பற்றிய ஆழமான புரிதலை உள்ளடக்கியது.

இந்தக் கட்டுரையானது குறியீட்டின் மூலம் உங்களை அழைத்துச் செல்வதை நோக்கமாகக் கொண்டுள்ளது, அது எப்படி என்பதை உடைக்கிறது ஒத்திசைவு மற்றும் காத்திருங்கள் இயக்கவியல் வேலை, அதே போல் வாக்குறுதி தீர்மானத்தின் வரிசை இறுதி முடிவை எவ்வாறு பாதிக்கிறது. இதன் முடிவில், ஒத்திசைவற்ற ஜாவாஸ்கிரிப்ட்டில் நேரம் எவ்வாறு செயல்படுகிறது என்பதைப் பற்றிய தெளிவான புரிதல் உங்களுக்கு இருக்க வேண்டும்.

முதல் செயல்பாடு ஏன் வெளிவருகிறது என்பதைப் புரிந்துகொள்ள குறியீட்டிற்குள் நுழைவோம் 24 5 வினாடிகளுக்குப் பிறகு, இரண்டாவது செயல்பாடும் வெளிவரும் 24 ஆனால் வேறு வாக்குறுதி அமைப்புடன். இந்த அறிவைக் கொண்டு, உங்களின் வரவிருக்கும் நேர்காணல் மதிப்பீடுகளுக்கு நீங்கள் சிறப்பாகத் தயாராக இருப்பீர்கள்.

கட்டளை	பயன்பாட்டின் உதாரணம்
நேரம் முடிந்தது	setTimeout(() =>setTimeout(() => {res(x);}, 5000); இந்த கட்டளை ஒரு குறிப்பிட்ட தாமதத்திற்கு பிறகு ஒரு செயல்பாட்டை செயல்படுத்துகிறது. இந்தச் சூழலில், 5 வினாடிகளுக்குப் பிறகு மதிப்பை வழங்குவதன் மூலம் ஒத்திசைவற்ற நடத்தையை உருவகப்படுத்த இது பயன்படுகிறது.
புதிய வாக்குறுதி	return new Promise(res =>புதிய உறுதிமொழியை (ரெஸ் => {...}); ஒத்திசைவற்ற குறியீட்டை மூடும் புதிய வாக்குறுதியை உருவாக்குகிறது, இது ஒத்திசைவு செயல்பாடு முடிந்ததும் மதிப்புகளைத் தீர்க்க அல்லது நிராகரிக்க அனுமதிக்கிறது.
காத்திருங்கள்	const f = காத்திருங்கள் after5s(3); வாக்குறுதி தீர்க்கப்படும் வரை ஒத்திசைவு செயல்பாடு செயல்படுத்தலை இடைநிறுத்துகிறது, இதனால் குறியீடு ஒத்திசைவற்ற செயல்பாட்டிற்குள் செயல்படும்
ஒத்திசைவு செயல்பாடு	async function mult(உள்ளீடு) {...} பயன்படுத்த அனுமதிக்கும் ஒத்திசைவற்ற செயல்பாட்டை அறிவிக்கிறது காத்திருங்கள் ஒத்திசைவற்ற செயல்பாடுகளை சுத்தமான மற்றும் படிக்கக்கூடிய வகையில் கையாள உள்ளே.
பிறகு	mult(2).then(value =>mult(2).பின் (மதிப்பு => {...}); ஒரு வாக்குறுதிக்கு திரும்ப அழைப்பை இணைக்கிறது. வாக்குறுதி தீர்க்கப்பட்டவுடன், திரும்பப் பெறுதல் தீர்க்கப்பட்ட மதிப்புடன் செயல்படுத்தப்படும்.
உறுதிமொழி ஒத்திசைவு	const f = after5s(3); const g = after5s(4); இது இரண்டு வாக்குறுதிகளை இணையாக இயக்க அனுமதிக்கிறது, ஒன்று மற்றொன்றைத் தொடங்குவதற்கு முன் தீர்க்கப்படும், இதனால் செயல்திறனை மேம்படுத்துகிறது.
console.log	console.log(மதிப்பு); பிழைத்திருத்தம் அல்லது முடிவு சரிபார்ப்பு நோக்கங்களுக்காக கன்சோலுக்கு மதிப்பை வெளியிடுகிறது.
ரெஸ்	ரெஸ்(x); என்பதற்கான சுருக்கெழுத்து தீர்க்க வாக்குறுதிகளில், வாக்குறுதி முடிந்ததாகக் குறிக்கவும் மதிப்பைத் திருப்பித் தரவும் அழைக்கப்படுகிறது.
*உள்ளீடு காத்திருக்க f**	திரும்ப உள்ளீடு * காத்திரு f * காத்திரு g; இரண்டு ஒத்திசைவற்ற செயல்பாடுகளின் தீர்க்கப்பட்ட மதிப்புகளால் உள்ளீட்டைப் பெருக்குகிறது, கணக்கீட்டைச் செய்வதற்கு முன் இரண்டு வாக்குறுதிகளும் தீர்க்கப்படுவதை உறுதி செய்கிறது.

ஜாவாஸ்கிரிப்டில் ஒத்திசைவற்ற செயல்பாடுகளை ஆராய்தல்

வழங்கப்பட்ட ஸ்கிரிப்டுகள் ஜாவாஸ்கிரிப்டில் ஒத்திசைவற்ற செயல்பாடுகளின் ஆற்றலைப் பயன்படுத்தி விளக்குகின்றன ஒத்திசைவு மற்றும் காத்திருங்கள் முக்கிய வார்த்தைகள். தாமதமான செயல்பாடுகள் போன்ற ஒத்திசைவற்ற பணிகளை திறமையாக கையாள்வதே முக்கிய யோசனை. இரண்டு எடுத்துக்காட்டுகளிலும், செயல்பாடு பிறகு 5 வி(x) மதிப்புடன் தீர்க்கப்படும் வாக்குறுதியை வழங்குவதன் மூலம் 5 வினாடிகள் தாமதத்தை உருவகப்படுத்துகிறது x. செயல்பாட்டின் வரிசை மற்றும் செயல்பாட்டின் ஓட்டத்துடன் வாக்குறுதிகள் எவ்வாறு தொடர்பு கொள்கின்றன என்பதைப் புரிந்துகொள்வதற்கு இந்த தாமதம் அவசியம்.

முதல் செயல்பாட்டில், பல (உள்ளீடு), இரண்டு வாக்குறுதிகள் தீர்க்கப்படுவதற்கு குறியீடு தொடர்ச்சியாக காத்திருக்கிறது. தி காத்திருங்கள் உறுதிமொழி திரும்பும் வரை குறியீடு செயலிழப்பை இடைநிறுத்துவதை முக்கிய வார்த்தை உறுதி செய்கிறது பிறகு 5 வி(3) தீர்க்கப்படுகிறது. பின்னர், முதல் வாக்குறுதி தீர்க்கப்பட்ட பிறகு, குறியீடு இரண்டாவது வாக்குறுதிக்காக மற்றொரு 5 வினாடிகள் காத்திருக்கிறது பிறகு 5 வி(4) தீர்க்க. இது கணக்கீடு செய்யப்படுவதற்கு முன் 10 வினாடிகள் காத்திருக்க வேண்டியிருக்கும். தீர்க்கப்பட்ட இரண்டு மதிப்புகளின் உள்ளீட்டின் பெருக்கல் இறுதி வெளியீட்டைக் கொடுக்கும்.

இரண்டாவது செயல்பாடு, second_mult(உள்ளீடு), இரண்டு வாக்குறுதிகளையும் ஒரே நேரத்தில் தொடங்குவதன் மூலம் செயல்திறனை மேம்படுத்துகிறது. ஒதுக்குவதன் மூலம் பிறகு 5 வி(3) மற்றும் பிறகு 5 வி(4) விண்ணப்பிக்கும் முன் மாறிகளுக்கு காத்திருங்கள், இரண்டு வாக்குறுதிகளும் இணையாக இயங்குகின்றன. குறியீடு அடையும் போது காத்திருங்கள் அறிக்கைகள், இரண்டு வாக்குறுதிகளும் தீர்க்கப்படும் வரை காத்திருக்கிறது, ஆனால் அவை ஏற்கனவே செயல்பாட்டில் உள்ளன, மொத்த காத்திருப்பு நேரத்தை வெறும் 5 வினாடிகளாகக் குறைக்கிறது. ஒத்திசைவற்ற செயல்பாடுகளை மேம்படுத்துவதன் முக்கியத்துவத்தை இந்த ஒரே நேரத்தில் செயல்படுத்துதல் எடுத்துக்காட்டுகிறது.

ஒத்திசைவற்ற குறியீட்டைக் கையாள, ஒத்திசைவு மற்றும் காத்திருப்பு எவ்வாறு பயன்படுத்தப்படலாம் என்பதை இந்த ஸ்கிரிப்டுகள் விளக்குகின்றன. ஒத்திசைவற்ற பணிகளை ஒரே நேரத்தில் அல்லது தொடர்ச்சியாக எப்போது இயக்க வேண்டும் என்பதைப் புரிந்துகொள்வது செயல்திறனை மேம்படுத்துவதற்கு முக்கியமானது. தி இரண்டாவது_பல செயல்பாட்டின் அணுகுமுறை தேவையற்ற தாமதங்களைத் தவிர்ப்பதன் பலனைக் காட்டுகிறது, அதேசமயம் செயல்பாடுகள் ஒரு குறிப்பிட்ட வரிசையில் நடக்கும் போது முதல் உதாரணம் பயனுள்ளதாக இருக்கும். இரண்டு எடுத்துக்காட்டுகளும் நிஜ உலகக் காட்சிகளில் பரவலாகப் பொருந்தும் வாக்குறுதி கையாளுதல் API களில் இருந்து தரவைப் பெறுதல் அல்லது வெளிப்புற ஆதாரங்களைச் சார்ந்த செயல்பாடுகளைச் செய்தல் போன்றவை தேவை.

ஒத்திசைவு/காத்திருப்பு நடத்தை ஜாவாஸ்கிரிப்ட் டைமிங்கில் விளக்கப்பட்டுள்ளது

இந்த உதாரணம் ஜாவாஸ்கிரிப்ட் பயன்படுத்தி ஒத்திசைவற்ற செயல்பாடுகளை நிரூபிக்கிறது ஒத்திசைவு மற்றும் காத்திருங்கள் செயல்பாடுகள்.

function after5s(x) {
  return new Promise(res => {
    setTimeout(() => {
      res(x);
    }, 5000);
  });
}

// First approach using async/await with sequential waits
async function mult(input) {
  const f = await after5s(3);
  const g = await after5s(4);
  return input * f * g;
}

// Calling the function and handling the promise resolution
mult(2).then(value => {
  console.log(value); // Output: 24 after 10 seconds
});

ஒத்திசைவை மேம்படுத்துதல்/காத்திருத்தல் செயல்பாட்டிற்காக காத்திருக்கிறது

குறியீட்டின் இந்தப் பதிப்பு, ஒவ்வொரு வாக்குறுதிக்கும் தொடர்ச்சியாகக் காத்திருப்பதைத் தவிர்க்க, வாக்குறுதி ஒத்திசைவைப் பயன்படுத்தி ஒத்திசைவு செயல்முறையை மேம்படுத்துகிறது.

function after5s(x) {
  return new Promise(res => {
    setTimeout(() => {
      res(x);
    }, 5000);
  });
}

// Second approach optimizing by starting both promises concurrently
async function second_mult(input) {
  const f = after5s(3); // Starts promise immediately
  const g = after5s(4); // Starts second promise concurrently
  return input * await f * await g;
}

// Calling the function and handling the promise resolution
second_mult(2).then(value => {
  console.log(value); // Output: 24 after 5 seconds
});

ஜாவாஸ்கிரிப்டில் ஒத்திசைவற்ற வடிவங்களை மாஸ்டரிங் செய்தல்

நவீன ஜாவாஸ்கிரிப்ட்டின் மிக முக்கியமான கருத்துகளில் ஒன்று ஒத்திசைவற்ற பணிகளை எவ்வாறு திறமையாக கையாள்வது என்பதுதான். அதே நேரத்தில் ஒத்திசைவு/காத்திருங்கள் தொடரியல் ஒத்திசைவற்ற குறியீட்டின் வாசிப்பை எளிதாக்குகிறது, டெவலப்பர்கள் கருத்தில் கொள்ள வேண்டிய பிற காரணிகளும் உள்ளன. Async செயல்பாடுகளைப் பயன்படுத்துவதில் ஒரு முக்கியமான அம்சம் JavaScript எவ்வாறு நிர்வகிக்கிறது என்பதைப் புரிந்துகொள்வது நிகழ்வு வளையம் மற்றும் ஒத்திசைவற்ற அழைப்பு அடுக்கு. நிகழ்வு வளையமானது ஜாவாஸ்கிரிப்ட்டை ஒரே நேரத்தில் பல பணிகளைச் செயல்படுத்த அனுமதிக்கிறது, ஒற்றை-திரிக்கப்பட்ட சூழலில் கூட, வாக்குறுதிகள் போன்ற தடுக்காத பணிகளை வரிசையில் தள்ளி மற்ற குறியீட்டை தொடர்ந்து செயல்படுத்துவதன் மூலம்.

ஒத்திசைவற்ற செயல்பாடுகளில் பெரும்பாலும் கவனிக்கப்படாத உறுப்பு பிழை கையாளுதல் ஆகும். ஒத்திசைவு/காத்திருப்பு தொடரியல் பயன்படுத்துவதன் மூலம், டெவலப்பர்கள் தங்கள் குறியீட்டை அ முயற்சி...பிடி வாக்குறுதி நிராகரிப்புகள் மற்றும் பிற பிழைகளை மனதார நிர்வகிக்க தடுக்கவும். இந்த முறை ஒத்திசைவற்ற செயல்பாட்டில் ஏற்படும் பிழைகள் பிடிக்கப்பட்டு நிரலின் ஓட்டத்தை உடைக்காமல் கையாளப்படுவதை உறுதி செய்கிறது. ஒத்திசைவற்ற செயல்பாடுகள் செயல்திறனை மேம்படுத்துவது மட்டுமல்லாமல் சிக்கலான பிழை கையாளுதலை மிகவும் திறமையாகவும் பிழைத்திருத்தத்தை எளிதாக்கவும் செய்கிறது.

கவனம் செலுத்த வேண்டிய மற்றொரு முக்கிய பகுதி எப்படி வாக்குறுதி.அனைத்தும் ஒரே நேரத்தில் பல வாக்குறுதிகளை கையாள பயன்படுத்தலாம். முதல் எடுத்துக்காட்டில் உள்ளதைப் போல வரிசையாக வாக்குறுதிகளுக்காக காத்திருக்கிறது போலல்லாமல், வாக்குறுதி.அனைத்தும் அனைத்து வாக்குறுதிகளையும் ஒரே நேரத்தில் செயல்படுத்துகிறது, ஒரு வரிசையில் முடிவுகளை வழங்குகிறது. பல API அழைப்புகளைச் செய்யும்போது அல்லது செயல்படுத்தும் வரிசை முக்கியமானதாக இல்லாத பல பணிகளைச் செய்யும்போது இந்த முறை மிகவும் உதவியாக இருக்கும். உகந்த மற்றும் அளவிடக்கூடிய ஜாவாஸ்கிரிப்ட் குறியீட்டை எழுதுவதற்கு ஒரே நேரத்தில் பணிகளை எவ்வாறு ஒழுங்கமைப்பது என்பதைப் புரிந்துகொள்வது முக்கியம்.

ஜாவாஸ்கிரிப்டில் ஒத்திசைவு/காத்திருப்பதில் அடிக்கடி கேட்கப்படும் கேள்விகள்

நோக்கம் என்ன async ஜாவாஸ்கிரிப்டில்?
தி async முக்கிய சொல் ஒரு செயல்பாட்டை வாக்குறுதியை வழங்க அனுமதிக்கிறது மற்றும் பயன்பாட்டை செயல்படுத்துகிறது await செயல்பாட்டிற்குள்.
என்ன செய்கிறது await முக்கிய சொல்லா?
தி await வாக்குறுதி தீர்க்கப்படும் வரை, முக்கிய வார்த்தை செயல்பாடு செயல்படுத்தலை இடைநிறுத்துகிறது, ஒத்திசைவற்ற பணிகளை மிகவும் ஒத்திசைவாகக் கையாளுவதை உறுதி செய்கிறது.
ஒத்திசைவற்ற குறியீடு இயக்கத்தை JavaScript எவ்வாறு நிர்வகிக்கிறது?
ஜாவாஸ்கிரிப்ட் பயன்படுத்துகிறது event loop ஒத்திசைவற்ற பணிகளைக் கையாள, ஒற்றை-திரிக்கப்பட்ட சூழலில் கூட தடையற்ற குறியீடு செயல்படுத்தலை அனுமதிக்கிறது.
வரிசைமுறை மற்றும் ஒரே நேரத்தில் ஒத்திசைவு செயல்பாட்டிற்கு என்ன வித்தியாசம்?
தொடர்ச்சியான செயல்பாட்டில், ஒவ்வொன்றும் await செயல்பாட்டை இடைநிறுத்துகிறது, அதே நேரத்தில் அனைத்து வாக்குறுதிகளும் ஒரே நேரத்தில் இயங்கும், காத்திருப்பு நேரத்தை குறைக்கிறது.
ஒத்திசைவில்/காத்திருப்பதில் பிழை கையாளுதல் எவ்வாறு செயல்படுகிறது?
உடன் try...catch, ஒத்திசைவற்ற செயல்பாடுகளில் பிழைகள் பிடிக்கப்பட்டு கையாளப்பட்டு, நிரல் செயலிழப்பதைத் தடுக்கிறது.

ஜாவாஸ்கிரிப்டில் ஒத்திசைவற்ற செயலாக்கத்தை மூடுதல்

ஜாவாஸ்கிரிப்டில் உள்ள ஒத்திசைவு/காத்திருப்பு செயல்பாடு, ஒத்திசைவற்ற செயல்பாடுகளைக் கையாள ஒரு சக்திவாய்ந்த வழியாகும், இது குறியீட்டை மேலும் படிக்கக்கூடியதாகவும் திறமையாகவும் ஆக்குகிறது. வழங்கப்பட்ட எடுத்துக்காட்டுகளில், பயன்பாடு காத்திருங்கள் முறையான வரிசை கையாளுதலை உறுதி செய்கிறது, முதல் உதாரணம் வாக்குறுதிகளை வரிசையாக இயக்குகிறது மற்றும் இரண்டாவது அவற்றை ஒரே நேரத்தில் செயல்படுத்துகிறது.

வாக்குறுதிகள் எவ்வாறு தீர்க்கப்படுகின்றன என்பதன் முக்கியத்துவத்தை அங்கீகரிப்பதன் மூலம், டெவலப்பர்கள் தேவையற்ற தாமதங்களைத் தவிர்த்து, தங்கள் பயன்பாட்டின் செயல்திறனை மேம்படுத்தலாம். APIகள் அல்லது சிக்கலான ஒத்திசைவற்ற பணிகளைக் கையாள்வது, இந்த அம்சங்களை மேம்படுத்துவது செயல்பாடு மற்றும் குறியீடு தெளிவு ஆகிய இரண்டிலும் குறிப்பிடத்தக்க மேம்பாடுகளை வழங்க முடியும்.

குறிப்புகள் மற்றும் வெளிப்புற ஆதாரங்கள்

இந்த கட்டுரை அதிகாரியின் தகவலைப் பயன்படுத்தியது MDN வெப் டாக்ஸ் ஒத்திசைவில்/காத்திருப்பில் , இது ஜாவாஸ்கிரிப்டில் ஒத்திசைவற்ற நிரலாக்கம் பற்றிய விரிவான வழிகாட்டியை வழங்குகிறது.
ஜாவாஸ்கிரிப்ட் நேர்காணல் மதிப்பீடுகள் பற்றிய கூடுதல் விவரங்களுக்கு, Adaface JavaScript ஆன்லைன் சோதனை நேர்காணல்களில் பயன்படுத்தப்படும் தொழில்நுட்ப சோதனைகளின் நிஜ உலக உதாரணங்களை வழங்கும், ஆலோசனை செய்யப்பட்டது.

ஜாவாஸ்கிரிப்டில் ஒத்திசைவு/காத்திருப்பதைப் புரிந்துகொள்வது: அவுட்புட் டைமிங்கில் ஆழமாக மூழ்குவது