मूल्यों द्वारा वस्तु गुण को क्रमबद्ध करना

Question

अगर मेरे पास जावास्क्रिप्ट ऑब्जेक्ट है जैसे:

var list = {
  "you": 100, 
  "me": 75, 
  "foo": 116, 
  "bar": 15
};

क्या मूल्य के आधार पर गुणों को क्रमबद्ध करने का एक तरीका है? ताकि मैं खत्म हो जाऊं

list = {
  "bar": 15, 
  "me": 75, 
  "you": 100, 
  "foo": 116
};

Comments

न केवल "सॉर्टिंग", बल्कि अधिक महत्वपूर्ण रूप से सॉर्टिंग नंबर। संख्याएं Javascripts Array.sort () विधि के लिए प्रतिरक्षा हैं, जिसका अर्थ है कि आपको केवल संपत्तियों को छांटने के लिए एक विधि नहीं ढूंढनी होगी, लेकिन संख्यात्मक मानों की तुलना करने के लिए आपको अपना फ़ंक्शन लिखना होगा।

— सैम्पसन

इससे पहले कि आप जवाब पढ़ें: जवाब नहीं है । ईसीएमएस्क्रिप्ट में वस्तु गुणों का क्रम गैर-मानक है। आपको जावास्क्रिप्ट ऑब्जेक्ट में तत्वों के क्रम के बारे में कभी भी धारणा नहीं बनानी चाहिए। एक वस्तु गुणों का एक अनियंत्रित संग्रह है। नीचे दिए गए उत्तर आपको सरणियों की मदद से सॉर्ट किए गए गुणों का "उपयोग" करने का तरीका दिखाते हैं, लेकिन वास्तव में वस्तुओं के गुणों के क्रम को कभी नहीं बदलते हैं। तो, नहीं, यह संभव नहीं है। यहां तक ​​कि अगर आप निर्धारित गुणों के साथ एक ऑब्जेक्ट का निर्माण करते हैं, तो यह गारंटी नहीं है कि वे भविष्य में उसी क्रम में प्रदर्शित करेंगे। पढ़ते रहिये :)।

— गोविंद राय

@GovindRai अभी तक, वास्तविक विश्व दृश्यपटल अनुप्रयोगों में हम कुंजी के रूप में आईडी के साथ ऑब्जेक्ट संग्रह पर लूप करते हैं और HTML टेम्प्लेट में अनुवादित होने पर ऑर्डर महत्वपूर्ण है। आप कहते हैं कि उनके पास कोई आदेश नहीं है, मेरा कहना है कि उनके पास ठीक वही क्रम है जो मैं तब देखता हूं जब उन्हें वर्तमान ब्राउज़र में कंसोल। और वह आदेश फिर से मिल सकता है। जैसे ही आप उन पर लूप करते हैं, उनके पास एक ऑर्डर होता है।

— ProblemsOfSumit

@ गोविंदराय: अब एक निर्दिष्ट क्रम में संपत्तियों को एक्सेस करने का एक साधन है। क्या यह एक अच्छा विचार है? लगभग निश्चित रूप से नहीं। :-) लेकिन यह वहाँ है, ES2015 के रूप में।

— टीजे क्राउडर

2019 विज़िटर: इस बमुश्किल उत्थान- Object.entriesआधारित उत्तर की जांच करें जो ES2017 के बाद से सबसे साफ और सबसे अधिक पढ़ने योग्य स्थिति है: stackoverflow.com/a/37607084/245966

— jakub.g

Answer 1

उन्हें एक सरणी में ले जाएं, उस सरणी को सॉर्ट करें, और फिर उस सरणी का उपयोग अपने उद्देश्यों के लिए करें। यहाँ एक समाधान है:

var maxSpeed = {
    car: 300, 
    bike: 60, 
    motorbike: 200, 
    airplane: 1000,
    helicopter: 400, 
    rocket: 8 * 60 * 60
};
var sortable = [];
for (var vehicle in maxSpeed) {
    sortable.push([vehicle, maxSpeed[vehicle]]);
}

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

//[["bike", 60], ["motorbike", 200], ["car", 300],
//["helicopter", 400], ["airplane", 1000], ["rocket", 28800]]

---

एक बार आपके पास सरणी होने के बाद, आप जिस क्रम में चाहें उस ऑब्जेक्ट को सरणी से पुन: बना सकते हैं, इस प्रकार वह प्राप्त करना जो आप करना चाहते हैं। मुझे पता है कि सभी ब्राउज़रों में काम करेगा, लेकिन यह एक कार्यान्वयन क्वर्क पर निर्भर होगा, और किसी भी समय टूट सकता है। आपको जावास्क्रिप्ट ऑब्जेक्ट में तत्वों के क्रम के बारे में कभी भी धारणा नहीं बनानी चाहिए।

var objSorted = {}
sortable.forEach(function(item){
    objSorted[item[0]]=item[1]
})

Comments

क्या आप कृपया "आप पुन: निर्माण कर सकते हैं" में सुधार कर सकते हैं "आप कुंजियों का क्रम बनाए रखने और ऑब्जेक्ट से मान खींचने के लिए सरणी का उपयोग कर सकते हैं"? न केवल यह गैर-मानक है, जैसा कि आपने स्वयं बताया है, यह गलत धारणा आज केवल क्रोम की तुलना में अधिक ब्राउज़रों द्वारा टूट गई है, इसलिए उपयोगकर्ताओं को इसे आज़माने के लिए प्रोत्साहित न करना बेहतर है।

— ओलेग वी। वोल्कोव

