मेरे पास एक सरणी है:

[{
    name: "A1"
    series: "A series"
}, 
{
    name: "A2"
    series: "A series"
}, 
{
    name: "B1"
    series: "B series"
}, 
{
    name: "C1"
    // series is not defined
}]

मैं इस सरणी को श्रृंखला संपत्ति के उनके मूल्यों के आधार पर समूहीकृत कई सरणियों में विभाजित करना चाहता हूं। मैं नीचे की संरचना की तरह कुछ पर पहुंचना चाहता हूं। लेकिन जब तक परिणाम में श्रृंखला संपत्ति के उनके मूल्यों द्वारा समूहीकृत सरणियाँ होती हैं, तब तक सटीक प्रारूप कोई मायने नहीं रखता।

[
    {
        series: "A series",
        items: [{
            name: "A1"
        },
        {
            name: "A2"
        }]
    },
    {
        series: "B series",
        items: [{
            name: "B1"
        }]
    }
    {
        items: [{
            name: "C1"
        }]
    }
]

यहाँ मेरा सबसे अच्छा प्रयास है:

private groupProductsBySeries = (devices: IItem[]): IProductGroup[] => {
    const seriesSymbols: any = new Map();
    const itemsBySeries: any = [];
    const series: any = [];

    devices.forEach((device) => {
        let symbol = seriesSymbols.get(device.properties.series);
        if (!symbol) {
            symbol = Symbol();
            seriesSymbols.set(device.properties.series, symbol);
        }

        Array.isArray(itemsBySeries[symbol])
            ? itemsBySeries[symbol].push(device)
            : (itemsBySeries[symbol] = [device]);
    });

    seriesSymbols.forEach((value: any, key: any) => {
        series.push({
            name: key,
            items: itemsBySeries[value],
        });
    });

    return series;
};

मैं सोच रहा हूं कि शायद यह अनावश्यक रूप से जटिल है। और जब मैं प्रकार जोड़ने की कोशिश करता हूं, तो मुझे टाइपस्क्रिप्ट कंपाइलर से शिकायतें मिलती हैं।

प्रश्न:

  • क्या इस समस्या को हल करने का कोई बेहतर तरीका है?
  • यदि नहीं, तो उपरोक्त कोड सफलतापूर्वक जोड़े गए प्रकारों के साथ कैसा दिखेगा? अगर नहीं

एडिगस टिप्पणी के बाद संपादित

1
user1283776 8 अक्टूबर 2019, 12:35

3 जवाब

सबसे बढ़िया उत्तर
function groupProductsBySeries(devices) {
  const series = Array.from(new Set(devices.map(item => item.series)));
  return series.map(item => {
    const series = item ? { series: item } : null;

    return {
      ...series,
      items: devices.filter(device => device.series === item)
    };
  });
}
1
f278f1b2 8 अक्टूबर 2019, 12:56

मैं प्रत्येक ऑब्जेक्ट के name और series गुणों पर पुनरावृति करता हूं, series के साथ खाली स्ट्रिंग को डिफॉल्ट करता है यदि खाली है, तो उस ऑब्जेक्ट पर मान डालते हैं जिसके गुण हैं series पर पुनरावृति की जा रही है, और उस श्रृंखला की संबद्ध वस्तु (नेस्टेड items सरणी के साथ)। यदि इस पर अभी तक कोई श्रृंखला मौजूद नहीं है, तो यदि आवश्यक हो तो इसे बनाएं (और यदि आवश्यक हो तो series संपत्ति असाइन करें), अन्यथा केवल { name } को धक्का दें।

अंत में, अपना वांछित आउटपुट प्राप्त करने के लिए ऑब्जेक्ट के मान लें:

