JavaScript හි සමකාලීන විලාසයෙන් පොරොමිස්
පොරොමිස් නැරහල්වල ගැටළුව විසඳීම සඳහා විශේෂ වාක්ය රචනයක් නිර්මාණය කරන ලදී, එය අසමකාලීන කේතය ඉතා පහසුවෙන් ලිවීමට ඉඩ සලසයි - සමකාලීන විලාසයෙන්.
අපි එහි අධ්යයනය ආරම්භ කරමු. පළමුව, කලින් පාඩමෙන් කේතය ගනිමු:
function func() {
getSmth(2).then(res => {
console.log(res); // 4 පෙන්වයි
});
}
func();
අපගේ ශ්රිතය getSmth නම්
සමකාලීන වී තිබුනේ නම්, ශ්රිතයේ කේතය func අපි
පහත පරිදි නැවත ලිවිය හැකිය:
function func() {
let res = getSmth(2);
console.log(res); // 4 පෙන්වයි
}
ශ්රිතය getSmth, කෙසේ වෙතත්, අසමකාලීනය,
එබැවින් ඉහත දක්වා ඇති කේතය ක්රියා නොකරනු ඇත.
නමුත්, පොරොමිස් වල සමකාලීන විලාසය භාවිතා කරමින්,
අපට සමාන යමක් ලබා ගත හැකිය. අපි එය කරමු.
පළමුව අපි අපගේ ශ්රිතය
func විශේෂ විධානයක් සමඟ අසමකාලීන ලෙස ප්රකාශ කළ යුතුය
async:
async function func() {
}
ඊට පසුව අපට ශ්රිතය තුළ func
විශේෂ විධානයක් භාවිතා කළ හැකිය await.
මෙම විධානය, පොරොමිසයකට පෙර ලියනු ලැබීම, එයට හේතු වනු ඇත
JavaScript බලා සිටීමට පොරොමිසය
සම්පූර්ණ නොවන තෙක්. ඊට පසුව විධානය ආපසු එනු ඇත
පොරොමිසයේ ප්රතිඵලය, සහ කේත ක්රියාත්මක කිරීම දිගටම ක්රියාත්මක වේ.
අපගේ නඩුවේදී අපි await ලිවිය යුතුය
getSmth කැඳවීමට පෙර. එහි ප්රතිඵලය වන බැවින්
මෙම ශ්රිතය කැඳවීම පොරොමිසයක් වනු ඇත, එවිට තවදුරටත්
කේතය ක්රියාත්මක කිරීම පමණක් ඉදිරියට යනු ඇත
මෙම පොරොමිසය ක්රියාත්මක කිරීම. හොඳයි, ප්රති result ලය
පොරොමිසය විචල්යයකට ලියා තැබිය හැකිය. අපි කරමු
විස්තර කර ඇති:
async function func() {
let res = await getSmth(2);
console.log(res); // 4 පෙන්වයි
}
func();
අපි getSmth කිහිප වතාවක් කැඳවමු:
async function func() {
let res1 = await getSmth(2);
let res2 = await getSmth(3);
console.log(res1 + res2); // 13 පෙන්වයි
}
func();
දැන් අපි getSmth ලූපයකදී කැඳවමු:
async function func() {
let arr = [1, 2, 3, 4, 5];
let sum = 0;
for (let elem of arr) {
sum += await getSmth(elem);
}
console.log(sum);
}
func();
පහත කේතය නැවත ලියන්න සමකාලීන වාක්ය රචනය හරහා:
function func() {
getSmth(2).then(res1 => {
getSmth(3).then(res2 => {
getSmth(4).then(res3 => {
console.log(res1 + res2 + res3);
});
});
});
}
func();
