ஜாவாஸ்கிரிப்டில் உள்ள பைட் நீளத்தைப் பொறுத்து உருப்படிகளின் வரிசையை திறம்பட பிரிவுகளாகப் பிரித்தல்

Node.js இல் நினைவகம்-பாதுகாப்பான பொருள் துண்டித்தல்

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

கடுமையான நினைவகக் கட்டுப்பாடுகள் அல்லது பேலோட் அளவுகளில் வரம்புகளைக் கொண்ட APIகள் அல்லது அமைப்புகளுடன் நீங்கள் கையாளும் போது இந்தப் பணி மிகவும் முக்கியமானது. ஜாவாஸ்கிரிப்டில் நினைவக அளவைக் கணக்கிடுவதற்கான பொதுவான அணுகுமுறை ஒவ்வொரு பொருளின் பைட் அளவை அளவிடுவதாகும் Buffer.byteLength() அதை இறுக்கிய பிறகு.

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

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

ஜாவாஸ்கிரிப்டில் நினைவக அளவு மூலம் வரிசைகளை சுருக்குவதற்கான தீர்வை உடைத்தல்

முந்தைய எடுத்துக்காட்டுகளில் வழங்கப்பட்ட ஸ்கிரிப்ட்கள் ஜாவாஸ்கிரிப்டில் உள்ள பொதுவான சிக்கலைத் தீர்க்க வடிவமைக்கப்பட்டுள்ளன: ஒவ்வொரு துண்டின் பைட் அளவின் அடிப்படையில் பொருள்களின் வரிசையை சிறிய துண்டுகளாகப் பிரித்தல். 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);
}

ஜாவாஸ்கிரிப்டில் வரிசைகளை துண்டிக்கும்போது நினைவகப் பயன்பாட்டை மேம்படுத்துதல்

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

ஒரு முக்கியமான நுட்பம் பயன்படுத்தப்படுகிறது Buffer.byteLength() பொருட்களை சரங்களாக மாற்றிய பின் JSON.stringify(). ஒவ்வொரு பொருளின் பைட் அளவை அளவிடுவதன் மூலம், அதிகபட்ச பைட் வரம்பை மீறாமல் இருப்பதை உறுதி செய்வதன் மூலம் நினைவக பயன்பாட்டை நீங்கள் துல்லியமாக கட்டுப்படுத்தலாம். இருப்பினும், நினைவக நுகர்வுக்கு பங்களிக்கும் பயன்பாட்டின் மற்ற பகுதிகளிலிருந்து நினைவக மேல்நிலையைக் கருத்தில் கொள்வதும் முக்கியம், உங்கள் தீர்வு திறமையாக இருப்பதை உறுதிசெய்கிறது.

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