ജാവാസ്ക്രിപ്റ്റിലെ ബൈറ്റ് ദൈർഘ്യത്തെ ആശ്രയിച്ച് ഇനങ്ങളുടെ ഒരു നിരയെ ഫലപ്രദമായി സെഗ്മെൻ്റുകളായി വിഭജിക്കുന്നു

Node.js-ൽ മെമ്മറി-സേഫ് ഒബ്ജക്റ്റ് ചങ്കിംഗ്

JavaScript-ൽ, പ്രത്യേകിച്ച് Node.js-ൽ ഒബ്‌ജക്‌റ്റുകളുടെ വലിയ നിരകളുമായി പ്രവർത്തിക്കുമ്പോൾ, മെമ്മറി ഫലപ്രദമായി കൈകാര്യം ചെയ്യേണ്ടത് നിർണായകമാണ്. ചില സമയങ്ങളിൽ, ഓരോ ചങ്കും നിശ്ചിത മെമ്മറി പരിധിയിൽ കവിയുന്നില്ലെന്ന് ഉറപ്പാക്കിക്കൊണ്ട് നിങ്ങൾ ഈ അറേകളെ ചെറിയ ഭാഗങ്ങളായി വിഭജിക്കേണ്ടി വന്നേക്കാം.

കർശനമായ മെമ്മറി നിയന്ത്രണങ്ങളോ പേലോഡ് വലുപ്പങ്ങളുടെ പരിധികളോ ഉള്ള എപിഐകളുമായോ സിസ്റ്റങ്ങളുമായോ നിങ്ങൾ ഇടപെടുമ്പോൾ ഈ ടാസ്‌ക് വളരെ പ്രധാനമാണ്. ജാവാസ്ക്രിപ്റ്റിൽ മെമ്മറി വലുപ്പം കണക്കാക്കുന്നതിനുള്ള ഒരു പൊതു സമീപനം ഉപയോഗിക്കുന്ന ഓരോ വസ്തുവിൻ്റെയും ബൈറ്റ് വലുപ്പം അളക്കുക എന്നതാണ് Buffer.byteLength() അത് കർശനമാക്കിയ ശേഷം.

ഈ ലേഖനത്തിൽ, ഒബ്‌ജക്‌റ്റുകളുടെ ഒരു നിരയെ അവയുടെ ബൈറ്റ് വലുപ്പത്തെ അടിസ്ഥാനമാക്കി ചെറിയ കഷണങ്ങളായി വിഭജിക്കുന്നത് എങ്ങനെയെന്ന് ഞങ്ങൾ പര്യവേക്ഷണം ചെയ്യും. പ്രയോജനപ്പെടുത്തുന്നതിലൂടെ Buffer.byteLength(), ഓരോ ചങ്കും നിർദ്ദിഷ്‌ട മെമ്മറി പരിധിക്കുള്ളിൽ തന്നെ തുടരുന്നുവെന്ന് ഞങ്ങൾക്ക് ഉറപ്പാക്കാം, ലഭ്യമായ മെമ്മറി കവിയുന്നത് മൂലമുണ്ടാകുന്ന പിശകുകൾ അല്ലെങ്കിൽ ക്രാഷുകൾ തടയുന്നു.

ഒരു പ്രായോഗിക ഉദാഹരണത്തിലൂടെ, വലിയ ഡാറ്റാസെറ്റുകൾ കൈകാര്യം ചെയ്യുമ്പോൾ നിങ്ങളുടെ കോഡ് കാര്യക്ഷമവും ശക്തവുമാണെന്ന് ഉറപ്പാക്കിക്കൊണ്ട് Node.js-ൽ ഇത് നടപ്പിലാക്കുന്നതിനുള്ള മികച്ച സമീപനം നിങ്ങൾ പഠിക്കും. നമുക്ക് പരിഹാരത്തിലേക്ക് കടക്കാം.

ജാവാസ്ക്രിപ്റ്റിലെ മെമ്മറി സൈസ് അനുസരിച്ച് ചങ്കിംഗ് അറേകൾക്കുള്ള പരിഹാരം തകർക്കുന്നു

