Creazione di coppie di oggetti dinamici in JavaScript utilizzando metodi di oggetti

Suddivisione degli oggetti JavaScript in coppie utilizzando i metodi degli oggetti

Script front-end JavaScript che utilizza Object.entries() e metodi Array

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

Creazione di coppie di oggetti dinamici utilizzando il metodo Reduce di JavaScript

Script front-end JavaScript che utilizza Object.keys() e Array.reduce()

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

Script backend Node.js per l'elaborazione di oggetti di larghezza materiale

Script backend Node.js che utilizza funzioni modulari per la mappatura degli oggetti

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

Domande frequenti sui metodi degli oggetti JavaScript

1. Cosa fa Object.fromEntries() fare in JavaScript?
2. Object.fromEntries() riconverte un array di coppie chiave-valore in un oggetto, invertendo la funzionalità di Object.entries().
3. Come posso unire due oggetti in JavaScript?
4. Puoi usare il Object.assign() metodo per unire due o più oggetti in uno solo, combinando le loro proprietà.
5. Qual è la differenza tra Object.keys() E Object.values()?
6. Object.keys() restituisce un array dei nomi delle proprietà dell'oggetto, mentre Object.values() restituisce un array dei valori delle proprietà dell'oggetto.
7. Come posso clonare un oggetto in JavaScript?
8. Per clonare un oggetto, puoi usare Object.assign(), che crea una copia superficiale dell'oggetto originale.
9. Potere reduce() essere utilizzato per oggetti in JavaScript?
10. SÌ, reduce() può essere applicato a array di coppie chiave-valore derivate da oggetti, consentendo di creare nuove strutture o calcolare dati.

Considerazioni finali sui metodi degli oggetti JavaScript

JavaScript fornisce potenti strumenti per manipolare gli oggetti, come dimostrato dalle tecniche utilizzate per dividere gli oggetti in strutture chiave-valore accoppiate. Metodi come Object.keys() E ridurre() contribuire a semplificare trasformazioni complesse di dati.

Padroneggiando questi metodi degli oggetti, gli sviluppatori possono creare codice più pulito e facilmente gestibile che si adatta bene sia agli ambienti front-end che a quelli back-end. Questo approccio è ideale per progetti che richiedono la creazione dinamica di oggetti e una gestione efficiente dei dati.