स्तंभ मान द्वारा 2 आयामी सरणी कैसे सॉर्ट करें?

Question 1

क्या कोई भी मुझे जावास्क्रिप्ट में 2 आयामी ऐरे को सॉर्ट करने में मदद कर सकता है?

यह निम्नलिखित प्रारूप में डेटा होगा:

[12, AAA]
[58, BBB]
[28, CCC]
[18, DDD]

छाँटे जाने पर इसे इस तरह दिखना चाहिए:

[12, AAA]
[18, DDD]
[28, CCC]
[58, BBB]

तो मूल रूप से, पहले कॉलम द्वारा छँटाई।

चियर्स

Question 2

यह इतना आसान है:

var a = [[12, 'AAA'], [58, 'BBB'], [28, 'CCC'],[18, 'DDD']];

a.sort(sortFunction);

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

मैं आपको प्रलेखन पढ़ने के लिए आमंत्रित करता हूं ।

यदि आप दूसरे कॉलम को क्रमबद्ध करना चाहते हैं, तो आप ऐसा कर सकते हैं:

a.sort(compareSecondColumn);

function compareSecondColumn(a, b) {
    if (a[1] === b[1]) {
        return 0;
    }
    else {
        return (a[1] < b[1]) ? -1 : 1;
    }
}

Question 3

सबसे अच्छा तरीका निम्नलिखित का उपयोग करना होगा, क्योंकि पहले कॉलम में दोहराव वाले मूल्य हो सकते हैं।

var arr = [[12, 'AAA'], [12, 'BBB'], [12, 'CCC'],[28, 'DDD'], [18, 'CCC'],[12, 'DDD'],[18, 'CCC'],[28, 'DDD'],[28, 'DDD'],[58, 'BBB'],[68, 'BBB'],[78, 'BBB']];

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

Question 4

इसे इस्तेमाल करे

//WITH FIRST COLUMN
arr = arr.sort(function(a,b) {
    return a[0] - b[0];
});


//WITH SECOND COLUMN
arr = arr.sort(function(a,b) {
    return a[1] - b[1];
});

नोट: मूल उत्तर का उपयोग माइनस (-) के बजाय (>) से अधिक किया गया है, जो कि टिप्पणियों को गलत बता रहा है।

Question 5

तीर फ़ंक्शन का उपयोग करना, और दूसरे स्ट्रिंग फ़ील्ड द्वारा छंटनी

var a = [[12, 'CCC'], [58, 'AAA'], [57, 'DDD'], [28, 'CCC'],[18, 'BBB']];
a.sort((a, b) => a[1].localeCompare(b[1]));
console.log(a)

स्निपेट का विस्तार करें

Question 6

यदि आप मेरे जैसे कुछ भी हैं, तो आप हर बार जब आप अपने द्वारा छांटे जा रहे कॉलम को बदलना चाहते हैं, तो आप प्रत्येक सूचकांक को बदलना नहीं चाहेंगे।

function sortByColumn(a, colIndex){

    a.sort(sortFunction);

    function sortFunction(a, b) {
        if (a[colIndex] === b[colIndex]) {
            return 0;
        }
        else {
            return (a[colIndex] < b[colIndex]) ? -1 : 1;
        }
    }

    return a;
}

var sorted_a = sortByColumn(a, 2);

Question 7

कुछ भी विशेष नहीं है, केवल एक सरणी से निश्चित सूचकांक पर एक मूल्य वापस करने के लिए लागत बचाने के लिए।

function sortByCol(arr, colIndex){
    arr.sort(sortFunction)
    function sortFunction(a, b) {
        a = a[colIndex]
        b = b[colIndex]
        return (a === b) ? 0 : (a < b) ? -1 : 1
    }
}
// Usage
var a = [[12, 'AAA'], [58, 'BBB'], [28, 'CCC'],[18, 'DDD']]
sortByCol(a, 0)
console.log(JSON.stringify(a))
// "[[12,"AAA"],[18,"DDD"],[28,"CCC"],[58,"BBB"]]"

Question 8

एक पंक्ति में:

var cars = [
  {type:"Volvo", year:2016},
  {type:"Saab", year:2001},
  {type:"BMW", year:2010}
]


function myFunction() {
  return cars.sort((a, b)=> a.year - b.year)
}

Question 9

यदि आप पहले कॉलम (जिसमें संख्या मान शामिल है) के आधार पर छाँटना चाहते हैं , तो यह कोशिश करें:

arr.sort(function(a,b){
  return a[0]-b[0]
})