മുമ്പത്തെ ഉദാഹരണങ്ങളിൽ നൽകിയിട്ടുള്ള സ്‌ക്രിപ്റ്റുകൾ JavaScript-ലെ ഒരു സാധാരണ പ്രശ്‌നം പരിഹരിക്കുന്നതിന് രൂപകൽപ്പന ചെയ്‌തിരിക്കുന്നു: ഓരോ ചങ്കിൻ്റെയും ബൈറ്റ് വലുപ്പത്തെ അടിസ്ഥാനമാക്കി ഒബ്‌ജക്റ്റുകളുടെ ഒരു നിരയെ ചെറിയ ഭാഗങ്ങളായി വിഭജിക്കുന്നു. API-കൾ അല്ലെങ്കിൽ ഡാറ്റാബേസ് ഇൻസെർട്ടുകൾ പോലെ, കർശനമായ മെമ്മറി അല്ലെങ്കിൽ പേലോഡ് വലുപ്പ പരിധികളുള്ള സിസ്റ്റങ്ങളിൽ പ്രവർത്തിക്കുമ്പോൾ ഇത് പ്രത്യേകിച്ചും ഉപയോഗപ്രദമാണ്. ഓരോ ഒബ്ജക്റ്റിൻ്റെയും മെമ്മറി വലുപ്പം ബൈറ്റുകളിൽ കണക്കാക്കുന്നതിലൂടെ Buffer.byteLength(), ഒരു ചങ്കും നിർവ്വചിച്ച മെമ്മറി പരിധി കവിയുന്നില്ലെന്ന് ഞങ്ങൾ ഉറപ്പാക്കുന്നു.

ആദ്യ സമീപനം പരമ്പരാഗത രീതിയെ സ്വാധീനിക്കുന്നു Array.forEach() ലൂപ്പ്, ഇവിടെ അറേയിലെ ഓരോ ഒബ്ജക്റ്റും ഓരോന്നായി പ്രോസസ്സ് ചെയ്യുന്നു. ഓരോ ഒബ്‌ജക്റ്റിനും, ഞങ്ങൾ ആദ്യം അത് ഉപയോഗിച്ച് ഒരു JSON സ്‌ട്രിംഗിലേക്ക് പരിവർത്തനം ചെയ്യുന്നു JSON.stringify(), തുടർന്ന് അതിൻ്റെ വലിപ്പം ബൈറ്റുകളിൽ കണക്കാക്കുക. നിലവിലെ ചങ്കിൻ്റെ മൊത്തം വലുപ്പം (നിലവിലെ ഒബ്‌ജക്‌റ്റിൻ്റെ വലുപ്പം കൂടി) അനുവദനീയമായ പരമാവധി വലുപ്പത്തേക്കാൾ കൂടുതലാണെങ്കിൽ, നിലവിലെ ചങ്ക് ചങ്കുകളുടെ അന്തിമ ശ്രേണിയിലേക്ക് തള്ളപ്പെടുകയും ഒരു പുതിയ ചങ്ക് ആരംഭിക്കുകയും ചെയ്യുന്നു. ഈ രീതി ലളിതവും എന്നാൽ ഫലപ്രദവുമാണ്, യഥാർത്ഥ മെമ്മറി ഉപയോഗത്തെ അടിസ്ഥാനമാക്കിയാണ് ചങ്കിംഗ് പ്രക്രിയ നടക്കുന്നതെന്ന് ഉറപ്പാക്കുന്നു.

രണ്ടാമത്തെ സമീപനം ഉപയോഗിക്കുന്നു Array.reduce(), ഇത് വൃത്തിയുള്ളതും കൂടുതൽ പ്രവർത്തനപരവുമായ പ്രോഗ്രാമിംഗ് രീതിയാണ്. ഈ സാഹചര്യത്തിൽ, അറേ ചങ്കുകളുടെ ഒരു നിരയിലേക്ക് ചുരുക്കുന്നു, അവിടെ ഒരു ഒബ്‌ജക്റ്റ് ഒരു ചങ്കിലേക്ക് ചേർക്കുന്നതിനോ ഒരു പുതിയ ചങ്ക് ആരംഭിക്കുന്നതിനോ ഉള്ള ലോജിക് റിഡ്യൂസർ ഫംഗ്‌ഷനിൽ കൈകാര്യം ചെയ്യുന്നു. ഈ സമീപനം കൂടുതൽ ഗംഭീരവും സംക്ഷിപ്തവുമാകാം, പ്രത്യേകിച്ചും സങ്കീർണ്ണമായ അറേകളിൽ പ്രവർത്തിക്കുമ്പോൾ. എന്നിരുന്നാലും, ഓരോ ചങ്കും നിർദ്ദിഷ്‌ട ബൈറ്റ് വലുപ്പ പരിധിക്കുള്ളിൽ തന്നെ നിലകൊള്ളുന്നുവെന്ന് ഉറപ്പാക്കുന്നതിലൂടെ ഇത് ആദ്യ രീതിയുടെ അതേ ഉദ്ദേശ്യം നിറവേറ്റുന്നു.

