जावास्क्रिप्ट में Firstname (वर्णानुक्रम) द्वारा क्रमबद्ध सरणी

Question

मुझे एक सरणी मिली (सरणी में एक वस्तु के लिए नीचे देखें) जिसे मुझे जावास्क्रिप्ट का उपयोग करके पहले नाम से सॉर्ट करने की आवश्यकता है। मैं यह कैसे कर सकता हूं?

var user = {
   bio: null,
   email:  "[e-mail]",
   firstname: "Anna",
   id: 318,
   lastAvatar: null,
   lastMessage: null,
   lastname: "Nickson",
   nickname: "anny"
};

Comments

वस्तुओं

— फेलिक्स क्लिंग

Answer 1

मान लीजिए कि आपके पास एक सरणी है users। आप users.sortएक फ़ंक्शन का उपयोग कर सकते हैं और दो तर्क ले सकते हैं और उनकी तुलना कर सकते हैं (तुलनाकर्ता)

इसे वापस लौटना चाहिए

• कुछ नकारात्मक अगर पहला तर्क दूसरे से कम है (परिणामी सरणी में दूसरे से पहले रखा जाना चाहिए)
• कुछ सकारात्मक अगर पहला तर्क अधिक है (दूसरे के बाद रखा जाना चाहिए)
• 0 यदि वे दो तत्व बराबर हैं।

हमारे मामले में अगर दो तत्व हैं aऔर bहम तुलना करना चाहते हैं a.firstnameऔरb.firstname

उदाहरण:

users.sort(function(a, b){
    if(a.firstname < b.firstname) { return -1; }
    if(a.firstname > b.firstname) { return 1; }
    return 0;
})

यह कोड किसी भी प्रकार के साथ काम करने वाला है।

ध्यान दें कि "वास्तविक जीवन" ™ में आप अक्सर मामले की अनदेखी करना चाहते हैं, जब आप तार की तुलना करते हैं, तो ics जैसे अजीब प्रतीक, ß आदि को सही ढंग से क्रमबद्ध करना चाहते हैं, इसलिए आप उपयोग करना चाह सकते हैं localeCompare। स्पष्टता के लिए अन्य उत्तर देखें।

Comments

Friggin कमाल ... मैं आईडी द्वारा एक नोडेलिस्ट छाँट रहा हूँ ... एक आकर्षण की तरह काम करता है। एक टन!

— कोडी

बाद की तारीख में आने वालों के लिए, श्रीचफ का जवाब बेहतर है क्योंकि यह असंवेदनशील है।

— मलाइनाउ

@mlienau, मैं इसे बेहतर या बदतर नहीं कहूंगा। यह सिर्फ एक और है

— 20

@ रियाद मेला काफी बस आवरण सहित वस्तुओं को वर्णानुक्रम से छांटने के कई मामलों के बारे में नहीं सोच सकते हैं, जहां 'सेब' से पहले 'ज़ेबरा' सूची में दिखाई देता है, बहुत उपयोगी होगा।

— म्लाइनाउ

यह कोड केवल अंग्रेजी बोलने वाले देशों पर काम करेगा। अन्य देशों में आपको ovunccetin के उत्तर काlocaleCompare उपयोग करना चाहिए ।

— स्पूइक जूल

Answer 2

ES6 के साथ सबसे कम संभव कोड!

users.sort((a, b) => a.firstname.localeCompare(b.firstname))

String.prototype.localeCompare () मूल समर्थन सार्वभौमिक है!

Comments

अब तक सबसे अच्छा जवाब अगर आप 2017 में रह रहे हैं

— nathanbirrell

यदि आप 2018 में रहते हैं, तो भी सबसे अच्छा जवाब;)

— सिमोन

शायद 2019 के लिए भी सबसे अच्छा जवाब होगा।

— अहमद मालेकी

2020 शायद? या ना?

— kspearrin

आह आदमी, 2030 में पृथ्वी पर बाढ़ आती है और यह केवल पहाड़ों में काम करता है।

— Starfs

Answer 3

कुछ इस तरह:

array.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)
});

Comments

