Dinamikus objektumpárok létrehozása JavaScriptben objektummódszerekkel

JavaScript objektumok párokra bontása objektummódszerekkel

JavaScript Front-End Script Object.entries() és Array Methods használatával

// Sample input object with materials and widths
const input = {
  'material-1': '0250',
  'material-2': '8963',
  'width-1': '10',
  'width-2': '25'
};

// Function to create an array of objects based on matching indices
function splitObjectIntoPairs(obj) {
  const result = [];
  const materials = Object.entries(obj).filter(([key]) => key.includes('material'));
  const widths = Object.entries(obj).filter(([key]) => key.includes('width'));
  for (let i = 0; i < materials.length; i++) {
    const materialObj = {};
    materialObj[materials[i][0]] = materials[i][1];
    materialObj[widths[i][0]] = widths[i][1];
    result.push(materialObj);
  }
  return result;
}

// Test the function
console.log(splitObjectIntoPairs(input));

Dinamikus objektumpárok létrehozása a JavaScript Reduce módszerével

JavaScript Front-End Script Object.keys() és Array.reduce() használatával

// Sample input object
const data = {
  'material-1': '0250',
  'material-2': '8963',
  'width-1': '10',
  'width-2': '25'
};

// Function to group object pairs using reduce
function groupPairs(obj) {
  return Object.keys(obj).reduce((acc, key) => {
    const match = key.match(/(\w+)-(\d+)/);
    if (match) {
      const [_, type, id] = match;
      if (!acc[id]) acc[id] = {};
      acc[id][key] = obj[key];
    }
    return acc;
  }, {});
}

// Convert result object into an array of objects
const pairsArray = Object.values(groupPairs(data));
console.log(pairsArray);

Háttér Node.js szkript anyagszélességű objektumok feldolgozásához

Node.js háttérszkript, amely moduláris függvényeket használ az objektum-leképezéshez

const materialsAndWidths = {
  'material-1': '0250',
  'material-2': '8963',
  'width-1': '10',
  'width-2': '25'
};

// Function to process and map objects into key-value pairs
function mapObjects(obj) {
  const output = [];
  const materials = Object.keys(obj).filter(k => k.startsWith('material'));
  const widths = Object.keys(obj).filter(k => k.startsWith('width'));
  materials.forEach((key, index) => {
    const materialKey = key;
    const widthKey = widths[index];
    output.push({
      [materialKey]: obj[materialKey],
      [widthKey]: obj[widthKey]
    });
  });
  return output;
}

// Call function and display results
const result = mapObjects(materialsAndWidths);
console.log(result);

// Module export for reuse in different environments
module.exports = { mapObjects };

Gyakran Ismételt Kérdések a JavaScript-objektum módszerekkel kapcsolatban

1. Mit tesz Object.fromEntries() csináld JavaScriptben?
2. Object.fromEntries() kulcs-érték párok tömbjét alakítja vissza objektummá, megfordítva a funkcionalitást Object.entries().
3. Hogyan egyesíthetek két objektumot JavaScriptben?
4. Használhatja a Object.assign() módszer két vagy több objektum egyesítésére, tulajdonságaik kombinálásával.
5. Mi a különbség között Object.keys() és Object.values()?
6. Object.keys() visszaadja az objektum tulajdonságneveinek tömbjét, míg Object.values() az objektum tulajdonságértékeinek tömbjét adja vissza.
7. Hogyan klónozhatok egy objektumot JavaScriptben?
8. Egy objektum klónozásához használhatja Object.assign(), amely az eredeti objektum sekély másolatát hozza létre.
9. Tud reduce() JavaScript objektumokhoz használható?
10. Igen, reduce() objektumokból származó kulcs-érték párok tömbjére alkalmazható, lehetővé téve új struktúrák felépítését vagy adatok kiszámítását.

Utolsó gondolatok a JavaScript objektum módszereiről

A JavaScript hatékony eszközöket biztosít az objektumok manipulálásához, amint azt az objektumok páros kulcsérték-struktúrákra való felosztására használt technikák is bizonyítják. Módszerek, mint Object.keys() és csökkenti() segít leegyszerűsíteni az összetett adatátalakításokat.

Ezen objektummetódusok elsajátításával a fejlesztők tisztább, karbantarthatóbb kódot hozhatnak létre, amely jól skálázható előtér- és háttérkörnyezetben egyaránt. Ez a megközelítés ideális olyan projektekhez, amelyek dinamikus objektum-létrehozást és hatékony adatkezelést igényelnek.