यहां आपके कोड का एक अधिक कॉम्पैक्ट संस्करण है। Object.key (maxSpeed) .sort (फ़ंक्शन (a, b) {वापसी - (maxSpeed ​​[a] - maxSpeed ​​[b])});

— TheBrain

@ TheBrain: keys()केवल जोड़ने के लिए, केवल IE9 + (और अन्य आधुनिक ब्राउज़र) द्वारा समर्थित है, अगर यह चिंता का विषय है। इसके अलावा keys()तत्वों प्रोटोटाइप श्रृंखला (। के विपरीत) से असंख्य गुणों को बाहर करता है - लेकिन यह आमतौर पर अधिक वांछनीय है।

— 9

_.pairsएक वस्तु को [[key1, value1], [key2, value2]] में बदल देता है। फिर उस पर कॉल सॉर्ट करें। फिर _.objectइसे वापस चालू करने के लिए कॉल करें ।

— फंककोडायट

मेरी परियोजना को सफाई से विलय करने के लिए ऑब्जेक्ट कुंजियों की आवश्यकता है, लेकिन मेटाडेटा ड्राइव यूआई के रूप में स्पष्ट छंटाई की भी आवश्यकता है। मैंने इसी तरह के दृष्टिकोण का पालन किया, केवल मैंने प्रोटोटाइप श्रृंखला को क्रॉल करने से बचने के लिए एक hasOwnProperty चेक जोड़ा। यहाँ जेएस hackernoon.com/

— नाथन Agersea

Answer 2

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

यहाँ एक और तरीका है जैसे कि बोनना:

var list = {"you": 100, "me": 75, "foo": 116, "bar": 15};
keysSorted = Object.keys(list).sort(function(a,b){return list[a]-list[b]})
console.log(keysSorted);     // bar,me,you,foo

Comments

ऐसा लगता है कि कुंजी के आधार पर छंटनी हो रही है, मूल्य नहीं है, जो प्रश्न के लिए बुलाया नहीं है?

— माइकल

यह मान द्वारा सॉर्ट किया जाता है, और कुंजियाँ प्रदर्शित करता है - लेकिन जब हम इसे प्रिंट करते हैं, तो मूल्य मान खो देते हैं, क्योंकि यह केवल कुंजियाँ प्रिंट करता है।

— हन्ना

जावास्क्रिप्ट में ऑब्जेक्ट प्रॉपर्टी ऑर्डर की गारंटी नहीं है, इसलिए छंटनी को एक सरणी में किया जाना चाहिए, न कि एक ऑब्जेक्ट (जिसे आप 'साहचर्य सरणी' के रूप में संदर्भित कर रहे हैं)।

— क्रिस्टोफर मेयर्स

मत भूलना। keysSortedएक सरणी है! वस्तु नहीं!

— ग्रीन

यदि आप .map(key => list[key]);सॉर्ट के अंत में जोड़ते हैं , तो यह केवल कुंजी के बजाय पूरे ऑब्जेक्ट को लौटाएगा

— जेम्स मोरन

Answer 3

आपकी वस्तुओं में किसी भी प्रकार की संपत्ति हो सकती है और यदि आप वस्तुओं को किसी संख्या या स्ट्रिंग में रखना चाहते हैं, तो वस्तुओं को किसी सरणी में रख सकते हैं। इस सरणी पर विचार करें:

var arrayOfObjects = [   
    {
        name: 'Diana',
        born: 1373925600000, // Mon, Jul 15 2013
        num: 4,
        sex: 'female'
    },
    {

        name: 'Beyonce',
        born: 1366832953000, // Wed, Apr 24 2013
        num: 2,
        sex: 'female'
    },
    {            
        name: 'Albert',
        born: 1370288700000, // Mon, Jun 3 2013
        num: 3,
        sex: 'male'
    },    
    {
        name: 'Doris',
        born: 1354412087000, // Sat, Dec 1 2012
        num: 1,
        sex: 'female'
    }
];

जन्म से क्रमबद्ध, सबसे पुराना पहला

// use slice() to copy the array and not just make a reference
var byDate = arrayOfObjects.slice(0);
byDate.sort(function(a,b) {
    return a.born - b.born;
});
console.log('by date:');
console.log(byDate);

नाम द्वारा क्रमबद्ध करें

var byName = arrayOfObjects.slice(0);
byName.sort(function(a,b) {
    var x = a.name.toLowerCase();
    var y = b.name.toLowerCase();
    return x < y ? -1 : x > y ? 1 : 0;
});

console.log('by name:');
console.log(byName);

http://jsfiddle.net/xsM5s/16/

Comments

नाम से क्रमबद्ध substrपहला वर्ण नहीं होना चाहिए ; बाकी Dianaऔर Debraएक अपरिभाषित आदेश दिया है। इसके अलावा, आपके byDateप्रकार वास्तव में उपयोग करता है num, नहीं born।

— लॉरेंस Dol

यह दिखता है अच्छा है, लेकिन ध्यान दें कि तार तुम सिर्फ उपयोग कर सकते हैं की तुलना करने केx.localeCompare(y)

— Jemar जोन्स

@JemarJones localCompareबहुत उपयोगी फ़ंक्शन की तरह दिखता है! बस ध्यान दें कि यह हर ब्राउज़र में समर्थित नहीं होगा - IE 10 और उससे कम, सफारी मोबाइल 9 और उससे कम।

— अकार्बनिक

@inorganik हाँ उन लोगों के लिए बहुत अच्छा ध्यान दें जिन्हें उन ब्राउज़रों का समर्थन करने की आवश्यकता है