यदि आप दूसरे कॉलम के आधार पर छांटना चाहते हैं (जिसमें स्ट्रिंग मान शामिल है), तो यह कोशिश करें:

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

दूसरे मामले के लिए PS, आपको उनके ASCII मूल्यों के बीच तुलना करने की आवश्यकता है।

उम्मीद है की यह मदद करेगा।

Question 10

जैसा कि मेरे usecase में दर्जनों कॉलम शामिल हैं, मैंने @ jahroy के उत्तर को थोड़ा विस्तारित किया। (यह भी एहसास हुआ कि @ charles- क्लेटन का भी यही विचार था।)
मैं उस पैरामीटर को पास करता हूं जिसे मैं क्रमबद्ध करना चाहता हूं, और उस पर जगह लेने के लिए वांछित फ़ंक्शन के साथ सॉर्ट फ़ंक्शन को फिर से परिभाषित किया जाता है।

var ID_COLUMN=0
var URL_COLUMN=1

findings.sort(compareByColumnIndex(URL_COLUMN))

function compareByColumnIndex(index) {
  return function(a,b){
    if (a[index] === b[index]) {
        return 0;
    }
    else {
        return (a[index] < b[index]) ? -1 : 1;
    }
  }
}

Question 11

चार्ल्स-क्लेटन और @ विकस-गौतम के कंधों पर खड़े होकर, मैंने स्ट्रिंग टेस्ट को जोड़ा, जो ओपी की तरह एक कॉलम में होता है।

return isNaN(a-b) ? (a === b) ? 0 : (a < b) ? -1 : 1 : a-b  ;

परीक्षण isNaN(a-b)यह निर्धारित करता है कि क्या तारों को संख्याओं के साथ ज़ब्त नहीं किया जा सकता है। यदि वे कर सकते हैं तो a-bपरीक्षण मान्य है।

ध्यान दें कि मिश्रित प्रकारों के एक कॉलम को छांटना हमेशा एक मनोरंजक परिणाम देगा क्योंकि सख्त समानता परीक्षण (a === b)हमेशा गलत वापस आएगा। एमडीएन यहां देखें

यह Google अनुप्रयोग स्क्रिप्ट का उपयोग करके लकड़हारा परीक्षण के साथ पूरी स्क्रिप्ट है।

function testSort(){

function sortByCol(arr, colIndex){
    arr.sort(sortFunction);
    function sortFunction(a, b) {
        a = a[colIndex];
        b = b[colIndex];
       return isNaN(a-b) ? (a === b) ? 0 : (a < b) ? -1 : 1 : a-b  ;  // test if text string - ie cannot be coerced to numbers.
       // Note that sorting a column of mixed types will always give an entertaining result as the strict equality test will always return false
       // see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Equality_comparisons_and_sameness

       }
}
// Usage
var a = [ [12,'12', 'AAA'],
          [12,'11', 'AAB'],
          [58,'120', 'CCC'],
          [28,'08', 'BBB'],
          [18,'80', 'DDD'],
        ]
    var arr1 = a.map(function (i){return i;}).sort();  // use map to ensure tests are not corrupted by a sort in-place.

    Logger.log("Original unsorted:\n     " + JSON.stringify(a));
    Logger.log("Vanilla sort:\n     " + JSON.stringify(arr1));
    sortByCol(a, 0);
    Logger.log("By col 0:\n     " + JSON.stringify(a));
    sortByCol(a, 1);
    Logger.log("By col 1:\n     " + JSON.stringify(a));
    sortByCol(a, 2);
    Logger.log("By col 2:\n     " + JSON.stringify(a));

/* vanilla sort returns " [
                            [12,"11","AAB"],
                            [12,"12","AAA"],
                            [18,"80","DDD"],
                            [28,"08","BBB"],
                            [58,"120","CCC"]
                          ]
   if col 0 then returns "[
                            [12,'12',"AAA"],
                            [12,'11', 'AAB'],
                            [18,'80',"DDD"],
                            [28,'08',"BBB"],
                            [58,'120',"CCC"]
                          ]"
   if col 1 then returns "[
                            [28,'08',"BBB"],
                            [12,'11', 'AAB'],
                            [12,'12',"AAA"],
                            [18,'80',"DDD"],
                            [58,'120',"CCC"],

                          ]"
   if col 2 then returns "[
                            [12,'12',"AAA"],
                            [12,'11', 'AAB'],
                            [28,'08',"BBB"],
                            [58,'120',"CCC"],
                            [18,'80',"DDD"],
                          ]"
*/

}