JavaScript मधील बाइट लांबीवर अवलंबून भागांमध्ये आयटमचे ॲरे प्रभावीपणे विभाजित करणे

Node.js मध्ये मेमरी-सेफ ऑब्जेक्ट चंकिंग

JavaScript मधील ऑब्जेक्ट्सच्या मोठ्या ॲरेसह काम करताना, विशेषत: Node.js मध्ये, मेमरी प्रभावीपणे व्यवस्थापित करणे महत्वाचे आहे. काहीवेळा, तुम्हाला या ॲरेला लहान भागांमध्ये विभाजित करण्याची आवश्यकता असू शकते, याची खात्री करून की प्रत्येक भाग विशिष्ट मेमरी मर्यादा ओलांडत नाही.

हे कार्य विशेषतः महत्वाचे बनते जेव्हा तुम्ही APIs किंवा प्रणालींशी व्यवहार करत असता ज्यात मेमरी निर्बंध किंवा पेलोड आकारांवर मर्यादा असतात. JavaScript मध्ये मेमरी आकाराची गणना करण्याचा एक सामान्य दृष्टीकोन म्हणजे वापरून प्रत्येक ऑब्जेक्टचा बाइट आकार मोजणे Buffer.byteLength() ते stringifying नंतर.

या लेखात, आम्ही त्यांच्या बाइट आकारावर आधारित ऑब्जेक्टच्या ॲरेला लहान भागांत कसे विभाजित करायचे ते पाहू. फायदा करून Buffer.byteLength(), आम्ही प्रत्येक भाग निर्दिष्ट मेमरी मर्यादेत राहील याची खात्री करू शकतो, उपलब्ध मेमरी ओलांडल्यामुळे त्रुटी किंवा क्रॅश होण्यापासून प्रतिबंधित करतो.

एका व्यावहारिक उदाहरणाद्वारे, तुम्ही हे Node.js मध्ये अंमलात आणण्यासाठी सर्वोत्तम पध्दत शिकाल, मोठ्या डेटासेट हाताळताना तुमचा कोड कार्यक्षम आणि मजबूत आहे याची खात्री करून घ्या. चला उपाय शोधूया.

जावास्क्रिप्टमध्ये मेमरी साईझनुसार चंकिंग ॲरेसाठी सोल्यूशन तोडणे

मागील उदाहरणांमध्ये दिलेल्या स्क्रिप्ट्स JavaScript मधील सामान्य समस्येचे निराकरण करण्यासाठी डिझाइन केल्या आहेत: प्रत्येक भागाच्या बाइट आकाराच्या आधारावर ऑब्जेक्ट्सच्या ॲरेला लहान भागांमध्ये विभाजित करणे. हे विशेषतः एपीआय किंवा डेटाबेस इन्सर्ट सारख्या कठोर मेमरी किंवा पेलोड आकार मर्यादा असलेल्या सिस्टमसह कार्य करताना उपयुक्त आहे. वापरून बाइट्समध्ये प्रत्येक ऑब्जेक्टच्या मेमरी आकाराची गणना करून Buffer.byteLength(), आम्ही खात्री करतो की कोणताही भाग परिभाषित मेमरी मर्यादा ओलांडत नाही.

पहिला दृष्टीकोन एक पारंपारिक फायदा घेते Array.forEach() loop, जेथे ॲरेमधील प्रत्येक ऑब्जेक्टवर एक-एक करून प्रक्रिया केली जाते. प्रत्येक ऑब्जेक्टसाठी, आम्ही प्रथम ते वापरून 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 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 मध्ये ॲरे चेंकिंग करताना मेमरी वापर ऑप्टिमाइझ करणे

JavaScript मध्ये मोठ्या डेटासेटसह काम करताना, मेमरी वापर ऑप्टिमाइझ करणे आवश्यक आहे, विशेषतः Node.js सारख्या वातावरणात जेथे कार्यक्षम मेमरी व्यवस्थापन क्रॅश किंवा कार्यप्रदर्शनातील अडथळे टाळू शकते. विचारात घेण्याजोगा एक महत्त्वाचा पैलू म्हणजे वेगवेगळ्या आकाराच्या वस्तूंचे ॲरे कसे हाताळायचे. सीरियलाइज्ड करताना प्रत्येक ऑब्जेक्टमध्ये भिन्न बाइट आकार असू शकतात आणि ही परिवर्तनशीलता मेमरी वापराचा अंदाज लावणे आव्हानात्मक बनवते.

एक महत्त्वपूर्ण तंत्र वापरत आहे Buffer.byteLength() सोबत वस्तूंचे स्ट्रिंगमध्ये रूपांतर केल्यानंतर JSON.stringify(). प्रत्येक ऑब्जेक्टच्या बाइट आकाराचे मोजमाप करून, आपण जास्तीत जास्त बाइट मर्यादेपेक्षा जास्त भाग नसल्याची खात्री करून मेमरी वापर अचूकपणे नियंत्रित करू शकता. तथापि, आपले समाधान कार्यक्षम राहील याची खात्री करून, मेमरी वापरामध्ये योगदान देऊ शकणाऱ्या अनुप्रयोगाच्या इतर भागांमधील मेमरी ओव्हरहेडचा विचार करणे देखील महत्त्वाचे आहे.

बाइट आकारावर आधारित चंकिंग व्यतिरिक्त, तुम्ही अधिक प्रगत मेमरी ऑप्टिमायझेशन लागू करू शकता, जसे की मोठ्या डेटासेटसाठी स्ट्रीमिंग तंत्र वापरणे. हा दृष्टिकोन तुम्हाला संपूर्ण डेटासेट एकाच वेळी मेमरीमध्ये लोड न करता भागांमध्ये डेटा हाताळण्याची परवानगी देतो. त्रुटी हाताळणे आणि प्रमाणीकरण समाविष्ट करणे देखील मजबूत उपाय तयार करण्यात मदत करते, हे सुनिश्चित करते की अवैध डेटामुळे तुमच्या सिस्टममध्ये अनावश्यक मेमरी लीक किंवा क्रॅश होणार नाही.