— जेमर जोन्स

यह वस्तुओं का एक सरणी है, जो ओपी के लिए नहीं पूछा गया है (कई गुणों के साथ एक वस्तु)

— जोआओ पिमेंटेल फेरेरा

Answer 4

संपूर्णता के लिए, यह फ़ंक्शन ऑब्जेक्ट गुणों की क्रमबद्ध सरणी देता है :

function sortObject(obj) {
    var arr = [];
    for (var prop in obj) {
        if (obj.hasOwnProperty(prop)) {
            arr.push({
                'key': prop,
                'value': obj[prop]
            });
        }
    }
    arr.sort(function(a, b) { return a.value - b.value; });
    //arr.sort(function(a, b) { a.value.toLowerCase().localeCompare(b.value.toLowerCase()); }); //use this to sort as strings
    return arr; // returns array
}

var list = {"you": 100, "me": 75, "foo": 116, "bar": 15};
var arr = sortObject(list);
console.log(arr); // [{key:"bar", value:15}, {key:"me", value:75}, {key:"you", value:100}, {key:"foo", value:116}]

ऊपर दिए गए कोड के साथ Jsfiddle यहां है । यह समाधान इस लेख पर आधारित है ।

छँटाई तारों के लिए अद्यतित फ़िडेल यहाँ है। केस संवेदी स्ट्रिंग तुलना के लिए आप इससे अतिरिक्त .toLowerCase () रूपांतरण दोनों निकाल सकते हैं।

Comments

वस्तुओं की एक सरणी के बारे में क्या? [{नाम: विल}, {नाम: बिल}, {नाम: बेन}]

— हैनकॉक

हाय विल, आप इस तुलना के लिए localeCompare फ़ंक्शन का उपयोग कर सकते हैं । इसे उपरोक्त उत्तर में जोड़ा गया।

— स्टेनो

महान समाधान। स्ट्रिंग सॉर्ट को वापसी की आवश्यकता है

— pfwd

@ स्टेनो सही और सरल उपाय। बहुत बहुत धन्यवाद।

— अबरार हुसैन

Answer 5

ECMAScript 2017 प्रस्तुत करता है Object.values / Object.entries। जैसा कि नाम से पता चलता है, पूर्व वस्तु के सभी मूल्यों को एक सरणी में एकत्रित करता है, और उत्तरार्द्ध पूरे ऑब्जेक्ट को [key, value]सरणियों के एक सरणी में करता है; की पायथन के बराबर dict.values()और dict.items()।

किसी भी हैश को एक ऑर्डर की गई वस्तु में सॉर्ट करना बहुत आसान है। अब तक, जावास्क्रिप्ट प्लेटफ़ॉर्म का केवल एक छोटा हिस्सा उनका समर्थन करता है , लेकिन आप इसे फ़ायरफ़ॉक्स 47+ पर आज़मा सकते हैं।

let obj = {"you": 100, "me": 75, "foo": 116, "bar": 15};

let entries = Object.entries(obj);
// [["you",100],["me",75],["foo",116],["bar",15]]

let sorted = entries.sort((a, b) => a[1] - b[1]);
// [["bar",15],["me",75],["you",100],["foo",116]]

Comments

यह संभवतः प्रश्न के शीर्षक का उत्तर कैसे देता है Sorting JavaScript Object by property value? आप मेरे द्वारा पूछे गए प्रश्न को गलत समझते हैं, क्योंकि आप मूल वस्तु को बदलना चाहते हैं और उससे एक नया एरियर नहीं बनाते हैं।

— vsync

@vsync यह उत्तर स्वीकृत उत्तर के समान परिणाम देता है, लेकिन कम कोड और कोई अस्थायी चर नहीं है।

— डैरेन कुक

FWIW, यह उत्तर साफ है और केवल एक ही है जिसने मेरी मदद की।

— नेटऑपरेटर विब्बी

केवल एफएफ में, यानी नहीं, और न ही क्रोम अब वे वस्तुओं को स्वचालित रूप से सॉर्ट नहीं करते हैं। wtf

— fb

बस ध्यान दें कि यह चाबियाँ संरक्षित नहीं करेगा।

— वेल विक्टस

Answer 6

संदर्भ के लिए @marcusR के उत्तर का "तीर" संस्करण है

var myObj = {"you": 100, "me": 75, "foo": 116, "bar": 15};
keysSorted = Object.keys(myObj).sort((a,b) => myObj[a]-myObj[b])
alert(keysSorted);     // bar,me,you,foo

अद्यतन: अप्रैल २०१ 2017 - यह myObjऊपर बताई गई क्रमबद्ध वस्तु देता है ।

Object
 .keys(myObj)
 .sort((a, b) => myObj[a]-myObj[b])
 .reduce((_sortedObj, key) => ({
   ..._sortedObj, 
   [key]: myObj[key]
 }), {})

यहाँ यह कोशिश करो!

अद्यतन: अक्टूबर 2018 - Object.entries संस्करण

Object
 .entries(myObj)
 .sort()
 .reduce((_sortedObj, [k,v]) => ({
   ..._sortedObj, 
   [k]: v
 }), {})

यहाँ यह कोशिश करो!

Comments

के लिए काम नहीं करता हैvar myObj = {"1": {"Value": 40}, "2": {"Value": 10}, "3": {"Value": 30}, "4": {"Value": 20}};

— रोहनिल

