सरणी की एक संपत्ति पर वर्णानुक्रम में वस्तुओं को क्रमबद्ध करें

Question

मान लीजिए कि आपके पास इस तरह एक जावास्क्रिप्ट वर्ग है

var DepartmentFactory = function(data) {
    this.id = data.Id;
    this.name = data.DepartmentName;
    this.active = data.Active;
}

मान लीजिए कि आप उस वर्ग के कई उदाहरण बनाते हैं और उन्हें एक सरणी में संग्रहीत करते हैं

var objArray = [];
objArray.push(DepartmentFactory({Id: 1, DepartmentName: 'Marketing', Active: true}));
objArray.push(DepartmentFactory({Id: 2, DepartmentName: 'Sales', Active: true}));
objArray.push(DepartmentFactory({Id: 3, DepartmentName: 'Development', Active: true}));
objArray.push(DepartmentFactory({Id: 4, DepartmentName: 'Accounting', Active: true}));

इसलिए मेरे पास अब बनाई गई वस्तुओं की एक सरणी होगी DepartmentFactory । मैं प्रत्येक ऑब्जेक्ट array.sort()की DepartmentNameसंपत्ति द्वारा इस सरणी को सॉर्ट करने के लिए विधि का उपयोग करने के बारे में कैसे जाऊंगा ?

array.sort()विधि ठीक काम करता है जब तार की एक सरणी छँटाई

var myarray=["Bob", "Bully", "Amy"];
myarray.sort(); //Array now becomes ["Amy", "Bob", "Bully"]

लेकिन मैं इसे वस्तुओं की सूची के साथ कैसे काम करूं?

Comments

आप .sort () के पहले तर्क के रूप में एक प्रकार का फ़ंक्शन पास कर सकते हैं।

— पॉल टॉम्बलिन

चूंकि आप DepartmentFactoryएक कंस्ट्रक्टर के रूप में उपयोग कर रहे हैं , इसलिए इसका उपयोग करके ऑब्जेक्ट बनाएं new DepartmentFactory, अन्यथा सरणी undefinedमानों के एक समूह से भर जाएगी ।

— अनुराग

Answer 1

आपको कुछ इस तरह करना होगा:

objArray.sort(function(a, b) {
    var textA = a.DepartmentName.toUpperCase();
    var textB = b.DepartmentName.toUpperCase();
    return (textA < textB) ? -1 : (textA > textB) ? 1 : 0;
});

नोट: मामले को बदलने (ऊपरी या निचले हिस्से में) एक मामले को असंवेदनशील सुनिश्चित करता है।

Comments

मैं आपके उत्तर में 50 गज़िलियन बार आया हूं क्योंकि मैं कभी नहीं याद कर सकता कि यह कैसे करना है। FWIW, मेरे लिंटर हमेशा मुझे "अभिव्यक्ति के चारों ओर गंभीर कोष्ठक" के बारे में सूचित करते हैं: return (textA < textB) ? -1 : (textA > textB) ? 1 : 0;अपना उत्तर संपादित न करें, आशा है कि मैं कम से कम

— लाइनिंग

इस ओमर के लिए धन्यवाद

— टेड फिट्ज़पैट्रिक

इस कोड के साथ एक समस्या मिली। निचले और बड़े अक्षरों के संयोजन का उपयोग करें। पूर्व। credit_card_no और शहर। कोड सूची को क्रमबद्ध करता है लेकिन 'c' से शुरू होने वाले शब्द एक साथ समूहीकृत नहीं होते हैं।

— केदार

Answer 2

यूनिकोड का समर्थन करने के लिए:

objArray.sort(function(a, b) {
   return a.DepartmentName.localeCompare(b.DepartmentName);
});

Comments

केस-असंवेदनशील संस्करण के लिए, लाइन 2 पर निम्न का उपयोग करें: return a.DepartmentName.toLowerCase().localeCompare(b.DepartmentName.toLowerCase());

— बेन बैरेथ

हर दिन कुछ नया सीखें - localeCompareशांत और पहले arg के लिए सभी ब्राउज़र का समर्थन है। बुरा नहीं!

— ओबजनर