മൂന്നാമത്തെ സമീപനം ഇൻപുട്ട് മൂല്യനിർണ്ണയം, പിശക് കൈകാര്യം ചെയ്യൽ എന്നിവ പോലുള്ള കൂടുതൽ വിപുലമായ സവിശേഷതകൾ അവതരിപ്പിക്കുന്നു, ഇത് സ്ക്രിപ്റ്റിനെ കൂടുതൽ ശക്തമാക്കുന്നു. ഞങ്ങൾ ഉപയോഗിക്കുന്നു Array.isArray() ഇൻപുട്ട് ഒരു സാധുതയുള്ള അറേ ആണോ എന്ന് പരിശോധിക്കുന്നതിനും ഇഷ്‌ടാനുസൃത പിശകുകൾ ഉപയോഗിക്കുന്ന വ്യവസ്ഥകൾ ഉൾപ്പെടുത്തുന്നതിനും പുതിയ പിശക് () ഇൻപുട്ട് ഡാറ്റ അസാധുവാണെങ്കിൽ. തെറ്റായ ഇൻപുട്ടുകൾ പ്രോസസ്സ് ചെയ്യുമ്പോൾ കോഡ് അപ്രതീക്ഷിതമായി തകരില്ലെന്ന് ഇത് ഉറപ്പാക്കുന്നു. കൂടാതെ, ഈ പതിപ്പ് കൂടുതൽ മോഡുലറും ഘടനാപരവുമാണ്, സുരക്ഷയും പ്രകടനവും നിർണായകമായ പ്രൊഡക്ഷൻ ലെവൽ കോഡിന് ഇത് അനുയോജ്യമാക്കുന്നു.

// Approach 1: Basic Solution using a loop and Buffer.byteLength<code>const data = [ { id: 1, name: 'Alice' }, { id: 2, name: 'Bob' }];
const maxSizeInBytes = 100; // Maximum size per chunk
function chunkArrayBySize(arr, maxSize) {
  let chunks = [];
  let currentChunk = [];
  let currentChunkSize = 0;

  arr.forEach(obj => {
    const objSize = Buffer.byteLength(JSON.stringify(obj));
    if (currentChunkSize + objSize > maxSize) {
      chunks.push(currentChunk);
      currentChunk = [];
      currentChunkSize = 0;
    }
    currentChunk.push(obj);
    currentChunkSize += objSize;
  });
  if (currentChunk.length) chunks.push(currentChunk);
  return chunks;
}

console.log(chunkArrayBySize(data, maxSizeInBytes));

// Approach 2: Using Array.reduce() for a more functional style<code>function chunkArrayWithReduce(arr, maxSize) {
  return arr.reduce((chunks, obj) => {
    const objSize = Buffer.byteLength(JSON.stringify(obj));
    let lastChunk = chunks[chunks.length - 1];

    if (!lastChunk || Buffer.byteLength(JSON.stringify(lastChunk)) + objSize > maxSize) {
      chunks.push([obj]);
    } else {
      lastChunk.push(obj);
    }

    return chunks;
  }, []);
}

console.log(chunkArrayWithReduce(data, maxSizeInBytes));

// Approach 3: Modular and robust solution with error handling<code>function isValidArray(arr) {
  return Array.isArray(arr) && arr.length > 0;
}

function chunkArrayWithValidation(arr, maxSize) {
  if (!isValidArray(arr)) throw new Error("Invalid input array");
  if (typeof maxSize !== 'number' || maxSize <= 0) throw new Error("Invalid max size");

  let chunks = [], currentChunk = [], currentChunkSize = 0;
  arr.forEach(obj => {
    const objSize = Buffer.byteLength(JSON.stringify(obj));
    if (currentChunkSize + objSize > maxSize) {
      chunks.push(currentChunk);
      currentChunk = [];
      currentChunkSize = 0;
    }
    currentChunk.push(obj);
    currentChunkSize += objSize;
  });

  if (currentChunk.length) chunks.push(currentChunk);
  return chunks;
}

try {
  console.log(chunkArrayWithValidation(data, maxSizeInBytes));
} catch (error) {
  console.error("Error:", error.message);
}

ജാവാസ്ക്രിപ്റ്റിൽ അറേകൾ ചങ്ക് ചെയ്യുമ്പോൾ മെമ്മറി ഉപയോഗം ഒപ്റ്റിമൈസ് ചെയ്യുന്നു