जब सॉर्टिंग स्ट्रिंग्स 'toLowerCase ()' बहुत महत्वपूर्ण है - कैपिटल लेटर्स आपके सॉर्ट को प्रभावित कर सकते हैं।

— 13

मामले में कोई और सोच रहा है कि लॉवरकैसे का क्या प्रभाव पड़ता है, यह बहुत ज्यादा नहीं है:'a'>'A' //true 'z'>'a' //true 'A'>'z' //false

— सिम्पलीजैन

@SimplGy मैं तर्क दूंगा कि इसका प्रभाव थोड़ा अधिक है, क्योंकि आप इसका श्रेय दे रहे हैं। उदाहरण के लिए, जैसा कि टिप्पणियों में स्वीकार किए गए उत्तर में कहा गया है, यह जानना महत्वपूर्ण है कि क्या आपका सॉर्ट फ़ंक्शन स्ट्रिंग 'Zebra'की तुलना में उच्चतर सॉर्ट करेगा 'apple', जो यदि आप उपयोग नहीं करते हैं तो यह करेगा .toLowerCase()।

— प्रिंसटेक

@PrinceTyke हाँ, यह एक अच्छा मामला है। 'Z' < 'a' // trueऔर'z' < 'a' // false

— SimpleGy

सभी मान्य बिंदु और मैं कहूंगा कि छँटाई हमेशा "यह निर्भर करता है" तरह की होती है। यदि आप नामों के आधार पर छंटनी कर रहे हैं, तो केस सेंसिटिविटी मायने नहीं रखती। अन्य मामलों में यह हो सकता है। भले ही, मुझे लगता है कि एक बार विशिष्ट विचार अपनाने के बाद आपको कोई भी मुश्किल नहीं है।

— मृकफ़र्ट

Answer 4

यदि तुलना तार में यूनिकोड वर्ण होते हैं तो आप निम्न की तरह वर्ग के localeCompareकार्य का उपयोग कर सकते हैं String:

users.sort(function(a,b){
    return a.firstname.localeCompare(b.firstname);
})

Comments

String.localeCompare Safari और IE <11 :) का समर्थन नहीं करता है

— CORSAIR

@CORSAIR समर्थित है, यह सिर्फ दूसरा और तीसरा पैरामीटर है जो समर्थित नहीं है।

— कोडर

@CORSAIR उदाहरण में उपयोग सभी प्रमुख IE ब्राउज़रों में समर्थित है: developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… । LocaleCompare पूंजीकरण को भी ध्यान में रखता है, इसलिए मुझे लगता है कि इस कार्यान्वयन को सबसे अच्छा अभ्यास माना जाना चाहिए।

— मैट जेन्सेन

users.sort ((a, b) => a.firstname.localeCompare (b.firstname)) // Short n sweet ES6 संस्करण!

— नचिकेता

टैंक भाई। ES6 उपयोग मेंusers.sort((a, b) => a.name.localeCompare(b.name))

— मोहम्मद इब्राहिमी अवल

Answer 5

अच्छा थोड़ा ES6 एक लाइनर:

users.sort((a, b) => a.firstname !== b.firstname ? a.firstname < b.firstname ? -1 : 1 : 0);

Comments

यह एक अपूर्ण है क्योंकि यह समान मानों को ठीक से नहीं संभालता है।

— कार्ल-जोहान Sjögren

बेशक, इस बात के लिए धन्यवाद कि, मैंने मिलान मूल्यों के लिए एक चेक जोड़ा है

— सैम लोगन

बुरा नहीं है, मुझे लगता है कि अगर आप वास्तव में यह सब एक लाइन पर चाहते हैं, नेस्टेड टर्नरीज़ को पठनीयता के लिए भ्रमित किया जाता है

— रसरस्टर

Answer 6

हम localeCompare का उपयोग कर सकते हैं लेकिन कुंजी की जाँच करने के साथ-साथ फाल्सी वैल्यूज़ की भी आवश्यकता है

यदि एक प्रविष्टि में कोई नाम नहीं है तो नीचे दिया गया कोड काम नहीं करेगा।

obj.sort((a, b) => a.lname.localeCompare(b.lname))