ओपी के प्रश्न, इस उत्तर के साथ नेस्टेड ऑब्जेक्ट्स शामिल नहीं हैं @ रोहनिल शायद आप डाउन-वोटिंग के बजाय एक और सवाल पूछना चाहते हैं। विभिन्न प्रकार के साथ आपकी नेस्टेड वस्तु को स्पष्ट रूप से इस समाधान की आवश्यकता से अधिक की आवश्यकता होती है

— जेसन जे। नाथन

बस एक नोट: आपके अपडेट वास्तव में काम नहीं करेंगे। कम से कम हर जगह और नहीं की वजह से entries। मानक के अनुसार, एक वस्तु गुणों का एक अनियंत्रित संग्रह है । ठीक है, इसका मतलब है कि अगर आप संपत्ति के मूल्य या किसी अन्य चीज़ से इसे छाँटने के बाद नई वस्तु का निर्माण करने की कोशिश कर रहे हैं, तो संपत्ति कुंजी आदेश फिर से अपरिभाषित हो जाता है। उदाहरण के लिए, क्रोम डिफ़ॉल्ट रूप से संपत्ति कुंजियों का आदेश दे रहा है, इस प्रकार उन्हें अलग तरीके से ऑर्डर करने का हर प्रयास बेकार है। आपका एकमात्र मौका आपकी ऑर्डरिंग प्राथमिकताओं के आधार पर एक "इंडेक्स" प्राप्त करना है और तदनुसार मूल वस्तु को पार करना है।

— ZorgoZ

हाँ @ZorgoZ, आप सही हैं और कई लोगों ने इस पोस्ट पर इसका उल्लेख किया है। अधिकांश समय, हम इस फ़ंक्शन का उपयोग किसी अन्य प्रकार (जैसे JSON) में परिवर्तित करने से पहले या किसी अन्य कम फ़ंक्शन से पहले रूपांतरण के रूप में करते हैं। यदि उद्देश्य उसके बाद वस्तु को बदलना है, तो अप्रत्याशित परिणाम हो सकते हैं। मुझे इंजनों में इस कार्य के साथ सफलता मिली है।

— जेसन जे। नाथन

नोट: यदि आप का उपयोग नहीं करना चाहते हैं sort()परObject.entries()

— Solvitieg

Answer 7

जावास्क्रिप्ट ऑब्जेक्ट परिभाषा से असंक्रमित होते हैं ( ECMAScript भाषा विनिर्देश देखें) , अनुभाग 8.6 देखें)। भाषा विनिर्देश भी इस बात की गारंटी नहीं देता है कि यदि आप उत्तराधिकार में दो बार किसी वस्तु के गुणों पर पुनरावृत्ति करते हैं, तो वे दूसरी बार भी उसी क्रम में निकलेंगे।

यदि आपको ऑर्डर करने के लिए चीजों की आवश्यकता है, तो ऐरे और Array.prototype.sort पद्धति का उपयोग करें।

Comments

ध्यान दें कि इस बारे में काफी बहस हुई है। अधिकांश कार्यान्वयन सूची को उस क्रम में रखते हैं जिसमें तत्व जोड़े गए थे। IIRC, Chrome नहीं करता है। इस बारे में तर्क था कि क्या क्रोम को अन्य कार्यान्वयन के अनुरूप होना चाहिए। मेरा विश्वास है कि एक जावास्क्रिप्ट ऑब्जेक्ट एक हैश है और कोई भी आदेश नहीं माना जाना चाहिए। मेरा मानना ​​है कि पायथन उसी तर्क से गुज़रा और हाल ही में एक नई आदेशित हैश जैसी सूची पेश की गई। अधिकांश ब्राउज़रों के लिए, आप वह कर सकते हैं जो आप अपनी वस्तु को पुनः प्राप्त करके चाहते हैं, क्रमबद्ध मूल्य द्वारा तत्वों को जोड़ते हुए। लेकिन आपको नहीं करना चाहिए।

— Nosredna

संपादित करें। क्रोम आमतौर पर ऑर्डर रखता है, लेकिन हमेशा नहीं। और यहां एक प्रासंगिक क्रोमियम बग: code.google.com/p/chromium/issues/detail?id=883

— Nosredna

वह बग रिपोर्ट अनुचित है, और जो लोग अनिर्दिष्ट व्यवहार पर भरोसा करते हैं वे बग के साथ हैं। ECMASCript अनुभाग 8.6 पढ़ें; यह स्पष्ट रूप से बताता है कि "एक वस्तु गुणों का एक अनियंत्रित संग्रह है"। जिस किसी ने पाया कि यह कुछ कार्यान्वयन में ऐसा नहीं लगता था, और फिर उस कार्यान्वयन-विशिष्ट व्यवहार पर निर्भर होना शुरू कर दिया, एक बड़ी गलती की, और उन्हें दोष को खुद से दूर करने की कोशिश नहीं करनी चाहिए। यदि मैं Chrome टीम में होता, तो मैं उस बग रिपोर्ट को "अमान्य, WontFix" के रूप में चिह्नित करता।

— निकित्ज़ जूल

EcmaScript 5 वास्तव में गणना के क्रम होने के लिए गणना के आदेश को परिभाषित करता है - परिभाषा की अनुपस्थिति को ES3 में एक विशेष बग माना जाता है। यह ध्यान देने योग्य है कि EcmaScript कल्पना व्यवहार को परिभाषित करता है कि कोई भी व्यक्ति को विचार नहीं करेगा - उदाहरण के लिए व्यवहार व्यवहार यह है कि वाक्यविन्यास त्रुटियां कई मामलों में हैं जो रनटाइम पर फेंक दी जाती हैं, जारी रखने के गलत उपयोग, ब्रेक, ++, -, कॉन्स्टेबल, आदि के अनुसार। उस कोड तक पहुंचने से पहले एक अपवाद को फेंकने वाले किसी भी इंजन को कल्पना करने के लिए गलत है

