Efektīva vienumu masīva sadalīšana segmentos atkarībā no JavaScript baita garuma

Atmiņai droša objektu sadalīšana pakalpojumā Node.js

Strādājot ar lieliem objektu masīviem JavaScript, īpaši Node.js, ir ļoti svarīgi efektīvi pārvaldīt atmiņu. Dažreiz jums var būt nepieciešams sadalīt šos masīvus mazākos gabalos, nodrošinot, ka katrs gabals nepārsniedz noteiktu atmiņas ierobežojumu.

Šis uzdevums kļūst īpaši svarīgs, ja strādājat ar API vai sistēmām, kurām ir stingri atmiņas ierobežojumi vai kravnesības lieluma ierobežojumi. Izplatīta pieeja atmiņas lieluma aprēķināšanai JavaScript ir katra izmantotā objekta baita lieluma mērīšana Buffer.byteLength() pēc tā stingrības.

Šajā rakstā mēs izpētīsim, kā objektu masīvu sadalīt mazākos gabalos, pamatojoties uz to baitu lielumu. Izmantojot sviras efektu Buffer.byteLength(), mēs varam nodrošināt, ka katrs fragments nepārsniedz norādīto atmiņas ierobežojumu, novēršot kļūdas vai avārijas, ko izraisa pieejamās atmiņas pārsniegšana.

Izmantojot praktisku piemēru, jūs uzzināsit, kā vislabāk to ieviest pakalpojumā Node.js, nodrošinot, ka kods ir gan efektīvs, gan stabils, apstrādājot lielas datu kopas. Iedziļināsimies risinājumā.

Risinājuma sadalīšana masīvu sadalīšanai pēc atmiņas lieluma JavaScript

Iepriekšējos piemēros sniegtie skripti ir izstrādāti, lai atrisinātu bieži sastopamu JavaScript problēmu: objektu masīva sadalīšanu mazākos gabalos, pamatojoties uz katra gabala baitu lielumu. Tas ir īpaši noderīgi, strādājot ar sistēmām, kurām ir stingri atmiņas vai lietderīgās slodzes lieluma ierobežojumi, piemēram, API vai datu bāzes ieliktņi. Aprēķinot katra objekta atmiņas lielumu baitos, izmantojot Buffer.byteLength(), mēs nodrošinām, ka neviena daļa nepārsniedz definēto atmiņas ierobežojumu.

Pirmā pieeja izmanto tradicionālo Masīvs.forEach() cilpa, kur katrs masīva objekts tiek apstrādāts pa vienam. Katram objektam mēs vispirms to pārvēršam par JSON virkni, izmantojot JSON.stringify()un pēc tam aprēķiniet tā lielumu baitos. Ja pašreizējā gabala kopējais izmērs (plus pašreizējā objekta lielums) pārsniedz maksimālo atļauto izmēru, pašreizējais gabals tiek novirzīts uz pēdējo gabalu masīvu un tiek sākts jauns gabals. Šī metode ir vienkārša, bet efektīva, nodrošinot, ka sadalīšanas process tiek veikts, pamatojoties uz faktisko atmiņas lietojumu.

Otrā pieeja izmanto Array.reduce(), kas ir tīrāka, funkcionālāka programmēšanas metode. Šajā gadījumā masīvs tiek reducēts līdz gabalu masīvam, kur objekta pievienošanas daļai vai jauna gabala sākšanas loģika tiek apstrādāta reduktora funkcijā. Šī pieeja var būt elegantāka un kodolīgāka, īpaši strādājot ar sarežģītiem masīviem. Tomēr tas kalpo tam pašam mērķim kā pirmā metode, nodrošinot, ka katrs gabals nepārsniedz norādīto baitu lieluma ierobežojumu.

Trešā pieeja ievieš uzlabotas funkcijas, piemēram, ievades validāciju un kļūdu apstrādi, padarot skriptu izturīgāku. Mēs izmantojam Array.isArray() lai pārbaudītu, vai ievade ir derīgs masīvs, un iekļautu nosacījumus, kas rada pielāgotas kļūdas, izmantojot mest jaunu kļūdu () ja ievades dati nav derīgi. Tas nodrošina, ka kods negaidīti nesabojājas, apstrādājot nepareizas ievades. Turklāt šī versija ir vairāk modulāra un strukturēta, padarot to ideāli piemērotu ražošanas līmeņa kodiem, kur drošība un veiktspēja ir ļoti svarīgas.

// 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);
}

Atmiņas lietojuma optimizēšana, sadalot masīvus JavaScript

Strādājot ar lielām JavaScript datu kopām, atmiņas lietojuma optimizēšana ir būtiska, jo īpaši tādās vidēs kā Node.js, kur efektīva atmiņas pārvaldība var novērst avārijas vai veiktspējas vājās vietas. Viens svarīgs aspekts, kas jāņem vērā, ir tas, kā rīkoties ar dažāda lieluma objektu masīviem. Katram objektam var būt dažādi baitu izmēri, kad tas ir serializēts, un šī mainīgums apgrūtina atmiņas lietojuma prognozēšanu.

Tiek izmantota svarīga tehnika Buffer.byteLength() pēc objektu pārvēršanas virknēs ar JSON.stringify(). Izmērot katra objekta baita lielumu, varat precīzi kontrolēt atmiņas lietojumu, nodrošinot, ka neviens fragments nepārsniedz maksimālo baitu ierobežojumu. Tomēr ir svarīgi ņemt vērā arī atmiņas apjomu no citām lietojumprogrammas daļām, kas var veicināt atmiņas patēriņu, nodrošinot, ka jūsu risinājums joprojām ir efektīvs.

Papildus sadalīšanai, pamatojoties uz baitu lielumu, iespējams, vēlēsities ieviest uzlabotas atmiņas optimizācijas, piemēram, izmantot straumēšanas metodes lielākām datu kopām. Šī pieeja ļauj apstrādāt datus gabalos, neielādējot atmiņā visu datu kopu uzreiz. Kļūdu apstrādes un validācijas iekļaušana palīdz arī izveidot stabilus risinājumus, nodrošinot, ka nederīgi dati neizraisa nevajadzīgas atmiņas noplūdes vai avārijas jūsu sistēmā.