इसलिए हमें नीचे की तरह फाल्सी वैल्यू की जांच करनी होगी

let obj=[
{name:'john',lname:'doe',address:'Alaska'},
{name:'tom',lname:'hopes',address:'California'},
{name:'harry',address:'Texas'}
]
let field='lname';
console.log(obj.sort((a, b) => (a[field] || "").toString().localeCompare((b[field] || "").toString())));

या

हम उपयोग कर सकते हैं लॉश, बहुत ही सरल है। यह लौटे हुए मानों का पता लगाएगा यानी संख्या या स्ट्रिंग और उसके अनुसार क्रमबद्धता।

import sortBy from 'lodash/sortBy';
sortBy(obj,'name')

https://lodash.com/docs/4.17.5#sortBy

Comments

लोदाश बहुत साफ है! पहले इसके बारे में नहीं सुना था। बहुत अच्छा काम करता है!

— डर्क जान स्पिलमैन

Answer 7

अंडरस्कोरजेस बहुत अच्छा _.sortBy फ़ंक्शन प्रदान करता है:

_.sortBy([{a:1},{a:3},{a:2}], "a")

या आप एक कस्टम प्रकार फ़ंक्शन का उपयोग कर सकते हैं:

_.sortBy([{a:"b"},{a:"c"},{a:"a"}], function(i) {return i.a.toLowerCase()})

Comments

दूसरे उदाहरण में स्ट्रिंग्स लौटाना शामिल है। क्या sortByपता है कि लौटे हुए मान तार हैं और इस प्रकार एक वर्णमाला छँटाई करते हैं? धन्यवाद

— superjos

Answer 8

मामले में हम नाम या विशेष वर्ण के साथ कुछ, जैसे छँटाई कर रहे हैं ñ या AEIOU (स्पेनिश में कॉमन्स) हम परम इस्तेमाल कर सकते हैं स्थानों ( तों इस मामले में के लिए स्पेनिश) और विकल्प इस तरह:

let user = [{'firstname': 'Az'},{'firstname': 'Áb'},{'firstname':'ay'},{'firstname': 'Ña'},{'firstname': 'Nz'},{'firstname': 'ny'}];


user.sort((a, b) => a.firstname.localeCompare(b.firstname, 'es', {sensitivity: 'base'}))


console.log(user)

इलियाना , ईएस (स्पेनिश), डे (जर्मन), फ्र (फ्रेंच) में यहां के स्थानीय लोक विकल्प देखे जा सकते हैं । के बारे में संवेदनशीलता आधार साधन:

केवल तार जो आधार पत्रों में भिन्न होते हैं, असमान के रूप में तुलना करते हैं। उदाहरण: ples b, a = á, a = A।

Answer 9

मूल रूप से आप एरर्स को मेथड सॉर्ट के साथ सॉर्ट कर सकते हैं, लेकिन यदि आप ऑब्जेक्ट्स को सॉर्ट करना चाहते हैं तो आपको एरे के तरीके को सॉर्ट करने के लिए फंक्शन पास करना होगा, इसलिए मैं आपको एरे का उपयोग करके एक उदाहरण दूंगा।

user = [{
bio: "<null>",
email: "[e-mail]",
firstname: 'Anna',
id: 318,
"last_avatar": "<null>",
"last_message": "<null>",
lastname: 'Nickson',
nickname: 'anny'
},
{
bio: "<null>",
email: "[e-mail]",
firstname: 'Senad',
id: 318,
"last_avatar": "<null>",
"last_message": "<null>",
lastname: 'Nickson',
nickname: 'anny'
},
{
bio: "<null>",
email: "[e-mail]",
firstname: 'Muhamed',
id: 318,
"last_avatar": "<null>",
"last_message": "<null>",
lastname: 'Nickson',
nickname: 'anny'
}];

var ar = user.sort(function(a, b)
{
  var nA = a.firstname.toLowerCase();
  var nB = b.firstname.toLowerCase();

  if(nA < nB)
    return -1;
  else if(nA > nB)
    return 1;
 return 0;
});

Comments

