JavaScript හි පොරොමිස් හඳුන්වාදීම

ඔබ දැනටමත් දන්නවා, කොල්බැක් මාදිලිය භාවිතා කිරීම අසමගත ක්‍රියාවලිය පහසුවෙන් callback hell තත්වයට ඇතුළු කරයි. ඒ නිසා JavaScript හි නව මාදිලියක් හඳුන්වා දෙන ලදී, එය නම් පොරොමිස් (promise). අපි මෙම මාදිලිය අධ්‍යයනය කරමු.

පොරොමිස් යනු වස්තුවකි, එයට පරාමිතියක් ලෙස ශ්‍රිතයක් ලබා දෙනු ලැබේ, එහි ඇතුළත අපගේ අසමගත කේතය තබා ගත යුතුය:

let promise = new Promise(function() {
	// අසමගත කේතය
});

ඔබට පෙනෙන පරිදි, මම පොරොමිස් සහිත වස්තුව promise යන විචල්‍යයට ලියා ඇත. කේතයේ වෙනත් ස්ථානයකදී මට මෙම විචල්‍යයට then ක්‍රමය යොදා ගත හැකිය, එයට ශ්‍රිතයක් ලබා දෙමින් මෙම පොරොමිස් තැනීමේදී ලියා ඇති අසමගත කේතය සම්පූර්ණ වූ විට ක්‍රියාත්මක විය යුතු කේතය සමඟ:

promise.then(function() {
	// අසමගත කේතය සම්පූර්ණ වූ විට ක්‍රියාත්මක වේ
});

එය ව්‍යාකූල ලෙස පෙනේ, ඒ නිසා අපි උදාහරණයක් බලමු. මට පහත දැක්වෙන අසමගත කේතයක් ඇතැයි සිතමු:

setTimeout(function() {
	let result = [1, 2, 3, 4, 5];
}, 3000);

මට එය සඳහා අපගේ ප්‍රධාන අසමගත ගැටළුව විසඳීමට අවශ්‍ය යැයි සිතමු: ටයිමරය ක්‍රියාකර පසුව යම් කේතයක් ක්‍රියාත්මක කිරීම. මෙම අවස්ථාවේදී මට මෙම කේතය ටයිමරය තුළම තැබීමට අවශ්‍ය නැත සහ මෙම කේතයට කෙසේ හෝ ප්‍රතිඵලය ලැබෙන පරිදි, මම result විචල්‍යයේ ලියා ඇත. සාමාන්‍යයෙන්, මෙම ගැටළුව අපි පෙර පාඩම් වල කොල්බැක් සහ දායකත්වය ඔස්සේ විසඳා ඇත. දැන් අපි බලමු, එය පොරොමිස් මගින් කරන්නේ කෙසේද කියා.

පළමුව අපගේ අසමගත කේතය පොරොමිස් එකකින් ආවරණය කළ යුතුය:

let promise = new Promise(function() {
	setTimeout(function() {
		let result = [1, 2, 3, 4, 5];
	}, 3000);
});

කෙසේ වෙතත්, මෙය ප්‍රමාණවත් නොවේ. අපට පැහැදිලිව දැක්විය යුතුය, අපගේ අසමගත කේතය සම්පූර්ණ වී ඇති බව. මේ සඳහා අපට උපකාරී වන්නේ විශේෂ සම්පූර්ණ කිරීමේ ශ්‍රිතය, එය ස්වයංක්‍රීයව ශ්‍රිතයේ පළමු පරාමිතියට ඇතුළු වේ, එය සඳහන් කර ඇත්නම්:

let promise = new Promise(function(resolve) { // පරාමිතිය සඳහන් කරමු
	setTimeout(function() {
		let result = [1, 2, 3, 4, 5];
	}, 3000);
});

සම්පූර්ණ කිරීමේ ශ්‍රිතය භාවිතා කරමින් අපට පැහැදිලිව පොරොමිස් වෙත දැක්විය හැකිය, අසමගත කේතය සම්පූර්ණ වී ඇති බව. මෙය සඳහා අපට අවශ්‍ය ස්ථානයේ මෙම ශ්‍රිතය ක්‍රියා කරවිය යුතුය:

let promise = new Promise(function(resolve) {
	setTimeout(function() {
		let result = [1, 2, 3, 4, 5];
		resolve(); // පොරොමිස් සම්පූර්ණ කරමු
	}, 3000);
});

මෙම අවස්ථාවේදී, අපට අසමගත කේතයේ කිසියම් ප්‍රතිඵලයක් බාහිරව යැවීමට අවශ්‍ය නම්, අපට එය පරාමිතියක් ලෙස අපගේ සම්පූර්ණ කිරීමේ ශ්‍රිතයට ලබා දිය හැකිය:

let promise = new Promise(function(resolve) {
	setTimeout(function() {
		let result = [1, 2, 3, 4, 5];
		resolve(result); // ප්‍රතිඵලය ලබා දෙමු
	}, 3000);
});

ඇත්ත වශයෙන්ම, අතරමැදි විචල්‍යය ඉවත් කළ හැකිය:

let promise = new Promise(function(resolve) {
	setTimeout(function() {
		resolve([1, 2, 3, 4, 5]);
	}, 3000);
});

දැන් ඕනෑම වෙනත් ස්ථානයකදී අපට ක්‍රියා කළ හැකිය අපගේ පොරොමිස් වල then ක්‍රමය:

promise.then(function() {
	// පොරොමිස් සම්පූර්ණ වූ විට ක්‍රියාත්මක වේ
});

පොරොමිස් වැඩ කිරීමේ ප්‍රතිඵලය පළමු පරාමිතියට ඇතුළු වේ, අපි එය සඳහන් කිරීමට කැමති නම්:

promise.then(function(result) {
	console.log(result); // ප්‍රතිඵලය සහිත අරාව පෙන්වයි
});

පොරොමිස් එකක් සාදන්න, එහි ඇතුළත ප්‍රමාදයක් 5 තත්පර වන අතර, ඉන් පසු පොරොමිස් ක්‍රියාත්මක විය යුතු අතර, එහි ප්‍රතිඵලයක් ලෙස යම් පාඨයක් ආපසු ලබා දිය යුතුය. මෙම පාඨය තිරය මත පෙන්වන්න.