@BenBarreth स्ट्रिंग्स को कम करने का कोई कारण नहीं है। पूरे localeCompareतर्क यह है कि सिस्टम को सॉर्ट लॉजिक और लोकल क्विर्क के प्रबंधन के काम को छोड़ना है। यदि केस-असंवेदनशील प्रकार करना लोकेल के लिए सामान्य है, जैसा कि अंग्रेजी में है, तो यह आपके लिए किया जाएगा: "Z" > 'a' // false "Z".localeCompare('a') // 1 यदि आप लोकेल के डिफॉल्ट से विचलन करना चाहते हैं, तो आप ओवरराइड्स इन localesऔर optionsपैरामीटर्स के साथ भेज सकते हैं : developer.mililla। org / en-US / डॉक्स / वेब / जावास्क्रिप्ट / संदर्भ /…

— जॉन z

Answer 3

var DepartmentFactory = function(data) {
    this.id = data.Id;
    this.name = data.DepartmentName;
    this.active = data.Active;
}

// use `new DepartmentFactory` as given below. `new` is imporatant

var objArray = [];
objArray.push(new DepartmentFactory({Id: 1, DepartmentName: 'Marketing', Active: true}));
objArray.push(new DepartmentFactory({Id: 2, DepartmentName: 'Sales', Active: true}));
objArray.push(new DepartmentFactory({Id: 3, DepartmentName: 'Development', Active: true}));
objArray.push(new DepartmentFactory({Id: 4, DepartmentName: 'Accounting', Active: true}));

function sortOn(property){
    return function(a, b){
        if(a[property] < b[property]){
            return -1;
        }else if(a[property] > b[property]){
            return 1;
        }else{
            return 0;   
        }
    }
}

//objArray.sort(sortOn("id")); // because `this.id = data.Id;`
objArray.sort(sortOn("name")); // because `this.name = data.DepartmentName;`
console.log(objArray);

डेमो: http://jsfiddle.net/diode/hdgeH/

Answer 4

// Sorts an array of objects "in place". (Meaning that the original array will be modified and nothing gets returned.)
function sortOn (arr, prop) {
    arr.sort (
        function (a, b) {
            if (a[prop] < b[prop]){
                return -1;
            } else if (a[prop] > b[prop]){
                return 1;
            } else {
                return 0;   
            }
        }
    );
}

//Usage example:

var cars = [
        {make:"AMC",        model:"Pacer",  year:1978},
        {make:"Koenigsegg", model:"CCGT",   year:2011},
        {make:"Pagani",     model:"Zonda",  year:2006},
        ];

// ------- make -------
sortOn(cars, "make");
console.log(cars);

/* OUTPUT:
AMC         : Pacer : 1978
Koenigsegg  : CCGT  : 2011
Pagani      : Zonda : 2006
*/



// ------- model -------
sortOn(cars, "model");
console.log(cars);

/* OUTPUT:
Koenigsegg  : CCGT  : 2011
AMC         : Pacer : 1978
Pagani      : Zonda : 2006
*/



// ------- year -------
sortOn(cars, "year");
console.log(cars);

/* OUTPUT:
AMC         : Pacer : 1978
Pagani      : Zonda : 2006
Koenigsegg  : CCGT  : 2011
*/

Answer 5

डेमो

var DepartmentFactory = function(data) {
    this.id = data.Id;
    this.name = data.DepartmentName;
    this.active = data.Active;
}

var objArray = [];
objArray.push(new DepartmentFactory({Id: 1, DepartmentName: 'Marketing', Active: true}));
objArray.push(new DepartmentFactory({Id: 2, DepartmentName: 'Sales', Active: true}));
objArray.push(new DepartmentFactory({Id: 3, DepartmentName: 'Development', Active: true}));
objArray.push(new DepartmentFactory({Id: 4, DepartmentName: 'Accounting', Active: true}));

console.log(objArray.sort(function(a, b) { return a.name > b.name}));

Answer 6

objArray.sort((a, b) => a.DepartmentName.localeCompare(b.DepartmentName))

Answer 7

इसको ऐसे करो

objArrayy.sort(function(a, b){
 var nameA=a.name.toLowerCase(), nameB=b.name.toLowerCase()
 if (nameA < nameB) //sort string ascending
  return -1
 if (nameA > nameB)
  return 1
 return 0 //default return value (no sorting)
});
console.log(objArray)

Answer 8

objArray.sort( (a, b) => a.id.localeCompare(b.id, 'en', {'sensitivity': 'base'}));

यह उन्हें वर्णानुक्रम में टाइप करता है और केस असंवेदनशील है। यह सुपर साफ और पढ़ने में आसान भी है: डी

Comments