अंत में 0 क्यों लौटे?

— नोबिता

=, जब तार समान होते हैं

— सेनाड मेस्किन

लेकिन उस मामले में elseहटाया नहीं जाना चाहिए ? अन्यथा वह return 0कभी नहीं पढ़ा जाएगा

— नोबिता

यह "और" नहीं है, यह "और अगर" है

— सेनाद मेस्किन

Answer 10

इस उत्तर से प्रेरित ,

users.sort((a,b) => (a.firstname  - b.firstname));

Answer 11

एक अधिक कॉम्पैक्ट संकेतन:

user.sort(function(a, b){
    return a.firstname === b.firstname ? 0 : a.firstname < b.firstname ? -1 : 1;
})

Comments

यह अधिक कॉम्पैक्ट है, लेकिन इसके अनुबंध का उल्लंघन करता है: sign(f(a, b)) =-sign(f(b, a))(a = b के लिए)

— RiaD

पूर्णता के लिए रिटर्न a.firstname == b.firstnameका उपयोग करना चाहिए===

— puiu

Answer 12

दोनों asec और desc सॉर्ट के लिए, u इसका उपयोग कर सकते हैं: मान लें कि हमारे पास एक वेरिएबल SortType है जो आरोही प्रकार या अवरोही क्रम को निर्दिष्ट करता है जो आप चाहते हैं:

 users.sort(function(a,b){
            return   sortType==="asc"? a.firstName.localeCompare( b.firstName): -( a.firstName.localeCompare(  b.firstName));
        })

Answer 13

एक सामान्यीकृत फ़ंक्शन को नीचे की तरह लिखा जा सकता है

    function getSortedData(data, prop, isAsc) {
        return data.sort((a, b) => (a[prop] < b[prop] ? -1 : 1) * (isAsc ? 1 : -1));
   }

आप नीचे दिए गए मापदंडों को पारित कर सकते हैं

1. डेटा जिसे आप सॉर्ट करना चाहते हैं
2. इसके द्वारा डेटा में मौजूद संपत्ति को छांटना चाहिए
3. अंतिम पैरामीटर बूलियन प्रकार का है। यह जाँचता है कि क्या आप आरोही या अवरोही क्रम से छँटाई करना चाहते हैं

Answer 14

प्रयत्न

users.sort((a,b)=> (a.firstname>b.firstname)*2-1)

var users = [
  { firstname: "Kate", id: 318, /*...*/ },
  { firstname: "Anna", id: 319, /*...*/ },
  { firstname: "Cristine", id: 317, /*...*/ },
]

console.log(users.sort((a,b)=> (a.firstname>b.firstname)*2-1) );

Comments

सॉर्ट फ़ंक्शन -1,0,1 वापस करना चाहिए। यह केवल -1,1 देता है।

— राधु लंकासु