— olliej

@olliej - मुझे नहीं लगता कि यह सही है। युक्ति कहती है: "यांत्रिकी और गुणों की गणना का क्रम (पहला एल्गोरिथ्म में चरण 6. ए, दूसरे में चरण 7. ए) निर्दिष्ट नहीं है"। यह अंतिम ड्राफ्ट के पीडीएफ के पृष्ठ 92 पर है।

— व्हाइटनीलैंड

Answer 8

ठीक है , जैसा कि आप जानते हैं, जावास्क्रिप्ट में सॉर्ट करने के लिए सॉर्ट () फ़ंक्शन है, लेकिन ऑब्जेक्ट के लिए कुछ भी नहीं ...

तो उस स्थिति में, हमें किसी न किसी तरह से चाबियों का सरणी प्राप्त करने और उन्हें क्रमबद्ध करने की आवश्यकता है, यही कारण है कि एपिस आपको अधिकांश समय एक सरणी में ऑब्जेक्ट देता है, क्योंकि एरे के पास ऑब्जेक्ट शाब्दिक की तुलना में उनके साथ खेलने के लिए अधिक मूल कार्य हैं, वैसे भी, क्विक सॉल्यूशन ऑब्जेक्ट.की का उपयोग कर रहा है, जो ऑब्जेक्ट कुंजियों की एक सरणी लौटाता है, मैं नीचे ईएस 6 फ़ंक्शन बनाता हूं जो आपके लिए काम करता है, यह जावास्क्रिप्ट में देशी प्रकार () और कम () फ़ंक्शन का उपयोग करता है :

function sortObject(obj) {
  return Object.keys(obj)
    .sort().reduce((a, v) => {
    a[v] = obj[v];
    return a; }, {});
}

और अब आप इसे इस तरह से उपयोग कर सकते हैं:

let myObject = {a: 1, c: 3, e: 5, b: 2, d: 4};
let sortedMyObject = sortObject(myObject);

सॉर्ट किए गए ऑबजेक्ट की जांच करें और आप इस तरह से कुंजियों द्वारा सॉर्ट किए गए परिणाम को देख सकते हैं:

{a: 1, b: 2, c: 3, d: 4, e: 5}

इस तरह से, मुख्य वस्तु को छुआ नहीं जाएगा और हमें वास्तव में एक नई वस्तु मिल रही है।

मैं नीचे दी गई छवि भी बनाता हूं, फ़ंक्शन को अधिक स्पष्ट बनाने के लिए, अगर आपको इसे अपने तरीके से काम करने के लिए इसे बदलने की आवश्यकता है:

Comments

यह कुंजी के आधार पर क्रमबद्ध होता है, मान से नहीं।

— रोरोरोरोरर

@ रोरोरोरोर, यह सिर्फ एक संकेत है कि यह कैसे काम करता है क्योंकि वे अलग नहीं हैं, लेकिन सभी अच्छे हैं, मैं मूल्य के आधार पर छंटाई भी

— जोड़ूंगा

मूल्य के आधार पर छांटना गलत है और यह आपका डेटासेट है। बदलें c: 3करने के लिए c: 13और आप इसे अलग गिर देखेंगे।

— वीटोकेर्लोन

@VtoCorleone यह केवल एक प्राकृतिक सॉर्टिंग त्रुटि है, 1 पहले आता है, न कि एल्गोरिथ्म में एक दोष जैसा कि प्रस्तुत किया गया है।

— माइकल रयान सोइलू

Answer 9

var list = {
    "you": 100, 
    "me": 75, 
    "foo": 116, 
    "bar": 15
};

function sortAssocObject(list) {
    var sortable = [];
    for (var key in list) {
        sortable.push([key, list[key]]);
    }
    // [["you",100],["me",75],["foo",116],["bar",15]]

    sortable.sort(function(a, b) {
        return (a[1] < b[1] ? -1 : (a[1] > b[1] ? 1 : 0));
    });
    // [["bar",15],["me",75],["you",100],["foo",116]]

    var orderedList = {};
    for (var idx in sortable) {
        orderedList[sortable[idx][0]] = sortable[idx][1];
    }

    return orderedList;
}

sortAssocObject(list);

// {bar: 15, me: 75, you: 100, foo: 116}

Comments

सरल और सही! यह सवाल का जवाब देता है। धन्यवाद।

— अजय सिंह

जावास्क्रिप्ट में मुख्य आदेश की गारंटी नहीं है, इसलिए यह मेरे लिए विफल हो जाता है अगर चाबियाँ पूर्णांक या पसंद हैं

— पैरोक्स

सटीक, पैरोक्स। जब कुंजी पूर्णांक प्रकार है, तो यह सही ढंग से काम नहीं कर रहा है।

— जुंगवॉन जिन

Answer 10

ES6 के साथ अद्यतन करें: यदि आपकी चिंता के माध्यम से पुनरावृत्त करने के लिए एक हल की गई वस्तु है (यही कारण है कि मैं कल्पना करूँगा कि आप अपनी वस्तु गुणों को क्रमबद्ध करना चाहते हैं), तो आप मैप ऑब्जेक्ट का उपयोग कर सकते हैं ।

आप सॉर्ट किए गए क्रम में अपनी (कुंजी, मान) जोड़े सम्मिलित कर सकते हैं और फिर एक for..ofलूप करने से आपको उनके द्वारा डाले गए क्रम में लूप होने की गारंटी होगी।

