Skapa dynamiska objektpar i JavaScript med hjälp av objektmetoder

Dela upp JavaScript-objekt i par med hjälp av objektmetoder

JavaScript Front-End-skript som använder Object.entries() och Array-metoder

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

Skapa dynamiska objektpar med hjälp av JavaScripts reduceringsmetod

JavaScript Front-End-skript som använder Object.keys() och 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);

Backend Node.js-skript för bearbetning av objekt med materialbredd

Node.js Backend-skript som använder modulära funktioner för objektmappning

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

Vanliga frågor om JavaScript-objektmetoder

1. Vad gör Object.fromEntries() göra i JavaScript?
2. Object.fromEntries() konverterar en array av nyckel-värdepar tillbaka till ett objekt och vänder på funktionaliteten av Object.entries().
3. Hur kan jag slå samman två objekt i JavaScript?
4. Du kan använda Object.assign() metod för att slå samman två eller flera objekt till ett, kombinera deras egenskaper.
5. Vad är skillnaden mellan Object.keys() och Object.values()?
6. Object.keys() returnerar en array av objektets egenskapsnamn, while Object.values() returnerar en matris med objektets egenskapsvärden.
7. Hur kan jag klona ett objekt i JavaScript?
8. För att klona ett objekt kan du använda Object.assign(), vilket skapar en ytlig kopia av originalobjektet.
9. Burk reduce() användas för objekt i JavaScript?
10. Ja, reduce() kan appliceras på arrayer av nyckel-värdepar härledda från objekt, så att du kan bygga nya strukturer eller beräkna data.

Slutliga tankar om JavaScript-objektmetoder

JavaScript tillhandahåller kraftfulla verktyg för att manipulera objekt, vilket visas av de tekniker som används för att dela upp objekt i parade nyckel-värdestrukturer. Metoder som Object.keys() och minska() hjälpa till att förenkla komplexa datatransformationer.

Genom att behärska dessa objektmetoder kan utvecklare skapa renare, mer underhållbar kod som skalas väl i både front-end- och back-end-miljöer. Detta tillvägagångssätt är idealiskt för projekt som kräver dynamiskt objektskapande och effektiv datahantering.