@RaduLuncasu - क्या आप परीक्षण डेटा (उपयोगकर्ता सरणी) प्रदान कर सकते हैं जो दिखाता है कि उपरोक्त समाधान गलत परिणाम देता है? (जहाँ तक मुझे पता है, शून्य को याद

— रखना

यदि तुलना (ए, बी) रिटर्न 0 है, तो ए और बी को एक दूसरे के संबंध में अपरिवर्तित छोड़ दें, लेकिन सभी अलग-अलग तत्वों के संबंध में क्रमबद्ध हैं।

— राडू लंकासु

developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…

— रादु लुंकासू

@RaduLuncasu ठीक है, लेकिन इसका मतलब यह नहीं है कि शून्य अनिवार्य है। यह दिखाने का सबसे अच्छा तरीका डेटा तैयार करना है जो काम नहीं करता है - लेकिन जहां तक ​​मुझे पता है कि यह असंभव है - जैसे[9,8,7,6,5,1,2,3].sort((a,b) => a<b ? -1 : 1)

— कामिल कील्वेज़स्की

Answer 15

आप वस्तुओं के लिए इसका उपयोग कर सकते हैं

transform(array: any[], field: string): any[] {
return array.sort((a, b) => a[field].toLowerCase() !== b[field].toLowerCase() ? a[field].toLowerCase() < b[field].toLowerCase() ? -1 : 1 : 0);}

Answer 16

सीधे शब्दों में आप इस विधि का उपयोग कर सकते हैं

users.sort(function(a,b){return a.firstname < b.firstname ? -1 : 1});

Answer 17

आप इन-बिल्ट ऐरे विधि का उपयोग कर सकते हैं - sort। यह विधि एक कॉलबैक विधि को एक परम के रूप में लेती है

    // custom sort function to be passed as param/callback to the Array's sort method
    function myCustomSort(a, b) {
        return (a.toLowerCase() > b.toLowerCase()) ? 1 : -1;
    }

    // Actual method to be called by entity that needs sorting feature
    function sortStrings() {
        var op = Array.prototype.sort.call(arguments, myCustomSort);
    }

    // Testing the implementation
    var sortedArray = sortStrings("Burger", "Mayo1", "Pizza", "boxes", "Apples", "Mayo");
    console.log(sortedArray); //["Apples", "boxes", "Burger", "Mayo", "Mayo1", "Pizza"]

इस कोड को समझने के लिए मुख्य बिंदुओं पर ध्यान दिया जाना चाहिए।

1. कस्टम विधि, इस मामले में, myCustomSortप्रत्येक तत्व जोड़ी (इनपुट सरणी से) की तुलना के लिए +1 या -1 वापस करना चाहिए।
2. कस्टम छँटाई कॉलबैक विधि में toLowerCase()/ toUpperCase()का उपयोग करें ताकि मामले अंतर छँटाई प्रक्रिया की शुद्धता को प्रभावित न करें।

मुझे उम्मीद है कि यह पर्याप्त स्पष्टीकरण स्पष्ट है। यदि आपको लगता है कि टिप्पणी करने के लिए स्वतंत्र महसूस करें, तो अधिक जानकारी की आवश्यकता है।

चीयर्स!

Comments

उचित उत्तर नहीं क्योंकि यह केवल चेक से कम और अधिक से अधिक प्रदर्शन करता है न कि समान चेक से।

— स्टील ब्रेन

यह ~ 2011 के बाद से वहाँ बैठे किसी भी उत्तर की तुलना में तालिका में नई चीज़ों को नहीं लाता है।

— एंथेस

Answer 18

कुंजी द्वारा क्रमबद्ध करने के लिए एक प्रोटोटाइप में शीर्ष उत्तरों को धक्का दिया।

Array.prototype.alphaSortByKey= function (key) {
    this.sort(function (a, b) {
        if (a[key] < b[key])
            return -1;
        if (a[key] > b[key])
            return 1;
        return 0;
    });
    return this;
};

Answer 19

केस संवेदनशील से छुटकारा पाने के लिए आप कुछ इसी तरह का उपयोग कर सकते हैं

users.sort(function(a, b){

  //compare two values
  if(a.firstname.toLowerCase() < b.firstname.toLowerCase()) return -1;
  if(a.firstname.toLowerCase() > b.firstname.toLowerCase()) return 1;
  return 0;

})

Comments

Mrchief द्वारा एक के रूप में एक ही जवाब। आगे के नुकसान के साथ कि दो बार की तुलना में टोलॉवर कैस की तुलना प्रति बार चार बार की जाती है।

— १३

Answer 20

मेरा कार्यान्वयन, पुराने ES संस्करणों में महान काम करता है:

sortObject = function(data) {
    var keys = Object.keys(data);
    var result = {};

    keys.sort();

    for(var i = 0; i < keys.length; i++) {
        var key = keys[i];

        result[key] = data[key];
    }

    return result;
};

Answer 21

केवल रिकॉर्ड के लिए, यदि आप एक नामित प्रकार-कार्य करना चाहते हैं, तो सिंटैक्स निम्नानुसार है:

let sortFunction = (a, b) => {
 if(a.firstname < b.firstname) { return -1; }
 if(a.firstname > b.firstname) { return 1; }
 return 0;
})
users.sort(sortFunction)

ध्यान दें कि निम्नलिखित काम नहीं करता है:

users.sort(sortFunction(a,b))