स्वीकृत समाधान की तुलना में बहुत अधिक सुरुचिपूर्ण!

— कानो

Answer 9

यहाँ एक सरल कार्य है जिसका उपयोग आप वस्तुओं के सरणी को उनके गुणों के माध्यम से क्रमबद्ध करने के लिए कर सकते हैं; इससे कोई फर्क नहीं पड़ता कि संपत्ति एक प्रकार का स्ट्रिंग या पूर्णांक है, यह काम करेगा।

    var cars = [
        {make:"AMC",        model:"Pacer",  year:1978},
        {make:"Koenigsegg", model:"CCGT",   year:2011},
        {make:"Pagani",     model:"Zonda",  year:2006},
    ];

    function sortObjectsByProp(objectsArr, prop, ascending = true) {
        let objectsHaveProp = objectsArr.every(object => object.hasOwnProperty(prop));
        if(objectsHaveProp)    {
            let newObjectsArr = objectsArr.slice();
            newObjectsArr.sort((a, b) => {
                if(isNaN(Number(a[prop])))  {
                    let textA = a[prop].toUpperCase(),
                        textB = b[prop].toUpperCase();
                    if(ascending)   {
                        return textA < textB ? -1 : textA > textB ? 1 : 0;
                    } else {
                        return textB < textA ? -1 : textB > textA ? 1 : 0;
                    }
                } else {
                    return ascending ? a[prop] - b[prop] : b[prop] - a[prop];
                }
            });
            return newObjectsArr;
        }
        return objectsArr;
    }

    let sortedByMake = sortObjectsByProp(cars, "make"); // returns ascending order by its make;
    let sortedByYear = sortObjectsByProp(cars, "year", false); // returns descending order by its year,since we put false as a third argument;
    console.log(sortedByMake);
    console.log(sortedByYear);

Answer 10

आपको एक फ़ंक्शन पास करना होगा जो दो मापदंडों को स्वीकार करता है, उनकी तुलना करता है, और एक नंबर लौटाता है, इसलिए यह मानकर कि आप उन्हें आईडी के आधार पर छाँटना चाहते हैं, जिसे आप लिखेंगे ...

objArray.sort(function(a,b) {
    return a.id-b.id;
});
// objArray is now sorted by Id

Comments

उन्होंने Id नहीं बल्कि विभागनाम से छंटनी के बारे में पूछा।

— पॉल टॉम्बलिन

मैंने यह कोशिश की और यह स्ट्रिंग कॉलम पर काम नहीं करता है ... यह एक तारीख कॉलम पर काम करता है। काम क्या था @ omer-bokhari से समाधान

— tsando

Answer 11

इस पर थोड़ा सा प्रयास करने के बाद, और जितना संभव हो कम लूप बनाने की कोशिश कर रहा हूं, मैं इस समाधान के साथ समाप्त हुआ:

कोडपेन पर डेमो

const items = [
      {
        name: 'One'
      },
      {
        name: 'Maria is here'
      },
      {
        name: 'Another'
      },
      {
        name: 'Z with a z'
      },
      {
        name: '1 number'
      },
      {
        name: 'Two not a number'
      },
      {
        name: 'Third'
      },
      {
        name: 'Giant'
      }
    ];

    const sorted = items.sort((a, b) => {
      return a[name] > b[name];
    });

    let sortedAlphabetically = {};

    for(var item in sorted) {
      const firstLetter = sorted[item].name[0];
      if(sortedAlphabetically[firstLetter]) {
        sortedAlphabetically[firstLetter].push(sorted[item]);
      } else {
        sortedAlphabetically[firstLetter] = [sorted[item]]; 
      }
    }

    console.log('sorted', sortedAlphabetically);

Answer 12

एक सरल जवाब:

objArray.sort(function(obj1, obj2) {
   return obj1.DepartmentName > obj2.DepartmentName;
});

ES6 रास्ता:

objArray.sort((obj1, obj2) => {return obj1.DepartmentName > obj2.DepartmentName};

यदि आपको इसे लोअरकेस / अपरकेस आदि बनाने की आवश्यकता है, तो बस उस वेरिएबल की तुलना की तुलना में वैरिएबल को स्टोर करें। उदाहरण:

objArray.sort((obj1, obj2) => {
   var firstObj = obj1.toLowerCase();
   var secondObj = obj2.toLowerCase();
   return firstObj.DepartmentName > secondObj.DepartmentName;
});