Création de paires d'objets dynamiques en JavaScript à l'aide de méthodes d'objet

Décomposer les objets JavaScript en paires à l'aide de méthodes d'objet

Script frontal JavaScript utilisant les méthodes Object.entries() et 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));

Création de paires d'objets dynamiques à l'aide de la méthode de réduction de JavaScript

Script frontal JavaScript utilisant Object.keys() et 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 pour le traitement des objets de largeur de matériau

Script backend Node.js utilisant des fonctions modulaires pour le mappage d'objets

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

Questions fréquemment posées sur les méthodes d'objet JavaScript

1. Qu'est-ce que Object.fromEntries() faire en JavaScript ?
2. Object.fromEntries() convertit un tableau de paires clé-valeur en un objet, inversant la fonctionnalité de Object.entries().
3. Comment fusionner deux objets en JavaScript ?
4. Vous pouvez utiliser le Object.assign() méthode pour fusionner deux ou plusieurs objets en un seul, combinant leurs propriétés.
5. Quelle est la différence entre Object.keys() et Object.values()?
6. Object.keys() renvoie un tableau des noms de propriétés de l'objet, tandis que Object.values() renvoie un tableau des valeurs des propriétés de l'objet.
7. Comment cloner un objet en JavaScript ?
8. Pour cloner un objet, vous pouvez utiliser Object.assign(), qui crée une copie superficielle de l'objet original.
9. Peut reduce() être utilisé pour les objets en JavaScript ?
10. Oui, reduce() peut être appliqué à des tableaux de paires clé-valeur dérivées d'objets, vous permettant de créer de nouvelles structures ou de calculer des données.

Réflexions finales sur les méthodes d'objet JavaScript

JavaScript fournit des outils puissants pour manipuler des objets, comme le démontrent les techniques utilisées pour diviser les objets en structures clé-valeur appariées. Des méthodes comme Objet.keys() et réduire() aider à simplifier les transformations de données complexes.

En maîtrisant ces méthodes objet, les développeurs peuvent créer un code plus propre et plus maintenable qui s'adapte bien aux environnements front-end et back-end. Cette approche est idéale pour les projets nécessitant la création d’objets dynamiques et une gestion efficace des données.