JavaScript හි මෙමොරි පරිභෝජනය ප්‍රශස්තකරණය කිරීම

සෑදූ විචල්ය සියල්ලම පරිගණකයේ මතකයේ ගබඩා වේ. සමහර විට චින්තනය නොකළ කේත ලිවීම පරිභෝජනය වන මතකය තියුණු ලෙස වැඩි කළ හැක.

අපි උදාහරණයක් බලමු. අප ඉදිරියේ 1 සිට 100000000 දක්වා පූර්ණ සංඛ්‍යාවල එකතුව සොයා ගැනීමේ කාර්යයක් ඇතැයි සිතමු. දී ඇති පරාසයකින් පූර්ණ සංඛ්‍යා සමඟ අරාව පුරවන ශ්‍රිතයක් අප සතුව ඇතැයි සිතමු:

javascriptfunction fillArr(a, b) {
  let res = [];
  
  for (let i = a; i <= b; i++) {
    res.push(i);
  }
  
  return res;
}

අරාවක මූලද්‍රව්‍යවල එකතුව සොයා ගන්නා ශ්‍රිතයක් ද අප සතුව ඇතැයි සිතමු:

javascriptfunction getSum(arr) {
  let sum = 0;
  
  for (let elem of arr) {
    sum += elem
  }
  
  return sum;
}

මෙම ශ්‍රිත සංයෝජනය භාවිතයෙන් දී ඇති කාර්යය පහසුවෙන් විසඳා ගත හැකිය:

javascriptlet sum = getSum(fillArr(1, 100000000));

එය කෞෂල්යමත් විසඳුමක් විය. එහි පැවතින්නේ, එය අතිවිශාල මතක ප්‍රමාණයක් පරිභෝජනය කරන ගැටලුවකි.

අපි ගණනය කරමු. fillArr ශ්‍රිතය 100000000 සංඛ්‍යා සහිත අරාවක් සාදයි. JavaScript සංඛ්‍යාවක් සඳහා 2 බයිට් වෙන් කරන බව සිතමු - එවිට අපගේ අරාව ගබඩා කිරීමට 200000000 බයිට්, එනම් 200 මෙගාබයිට් පමණ මතකය අවශ්‍ය වනු ඇත.

ඇත්ත වශයෙන්ම, JavaScript හි අරාව ගබඩා කිරීමේදී ඉතා විශාල අතිරේක පිරිවැය හේතුවෙන් ඊටත් වඩා වැඩි මතකයක් අවශ්‍ය වනු ඇත.

ගැටලුව අවබෝධ කර ගැනීමෙන්, කාර්යය විසඳන සහ ප්‍රායෝගිකව මතකය නොපරිභෝජනය කරන ශ්‍රිතයක් සෑදිය හැකිය:

javascriptfunction getNumsSum(max) {
  let sum = 0;
  
  for (let i = 1; i <= max; i++) {
    sum += i;
  }
  
  return sum;
}

අපගේ ශ්‍රිතය භාවිතයෙන් කාර්යය විසඳමු:

javascriptlet sum = getNumsSum(100000000);

javascriptlet arr = [];

for (let i = 0; i <= 1000; i++) {
  if (i % 7 == 0) {
    arr.push(i);
  }
}

console.log(arr.length);

javascriptfunction getDivisors(num) {
  let res = [];
  
  for (let i = 1; i <= num; i++) {
    if (num % i === 0) {
      res.push(i);
    }
  }
  
  return res;
}

function getSum(arr) {
  let sum = 0;
  
  for (let elem of arr) {
    sum += elem
  }
  
  return sum;
}

let sum = getSum(getDivisors(320));
console.log(sum);