मैं इसे समझ नहीं पा रहा हूं।

var arr = [
[ {'value': 3, 'id': 'ab'},  {'value': 1, 'id': 'ab'},  {'value': 5, 'id': 'ab'} ],
[ {'value': 6, 'id': 'bc'},  {'value': 3, 'id': 'bc'},  {'value': 4, 'id': 'bc'} ],
[ {'value': 1, 'id': 'cd'},  {'value': 3, 'id': 'cd'},  {'value': 2, 'id': 'de'} ],
]

मेरे पास एक सरणी गिरफ्तारी है। arr[0], arr[1] और arr[2] सभी में समान मात्रा में ऑब्जेक्ट होते हैं।

मैं गिरफ्तारी [1] द्वारा पूरी सरणी को सॉर्ट करना चाहता हूं। उदाहरण के लिए

var result = [
[ {'value': 1, 'id': 'ab'},  {'value': 5, 'id': 'ab'}, {'value': 3, 'id': 'ab'}, ],
[ {'value': 3, 'id': 'bc'},  {'value': 4, 'id': 'bc'}, {'value': 6, 'id': 'bc'}, ],
[ {'value': 3, 'id': 'cd'},  {'value': 2, 'id': 'de'}, {'value': 1, 'id': 'cd'}, ],
]

-> गिरफ्तारी [1] अब 'मान' (3,4,6) द्वारा क्रमबद्ध है। गिरफ्तारी [0] और गिरफ्तारी [2] में संबंधित मान भी 'क्रमबद्ध' थे। यदि गिरफ्तारी [1] [१] गिरफ्तारी के कारण शुरुआत में चलती है [१] सही ढंग से क्रमबद्ध किया जा रहा है, तो गिरफ्तारी [०] [१] और गिरफ्तारी [२] [१] करता है।

सॉर्ट करने से पहले

3 1 5
6 3 4
1 3 2

छँटाई के बाद

1 5 3 <- 1 is 'linked' to 3 in 2nd row, 5 is 'linked' to 4 in 2nd row, etc.
3 4 6 <- sorted
3 2 1 <- 3 is 'linked' to 3 in 2nd row, 2 is 'linked' to 4 in 2nd row, etc.

उदा. मैं गिरफ्तारी [१] का उपयोग करके सॉर्ट कर सकता हूं

arr[1].sort(function(a,b) {
    return a.value-b.value
});

लेकिन निश्चित रूप से यह एआर [0] और एआर [2] को नहीं बदलता जैसा मैं चाहता हूं। जाहिर है कि यही सच है

arr.forEach(item =>
item.sort(function(a,b) {
    return a.value-b.value
}));

जो केवल प्रत्येक सरणी को अलग से सॉर्ट करता है।

संभव है उदा। ए और बी के सूचकांक प्राप्त करने के लिए ताकि मैं वस्तुओं को एआर [0] और एआर [1] में स्थानांतरित कर सकूं?

किसी भी प्रकार की मदद की बेहद सराहना की जाती है!

0
lledpoly 17 जिंदा 2020, 20:01

2 जवाब

सबसे बढ़िया उत्तर

यहाँ एक विधि है जो सबसे पहले वस्तुओं के क्रम की गणना करती है।
फिर प्रत्येक पंक्ति को उसी तरह सॉर्ट करने के लिए उस सॉर्ट ऑर्डर का उपयोग करता है।

var arr = [
  [ {'value': 3, 'id': 'ab'}, {'value': 1, 'id': 'ab'}, {'value': 5, 'id': 'ab'} ],
  [ {'value': 6, 'id': 'bc'}, {'value': 3, 'id': 'bc'}, {'value': 4, 'id': 'bc'} ], 
  [ {'value': 1, 'id': 'cd'}, {'value': 3, 'id': 'cd'}, {'value': 2, 'id': 'de'} ]
];

function sortArrayColumnsByIndex(arr2dOfObj, rowindex, objkey) {
    let rownum = rowindex || 0;
    let key = objkey || Object.keys(arr2dOfObj[0][0])[0];
    let sortorder = arr2dOfObj[rownum]
         .map((x,i)=>[x,i])
         .sort((a, b) => a[0][key] < b[0][key] ? -1 : a[0][key] > b[0][key] ? 1 : 0) 
         .map(x=>x[1]);

    arr2dOfObj.forEach( 
       (row, idx) => {
       let sorted = [];
       sortorder.forEach( (y) => {
         sorted.push(row[y]);
       })
       arr2dOfObj[idx] = sorted;
      }
  );
}

sortArrayColumnsByIndex(arr, 1, 'value');

console.log(JSON.stringify(arr))
0
LukStorms 19 जिंदा 2020, 00:30

शायद सबसे सुरुचिपूर्ण समाधान नहीं है, लेकिन मैं सरणी को स्थानांतरित करता हूं, फिर इसे सॉर्ट करता हूं और फिर इसे मूल रूप में वापस स्थानांतरित करता हूं।

// sort array accordingly to this row
let i = 1;

var arr = [
[ {'value': 1, 'id': 'ab'},  {'value': 6, 'id': 'ab'},  {'value': 3, 'id': 'ab'} ],
[ {'value': 3, 'id': 'bc'},  {'value': 1, 'id': 'bc'},  {'value': 4, 'id': 'bc'} ],
[ {'value': 2, 'id': 'cd'},  {'value': 1, 'id': 'cd'},  {'value': 8, 'id': 'cd'} ],
]

function transpose(m) {
    return Object.keys(m[0]).map(function(a) {
        return m.map(function(b) { return b[a]; });
    });
}

arr = transpose(arr);

arr.sort(function sortFunction(a, b) {
    if (a[i].value === b[i].value) {
        return 0;
    }
    else {
        return (a[i].value < b[i].value) ? -1 : 1;
    }
})

arr = transpose(arr);

console.log(arr);

0
lledpoly 18 जिंदा 2020, 11:41