var myMap = new Map();
myMap.set(0, "zero");
myMap.set(1, "one");
for (var [key, value] of myMap) {
  console.log(key + " = " + value);
}
// 0 = zero 
// 1 = one

Comments

इसके अलावा में ES6 (ES2015): ऑब्जेक्ट गुण है आदेश है (या वहाँ एक परिभाषित क्रम में उन तक अपने दृष्टिकोण पर निर्भर करता है का एक साधन है)। यदि संपत्ति के नाम तार हैं और सरणी अनुक्रमित की तरह नहीं दिखते हैं, तो आदेश वह क्रम है जो उन्हें ऑब्जेक्ट में जोड़ा गया था। यह आदेश द्वारा सम्मानित किया जाना निर्दिष्ट नहीं है for-inया Object.keys, लेकिन इसे संपत्ति के बकाया सरणियों तक पहुंचने के लिए सम्मान और अन्य नए तरीकों से परिभाषित किया गया है Object.getOwnPropertyNames। तो यह एक और विकल्प है।

— टीजे क्राउडर

लेकिन `सॉर्ट’ ऑपरेशन कहां है? वे सब पर पृथक नहीं किया जा

— ग्रीन

@ मुझे लगता है कि जो मैं यहां उजागर करना चाहता था, वह यह है कि Mapवास्तव में आपके पास एक डेटा संरचना है जो क्रमबद्ध क्रम में संग्रहीत कर सकते हैं (अपने डेटा को सॉर्ट करें, इसके माध्यम से लूप करें और इसे मानचित्र में संग्रहीत करें) जहां आप की गारंटी नहीं है वस्तुओं।

— julianljk

Answer 11

Underscore.js या उन्नत सरणी या ऑब्जेक्ट प्रकार के लिए Lodash.js

 var data={
        "models": {

            "LTI": [
                "TX"
            ],
            "Carado": [
                "A",
                "T",
                "A(пасс)",
                "A(груз)",
                "T(пасс)",
                "T(груз)",
                "A",
                "T"
            ],
            "SPARK": [
                "SP110C 2",
                "sp150r 18"
            ],
            "Autobianchi": [
                "A112"
            ]
        }
    };

    var arr=[],
        obj={};
    for(var i in data.models){
      arr.push([i, _.sortBy(data.models[i],function (el){return el;})]);
    }
    arr=_.sortBy(arr,function (el){
      return el[0];
    });
    _.map(arr,function (el){return obj[el[0]]=el[1];});
     console.log(obj);

डेमो

Answer 12

बहुत छोटा और सरल!

var sortedList = {};
Object.keys(list).sort((a,b) => list[a]-list[b]).forEach((key) => {
    sortedList[key] = list[key]; });

Answer 13

मैं स्लीबेटमैन द्वारा दिए गए समाधान का पालन कर रहा हूं (सभी विवरणों के लिए इसे पढ़ें), लेकिन समायोजित, चूंकि आपकी वस्तु गैर-नेस्टेड है।

// First create the array of keys/values so that we can sort it:
var sort_array = [];
for (var key in list) {
    sort_array.push({key:key,value:list[key]});
}

// Now sort it:
sort_array.sort(function(x,y){return x.value - y.value});

// Now process that object with it:
for (var i=0;i<sort_array.length;i++) {
    var item = list[sort_array[i].key];

    // now do stuff with each item
}

Answer 14

कई फॉर-लूप्स के बिना मानों को सॉर्ट करें (सॉर्ट कॉलबैक में कुंजी को बदलने के लिए सॉर्ट करें "0" पर)

const list = {
    "you": 100, 
    "me": 75, 
    "foo": 116, 
    "bar": 15
  };

let sorted = Object.fromEntries(
                Object.entries(list).sort( (a,b) => a[1] - b[1] )    
             ) 
console.log('Sorted object: ', sorted) 

Answer 15

यह एक वास्तविक ऑर्डर की गई वस्तु के रूप में इसे संभालने का एक सरल तरीका हो सकता है। निश्चित नहीं है कि यह कितना धीमा है। थोड़ी देर के लूप के साथ भी बेहतर हो सकता है।

Object.sortByKeys = function(myObj){
  var keys = Object.keys(myObj)
  keys.sort()
  var sortedObject = Object()
  for(i in keys){
    key = keys[i]
    sortedObject[key]=myObj[key]
   }

  return sortedObject

}

और फिर मुझे यह इनवर्ट फ़ंक्शन मिला: http://nelsonwells.net/2011/10/swap-object-key-and-values-in-javascript/

Object.invert = function (obj) {

  var new_obj = {};

  for (var prop in obj) {
    if(obj.hasOwnProperty(prop)) {
      new_obj[obj[prop]] = prop;
    }
  }

  return new_obj;
};

इसलिए

var list = {"you": 100, "me": 75, "foo": 116, "bar": 15};
var invertedList = Object.invert(list)
var invertedOrderedList = Object.sortByKeys(invertedList)
var orderedList = Object.invert(invertedOrderedList)

Answer 16

a = { b: 1, p: 8, c: 2, g: 1 }
Object.keys(a)
  .sort((c,b) => {
    return a[b]-a[c]
  })
  .reduce((acc, cur) => {
    let o = {}
    o[cur] = a[cur]
    acc.push(o)
    return acc
   } , [])

आउटपुट = [{p: 8}, {c: 2}, {b: 1}, {g: 1}]

Answer 17

बस मामले में, कोई व्यक्ति ऑब्जेक्ट (कुंजियों और मूल्यों के साथ) की तलाश में रहता है, @Markus R और @James Moran द्वारा कोड संदर्भ का उपयोग करके, बस उपयोग करें:

var list = {"you": 100, "me": 75, "foo": 116, "bar": 15};
var newO = {};
Object.keys(list).sort(function(a,b){return list[a]-list[b]})
                 .map(key => newO[key] = list[key]);
console.log(newO);  // {bar: 15, me: 75, you: 100, foo: 116}

Comments

आप इसमें एक असाइनमेंट लौटा रहे हैं map, forEachयह बेहतर होगा

— डिएगोब्रॉकेरो

Answer 18

let toSort = {a:2323, b: 14, c: 799} 
let sorted = Object.entries(toSort ).sort((a,b)=> a[1]-b[1]) 

आउटपुट:

[ [ "b", 14 ], [ "c", 799 ], [ "a", 2323 ] ]

Answer 19

कई समान और उपयोगी कार्य: https://github.com/shimondoodkin/groupbyfunctions/

function sortobj(obj)
{
    var keys=Object.keys(obj);
    var kva= keys.map(function(k,i)
    {
        return [k,obj[k]];
    });
    kva.sort(function(a,b){
        if(a[1]>b[1]) return -1;if(a[1]<b[1]) return 1;
        return 0
    });
    var o={}
    kva.forEach(function(a){ o[a[0]]=a[1]})
    return o;
}

function sortobjkey(obj,key)
{
    var keys=Object.keys(obj);
    var kva= keys.map(function(k,i)
    {
        return [k,obj[k]];
    });
    kva.sort(function(a,b){
        k=key;      if(a[1][k]>b[1][k]) return -1;if(a[1][k]<b[1][k]) return 1;
        return 0
    });
    var o={}
    kva.forEach(function(a){ o[a[0]]=a[1]})
    return o;
}

Answer 20

मान द्वारा छांटी गई वस्तु (DESC)

function sortObject(list) {
  var sortable = [];
  for (var key in list) {
    sortable.push([key, list[key]]);
  }

  sortable.sort(function(a, b) {
    return (a[1] > b[1] ? -1 : (a[1] < b[1] ? 1 : 0));
  });

  var orderedList = {};
  for (var i = 0; i < sortable.length; i++) {
    orderedList[sortable[i][0]] = sortable[i][1];
  }

  return orderedList;
}

Answer 21

यहाँ एक और उदाहरण है:

function sortObject(obj) {
  var arr = [];
  var prop;
  for (prop in obj) {
    if (obj.hasOwnProperty(prop)) {
      arr.push({
        'key': prop,
        'value': obj[prop]
      });
    }
  }
  arr.sort(function(a, b) {
    return a.value - b.value;
  });
  return arr; // returns array
}
var list = {
  car: 300,
  bike: 60,
  motorbike: 200,
  airplane: 1000,
  helicopter: 400,
  rocket: 8 * 60 * 60
};
var arr = sortObject(list);
console.log(arr);

Answer 22

    var list = {
    "you": 100,
    "me": 75,
    "foo": 116,
    "bar": 15
};
var tmpList = {};
while (Object.keys(list).length) {
    var key = Object.keys(list).reduce((a, b) => list[a] > list[b] ? a : b);
    tmpList[key] = list[key];
    delete list[key];
}
list = tmpList;
console.log(list); // { foo: 116, you: 100, me: 75, bar: 15 }

Answer 23

टाइपप्रति

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

/**
 * Represents an associative array of a same type.
 */
interface Dictionary<T> {
  [key: string]: T;
}

/**
 * Sorts an object (dictionary) by value or property of value and returns
 * the sorted result as a Map object to preserve the sort order.
 */
function sort<TValue>(
  obj: Dictionary<TValue>,
  valSelector: (val: TValue) => number | string,
) {
  const sortedEntries = Object.entries(obj)
    .sort((a, b) =>
      valSelector(a[1]) > valSelector(b[1]) ? 1 :
      valSelector(a[1]) < valSelector(b[1]) ? -1 : 0);
  return new Map(sortedEntries);
}

प्रयोग

var list = {
  "one": { height: 100, weight: 15 },
  "two": { height: 75, weight: 12 },
  "three": { height: 116, weight: 9 },
  "four": { height: 15, weight: 10 },
};

var sortedMap = sort(list, val => val.height);

एक जावास्क्रिप्ट ऑब्जेक्ट में कुंजियों के क्रम की गारंटी नहीं है, इसलिए मैं एक Mapऑब्जेक्ट के रूप में परिणाम को सॉर्ट और वापस कर रहा हूं जो सॉर्ट ऑर्डर को संरक्षित करता है।

यदि आप इसे वापस ऑब्जेक्ट में बदलना चाहते हैं, तो आप ऐसा कर सकते हैं:

var sortedObj = {} as any;
sortedMap.forEach((v,k) => { sortedObj[k] = v });

Answer 24

इनपुट ऑब्जेक्ट है, आउटपुट ऑब्जेक्ट है, लॉक्ड एंड जेएस का उपयोग करके, अवरोही या आरोही विकल्प के साथ, और इनपुट ऑब्जेक्ट को म्यूट नहीं करता है

जैसे इनपुट और आउटपुट

{
  "a": 1,
  "b": 4,
  "c": 0,
  "d": 2
}
{
  "b": 4,
  "d": 2,
  "a": 1,
  "c": 0
}

कार्यान्वयन

const _ = require('lodash');

const o = { a: 1, b: 4, c: 0, d: 2 };


function sortByValue(object, descending = true) {
  const { max, min } = Math;
  const selector = descending ? max : min;

  const objects = [];
  const cloned = _.clone(object);

  while (!_.isEmpty(cloned)) {
    const selectedValue = selector(...Object.values(cloned));
    const [key, value] = Object.entries(cloned).find(([, value]) => value === selectedValue);

    objects.push({ [key]: value });
    delete cloned[key];
  }

  return _.merge(...objects);
}

const o2 = sortByValue(o);
console.log(JSON.stringify(o2, null, 2));

Answer 25

const arrayOfObjects = [
{name: 'test'},
{name: 'test2'}
]

const order = ['test2', 'test']

const setOrder = (arrayOfObjects, order) =>
    arrayOfObjects.sort((a, b) => {
        if (order.findIndex((i) => i === a.name) < order.findIndex((i) => i === b.name)) {
            return -1;
        }

        if (order.findIndex((i) => i === a.name) > order.findIndex((i) => i === b.name)) {
            return 1;
        }

        return 0;
    });

Answer 26

सॉर्ट के साथ मेरा समाधान:

let list = {
    "you": 100, 
    "me": 75, 
    "foo": 116, 
    "bar": 15
};

let sorted = Object.entries(list).sort((a,b) => a[1] - b[1]);

for(let element of sorted) {
    console.log(element[0]+ ": " + element[1]);
}

Comments

कृपया कोड के रूप में अपने कोड को प्रारूपित करें

— इटाराम मुश्किन

Answer 27

<pre>
function sortObjectByVal(obj){  
var keysSorted = Object.keys(obj).sort(function(a,b){return obj[b]-obj[a]});
var newObj = {};
for(var x of keysSorted){
    newObj[x] = obj[x];
}
return newObj;

}
var list = {"you": 100, "me": 75, "foo": 116, "bar": 15};
console.log(sortObjectByVal(list));
</pre>

Comments

Stackoverflow में आपका स्वागत है। आपके द्वारा प्रदान किए गए उत्तर के अलावा, कृपया इस बात की संक्षिप्त व्याख्या प्रदान करें कि यह समस्या क्यों और कैसे ठीक होती है।

— jtate

Answer 28

इसे हल करने का दूसरा तरीका: -

var res = [{"s1":5},{"s2":3},{"s3":8}].sort(function(obj1,obj2){ 
 var prop1;
 var prop2;
 for(prop in obj1) {
  prop1=prop;
 }
 for(prop in obj2) {
  prop2=prop;
 }
 //the above two for loops will iterate only once because we use it to find the key
 return obj1[prop1]-obj2[prop2];
});

// Res का परिणाम सरणी होगा

Answer 29

धन्यवाद और उत्तर जारी रखें @Nosredna

अब जब हम समझते हैं कि वस्तु को सरणी में बदलना है तो सरणी को क्रमबद्ध करें। यह स्ट्रिंग द्वारा सरणी (या परिवर्तित ऑब्जेक्ट को सरणी में) सॉर्ट करने के लिए उपयोगी है:

Object {6: Object, 7: Object, 8: Object, 9: Object, 10: Object, 11: Object, 12: Object}
   6: Object
   id: "6"
   name: "PhD"
   obe_service_type_id: "2"
   __proto__: Object
   7: Object
   id: "7"
   name: "BVC (BPTC)"
   obe_service_type_id: "2"
   __proto__: Object


    //Sort options
    var sortable = [];
    for (var vehicle in options)
    sortable.push([vehicle, options[vehicle]]);
    sortable.sort(function(a, b) {
        return a[1].name < b[1].name ? -1 : 1;
    });


    //sortable => prints  
[Array[2], Array[2], Array[2], Array[2], Array[2], Array[2], Array[2]]
    0: Array[2]
    0: "11"
    1: Object
        id: "11"
        name: "AS/A2"
        obe_service_type_id: "2"
        __proto__: Object
        length: 2
        __proto__: Array[0]
    1: Array[2]
    0: "7"
    1: Object
        id: "7"
        name: "BVC (BPTC)"
        obe_service_type_id: "2"
        __proto__: Object
        length: 2

Answer 30

इसे इस्तेमाल करे। यहां तक ​​कि आपकी वस्तु भी उस संपत्ति पर आधारित नहीं है जिसके आधार पर आप छांटने की कोशिश कर रहे हैं।

बस वस्तु के साथ संपत्ति भेजकर इसे बुलाओ।

var sortObjectByProperty = function(property,object){

    console.time("Sorting");
    var  sortedList      = [];
         emptyProperty   = [];
         tempObject      = [];
         nullProperty    = [];
    $.each(object,function(index,entry){
        if(entry.hasOwnProperty(property)){
            var propertyValue = entry[property];
            if(propertyValue!="" && propertyValue!=null){
              sortedList.push({key:propertyValue.toLowerCase().trim(),value:entry});  
            }else{
                emptyProperty.push(entry);
           }
        }else{
            nullProperty.push(entry);
        }
    });

      sortedList.sort(function(a,b){
           return a.key < b.key ? -1 : 1;
         //return a.key < b.key?-1:1;   // Asc 
         //return a.key < b.key?1:-1;  // Desc
      });


    $.each(sortedList,function(key,entry){
        tempObject[tempObject.length] = entry.value;
     });

    if(emptyProperty.length>0){
        tempObject.concat(emptyProperty);
    }
    if(nullProperty.length>0){
        tempObject.concat(nullProperty);
    }
    console.timeEnd("Sorting");
    return tempObject;
}