const arr = [
    {
        name: 'A1',
        series: 'A series',
    },
    {
        name: 'A2',
        series: 'A series',
    },
    {
        name: 'B1',
        series: 'B series',
    },
    {
        name: 'C1',
    // series is not defined
    },
];
type outputItem = {
    series?: string,
    items: Array<{ name: string }>,
};
const groupedObj: { [series: string]: outputItem } = {};
for (const { name, series='' } of arr) {
    if (!groupedObj[series]) {
        groupedObj[series] = { items: [{ name }] };
        if (series) {
            groupedObj[series].series = series;
        }
    } else {
        groupedObj[series].items.push({ name });
    }
}
const output = Object.values(groupedObj);
console.log(output);

जावास्क्रिप्ट में अनुवादित:

"use strict";
const arr = [
    {
        name: 'A1',
        series: 'A series',
    },
    {
        name: 'A2',
        series: 'A series',
    },
    {
        name: 'B1',
        series: 'B series',
    },
    {
        name: 'C1',
    },
];
const groupedObj = {};
for (const { name, series = '' } of arr) {
    if (!groupedObj[series]) {
        groupedObj[series] = { items: [{ name }] };
        if (series) {
            groupedObj[series].series = series;
        }
    }
    else {
        groupedObj[series].items.push({ name });
    }
}
const output = Object.values(groupedObj);
console.log(output);

हालाँकि, यह वस्तु संरचना बहुत ही अजीब है। किसी एक वस्तु के साथ काम करना शायद बहुत आसान होगा, जिसकी कुंजियाँ series हैं, और जिनके मान name मानों के सरणियाँ हैं:

const arr = [
    {
        name: 'A1',
        series: 'A series',
    },
    {
        name: 'A2',
        series: 'A series',
    },
    {
        name: 'B1',
        series: 'B series',
    },
    {
        name: 'C1',
    // series is not defined
    },
];
const output: { [series: string]: string[] } = {};
for (const { name, series='' } of arr) {
    if (!output[series]) {
        output[series] = [name];
    } else {
        output[series].push(name);
    }
}
console.log(output);

जावास्क्रिप्ट में अनुवादित:

"use strict";
const arr = [
    {
        name: 'A1',
        series: 'A series',
    },
    {
        name: 'A2',
        series: 'A series',
    },
    {
        name: 'B1',
        series: 'B series',
    },
    {
        name: 'C1',
    },
];
const output = {};
for (const { name, series = '' } of arr) {
    if (!output[series]) {
        output[series] = [name];
    }
    else {
        output[series].push(name);
    }
}
console.log(output);
-1
CertainPerformance 8 अक्टूबर 2019, 23:40

आप एक सामान्य कार्य लिख सकते हैं जो उनके द्वारा किसी भी क्षेत्र और समूह को स्वीकार करता है। नीचे जैसा कुछ मदद कर सकता है।

data = [{
    name: "A1",
    series: "A series"
}, 
{
    name: "A2",
    series: "A series"
}, 
{
    name: "B1",
    series: "B series"
}, 
{
    name: "C1",
    // series is not defined
}]

data1 = [{
    name: "A",
    series: "A series"
}, 
{
    name: "A",
    series: "A series"
}, 
{
    name: "B",
    series: "B series"
}, 
{
    name: "C",
    // series is not defined
}]


function groupByField(data, field){
    const groupedByObject = data.reduce((acc, val) => {
        const rest = Object.keys(val).reduce((newObj, key) => {
            if(key !== field){
                newObj[key] = val[key]
            }
            return newObj;
        }, {});
        if (acc[val[field]]) {
          acc[val[field]].push(rest);
        } else {;
          acc[val[field]] = [rest];
        }
        return acc;
    }, {})

    //Return the reduced object from above if want in Object format. If wanted array, return the below statement

    return Object.keys(groupedByObject).filter(a => a!== "undefined").map(key => ({[field]: key, items: groupedByObject[key]}))

}

a = groupByField(data,"series");
console.log("Grouped by series")
console.log(a);



b = groupByField(data1, "name");
console.log("Grouped by name")
console.log(b);
-1
Nithin Thampi 9 अक्टूबर 2019, 15:40