JavaScript-ൽ വലിയ ഡാറ്റാസെറ്റുകളിൽ പ്രവർത്തിക്കുമ്പോൾ, മെമ്മറി ഉപയോഗം ഒപ്റ്റിമൈസ് ചെയ്യുന്നത് അത്യന്താപേക്ഷിതമാണ്, പ്രത്യേകിച്ച് Node.js പോലുള്ള പരിതസ്ഥിതികളിൽ കാര്യക്ഷമമായ മെമ്മറി മാനേജ്മെൻ്റിന് ക്രാഷുകൾ അല്ലെങ്കിൽ പ്രകടന തടസ്സങ്ങൾ തടയാൻ കഴിയും. പരിഗണിക്കേണ്ട ഒരു പ്രധാന വശം, വ്യത്യസ്ത ഒബ്ജക്റ്റ് വലുപ്പങ്ങളുടെ ശ്രേണികൾ എങ്ങനെ കൈകാര്യം ചെയ്യാം എന്നതാണ്. സീരിയലൈസ് ചെയ്യുമ്പോൾ ഓരോ ഒബ്ജക്റ്റിനും വ്യത്യസ്‌ത ബൈറ്റ് വലുപ്പങ്ങൾ ഉണ്ടാകാം, കൂടാതെ ഈ വേരിയബിളിറ്റി മെമ്മറി ഉപയോഗം പ്രവചിക്കുന്നത് വെല്ലുവിളിയാക്കുന്നു.

ഒരു നിർണായക സാങ്കേതികത ഉപയോഗിക്കുന്നു Buffer.byteLength() വസ്തുക്കളെ സ്ട്രിംഗുകളാക്കി മാറ്റിയ ശേഷം JSON.stringify(). ഓരോ ഒബ്‌ജക്റ്റിൻ്റെയും ബൈറ്റ് വലുപ്പം അളക്കുന്നതിലൂടെ, പരമാവധി ബൈറ്റ് പരിധിയിൽ കവിയുന്ന ചങ്ക് ഇല്ലെന്ന് ഉറപ്പാക്കിക്കൊണ്ട് നിങ്ങൾക്ക് മെമ്മറി ഉപയോഗം കൃത്യമായി നിയന്ത്രിക്കാനാകും. എന്നിരുന്നാലും, മെമ്മറി ഉപഭോഗത്തിന് കാരണമായേക്കാവുന്ന ആപ്ലിക്കേഷൻ്റെ മറ്റ് ഭാഗങ്ങളിൽ നിന്നുള്ള മെമ്മറി ഓവർഹെഡ് പരിഗണിക്കേണ്ടതും പ്രധാനമാണ്, നിങ്ങളുടെ പരിഹാരം കാര്യക്ഷമമായി തുടരുന്നുവെന്ന് ഉറപ്പാക്കുന്നു.

ബൈറ്റ് വലുപ്പത്തെ അടിസ്ഥാനമാക്കിയുള്ള ചങ്കിംഗ് കൂടാതെ, വലിയ ഡാറ്റാസെറ്റുകൾക്കായി സ്ട്രീമിംഗ് ടെക്നിക്കുകൾ ഉപയോഗിക്കുന്നത് പോലെയുള്ള കൂടുതൽ വിപുലമായ മെമ്മറി ഒപ്റ്റിമൈസേഷനുകൾ നടപ്പിലാക്കാൻ നിങ്ങൾ ആഗ്രഹിച്ചേക്കാം. മുഴുവൻ ഡാറ്റാസെറ്റും ഒരേസമയം മെമ്മറിയിലേക്ക് ലോഡുചെയ്യാതെ ഡാറ്റ കഷണങ്ങളായി കൈകാര്യം ചെയ്യാൻ ഈ സമീപനം നിങ്ങളെ അനുവദിക്കുന്നു. പിശക് കൈകാര്യം ചെയ്യലും മൂല്യനിർണ്ണയവും ഉൾപ്പെടുത്തുന്നത് ശക്തമായ സൊല്യൂഷനുകൾ നിർമ്മിക്കാൻ സഹായിക്കുന്നു, അസാധുവായ ഡാറ്റ നിങ്ങളുടെ സിസ്റ്റത്തിൽ അനാവശ്യ മെമ്മറി ലീക്കുകൾക്കോ ​​ക്രാഷുകൾക്കോ ​​കാരണമാകുന്നില്ലെന്ന് ഉറപ്പാക്കുന്നു.