ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿನ ಬೈಟ್ ಉದ್ದವನ್ನು ಅವಲಂಬಿಸಿ ಐಟಂಗಳ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಭಾಗಗಳಾಗಿ ಪರಿಣಾಮಕಾರಿಯಾಗಿ ವಿಭಜಿಸುವುದು

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(). ಪ್ರತಿಯೊಂದು ವಸ್ತುವಿನ ಬೈಟ್ ಗಾತ್ರವನ್ನು ಅಳೆಯುವ ಮೂಲಕ, ಯಾವುದೇ ಚಂಕ್ ಗರಿಷ್ಠ ಬೈಟ್ ಮಿತಿಯನ್ನು ಮೀರುವುದಿಲ್ಲ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವ ಮೂಲಕ ನೀವು ಮೆಮೊರಿ ಬಳಕೆಯನ್ನು ನಿಖರವಾಗಿ ನಿಯಂತ್ರಿಸಬಹುದು. ಆದಾಗ್ಯೂ, ಮೆಮೊರಿ ಬಳಕೆಗೆ ಕೊಡುಗೆ ನೀಡಬಹುದಾದ ಅಪ್ಲಿಕೇಶನ್‌ನ ಇತರ ಭಾಗಗಳಿಂದ ಮೆಮೊರಿ ಓವರ್‌ಹೆಡ್ ಅನ್ನು ಪರಿಗಣಿಸುವುದು ಸಹ ಮುಖ್ಯವಾಗಿದೆ, ನಿಮ್ಮ ಪರಿಹಾರವು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಉಳಿಯುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.

ಬೈಟ್ ಗಾತ್ರದ ಆಧಾರದ ಮೇಲೆ ಚಂಕ್ ಮಾಡುವುದರ ಜೊತೆಗೆ, ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ಗಳಿಗಾಗಿ ಸ್ಟ್ರೀಮಿಂಗ್ ತಂತ್ರಗಳನ್ನು ಬಳಸುವಂತಹ ಹೆಚ್ಚು ಸುಧಾರಿತ ಮೆಮೊರಿ ಆಪ್ಟಿಮೈಸೇಶನ್‌ಗಳನ್ನು ನೀವು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಬಯಸಬಹುದು. ಈ ವಿಧಾನವು ಸಂಪೂರ್ಣ ಡೇಟಾಸೆಟ್ ಅನ್ನು ಒಮ್ಮೆ ಮೆಮೊರಿಗೆ ಲೋಡ್ ಮಾಡದೆಯೇ ಡೇಟಾವನ್ನು ಭಾಗಗಳಲ್ಲಿ ನಿರ್ವಹಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ದೋಷ ನಿರ್ವಹಣೆ ಮತ್ತು ಊರ್ಜಿತಗೊಳಿಸುವಿಕೆಯನ್ನು ಸಂಯೋಜಿಸುವುದು ದೃಢವಾದ ಪರಿಹಾರಗಳನ್ನು ನಿರ್ಮಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ, ಅಮಾನ್ಯ ಡೇಟಾವು ನಿಮ್ಮ ಸಿಸ್ಟಮ್‌ನಲ್ಲಿ ಅನಗತ್ಯ ಮೆಮೊರಿ ಸೋರಿಕೆಗಳು ಅಥವಾ ಕ್ರ್ಯಾಶ್‌ಗಳಿಗೆ ಕಾರಣವಾಗುವುದಿಲ್ಲ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.