दोस्तों मैं बहुत हैरान हूँ! यकीन है कि सभी उत्तर कुछ पुराने हैं, लेकिन किसी ने भी छँटाई में स्थिरता का उल्लेख नहीं किया! इसलिए मेरे साथ रहिए मैं स्वयं इस प्रश्न का उत्तर देने की पूरी कोशिश करूंगा और यहां विवरण में जाऊंगा। इसलिए मैं अब माफी मांगने जा रहा हूं, यह पढ़ने के लिए बहुत कुछ होगा।
चूंकि यह 2018 है मैं केवल ES6 का उपयोग करूंगा, पॉलिफिल्स एमडीएन डॉक्स पर सभी उपलब्ध हैं, जिन्हें मैं दिए गए भाग में लिंक करूंगा।
सवाल का जवाब है:
यदि आपकी कुंजियाँ केवल संख्याएँ हैं, तो आप क्रमबद्ध वस्तु को वापस करने के लिए सुरक्षित रूप से Object.keys()एक साथ उपयोग कर सकते हैं Array.prototype.reduce():
// Only numbers to show it will be sorted.
const testObj = {
'2000': 'Articel1',
'4000': 'Articel2',
'1000': 'Articel3',
'3000': 'Articel4',
};
// I'll explain what reduces does after the answer.
console.log(Object.keys(testObj).reduce((accumulator, currentValue) => {
accumulator[currentValue] = testObj[currentValue];
return accumulator;
}, {}));
/**
* expected output:
* {
* '1000': 'Articel3',
* '2000': 'Articel1',
* '3000': 'Articel4',
* '4000': 'Articel2'
* }
*/
// if needed here is the one liner:
console.log(Object.keys(testObj).reduce((a, c) => (a[c] = testObj[c], a), {}));
हालाँकि, अगर आप तार के साथ काम कर रहे हैं, तो मैं Array.prototype.sort()इस सब में चैनिंग करने की सलाह देता हूँ :
// String example
const testObj = {
'a1d78eg8fdg387fg38': 'Articel1',
'z12989dh89h31d9h39': 'Articel2',
'f1203391dhj32189h2': 'Articel3',
'b10939hd83f9032003': 'Articel4',
};
// Chained sort into all of this.
console.log(Object.keys(testObj).sort().reduce((accumulator, currentValue) => {
accumulator[currentValue] = testObj[currentValue];
return accumulator;
}, {}));
/**
* expected output:
* {
* a1d78eg8fdg387fg38: 'Articel1',
* b10939hd83f9032003: 'Articel4',
* f1203391dhj32189h2: 'Articel3',
* z12989dh89h31d9h39: 'Articel2'
* }
*/
// again the one liner:
console.log(Object.keys(testObj).sort().reduce((a, c) => (a[c] = testObj[c], a), {}));
अगर कोई सोच रहा है कि क्या कम होता है:
// Will return Keys of object as an array (sorted if only numbers or single strings like a,b,c).
Object.keys(testObj)
// Chaining reduce to the returned array from Object.keys().
// Array.prototype.reduce() takes one callback
// (and another param look at the last line) and passes 4 arguments to it:
// accumulator, currentValue, currentIndex and array
.reduce((accumulator, currentValue) => {
// setting the accumulator (sorted new object) with the actual property from old (unsorted) object.
accumulator[currentValue] = testObj[currentValue];
// returning the newly sorted object for the next element in array.
return accumulator;
// the empty object {} ist the initial value for Array.prototype.reduce().
}, {});
यदि यहाँ एक लाइनर के लिए स्पष्टीकरण आवश्यक है:
Object.keys(testObj).reduce(
// Arrow function as callback parameter.
(a, c) =>
// parenthesis return! so we can safe the return and write only (..., a);
(a[c] = testObj[c], a)
// initial value for reduce.
,{}
);
क्यों छंटनी थोड़ी जटिल है:
संक्षेप Object.keys()में उसी क्रम के साथ एक सरणी लौटाएंगे जैसा कि हम एक सामान्य लूप के साथ प्राप्त करते हैं:
const object1 = {
a: 'somestring',
b: 42,
c: false
};
console.log(Object.keys(object1));
// expected output: Array ["a", "b", "c"]
Object.keys () एक सरणी देता है, जिसके तत्व सीधे ऑब्जेक्ट पर पाए जाने वाले असंख्य गुणों के अनुरूप होते हैं। गुणों का क्रम वही होता है जो वस्तु के गुणों पर मैन्युअल रूप से लूपिंग द्वारा दिया जाता है।
सिडेनोट - आप Object.keys()सरणियों पर भी उपयोग कर सकते हैं , ध्यान रखें कि सूचकांक वापस आ जाएगा:
// simple array
const arr = ['a', 'b', 'c'];
console.log(Object.keys(arr)); // console: ['0', '1', '2']
लेकिन यह उतना आसान नहीं है जितना कि उन उदाहरणों द्वारा दिखाया गया है, वास्तविक दुनिया की वस्तुओं में संख्याएँ और वर्णमाला के अक्षर या प्रतीक भी हो सकते हैं (कृपया ऐसा न करें)।
यहाँ एक वस्तु में उन सभी के साथ एक उदाहरण दिया गया है:
// This is just to show what happens, please don't use symbols in keys.
const testObj = {
'1asc': '4444',
1000: 'a',
b: '1231',
'#01010101010': 'asd',
2: 'c'
};
console.log(Object.keys(testObj));
// output: [ '2', '1000', '1asc', 'b', '#01010101010' ]
अब अगर हम Array.prototype.sort()आउटपुट में बदलाव से ऊपर के ऐरे पर उपयोग करते हैं:
console.log(Object.keys(testObj).sort());
// output: [ '#01010101010', '1000', '1asc', '2', 'b' ]
यहाँ डॉक्स से एक उद्धरण है:
सॉर्ट () विधि एक सरणी के तत्वों को जगह में सॉर्ट करती है और सरणी को वापस करती है। सॉर्ट आवश्यक रूप से स्थिर नहीं है। डिफ़ॉल्ट सॉर्ट क्रम स्ट्रिंग यूनिकोड कोड बिंदुओं के अनुसार है।
इस तरह के समय और स्थान की जटिलता की गारंटी नहीं दी जा सकती क्योंकि यह कार्यान्वयन पर निर्भर है।
आपको यह सुनिश्चित करना होगा कि उनमें से एक आपके लिए वांछित आउटपुट लौटाए। यदि आप एक साथ एपीआई और डेटाबेस जैसे विभिन्न सूचना इनपुट का उपयोग करते हैं, तो वास्तविक जीवन के उदाहरणों में लोग चीजों को पूरी तरह से मिलाते हैं।
तो कौन सी बड़ी बात है?
वैसे दो लेख हैं जिन्हें हर प्रोग्रामर को समझना चाहिए:
इन-प्लेस एल्गोरिथम :
कंप्यूटर विज्ञान में, एक इन-प्लेस एल्गोरिथ्म एक एल्गोरिथ्म है जो बिना किसी सहायक डेटा संरचना का उपयोग किए इनपुट को बदल देता है। हालांकि सहायक चर के लिए अतिरिक्त भंडारण स्थान की एक छोटी राशि की अनुमति है। एल्गोरिथ्म के निष्पादित होते ही इनपुट आमतौर पर आउटपुट द्वारा अधिलेखित हो जाता है। इन-प्लेस एल्गोरिथ्म केवल तत्वों के प्रतिस्थापन या अदला-बदली के माध्यम से इनपुट अनुक्रम को अपडेट करता है। एक एल्गोरिथ्म जो कभी-कभी अंदर नहीं होता है उसे कभी-कभी अंदर या बाहर का स्थान नहीं कहा जाता है।
तो मूल रूप से हमारे पुराने सरणी को अधिलेखित कर दिया जाएगा! यह महत्वपूर्ण है यदि आप अन्य कारणों से पुराने सरणी को रखना चाहते हैं। इसलिए इस बात का ध्यान रखें।
छँटाई एल्गोरिथ्म
स्थिर क्रम एल्गोरिदम समान तत्वों को उसी क्रम में क्रमबद्ध करते हैं जो वे इनपुट में दिखाई देते हैं। कुछ प्रकार के डेटा को सॉर्ट करते समय, सॉर्ट क्रम का निर्धारण करते समय डेटा के केवल भाग की जांच की जाती है। उदाहरण के लिए, कार्ड के दाईं ओर के सॉर्टिंग उदाहरण में, कार्ड को उनकी रैंक के आधार पर सॉर्ट किया जा रहा है, और उनके सूट को नजरअंदाज किया जा रहा है। यह मूल सूची के कई अलग-अलग सही ढंग से सॉर्ट किए गए संस्करणों की संभावना को अनुमति देता है। स्थिर सॉर्टिंग एल्गोरिदम इनमें से एक का चयन करता है, निम्न नियम के अनुसार: यदि दो आइटम समान तुलना करते हैं, जैसे दो 5 कार्ड, तो उनके सापेक्ष क्रम को संरक्षित किया जाएगा, ताकि यदि कोई इनपुट में दूसरे से पहले आए, तो यह भी होगा आउटपुट में दूसरे से पहले आते हैं।
ताश खेलने पर स्थिर प्रकार का उदाहरण। जब कार्डों को एक स्थिर क्रम के साथ रैंक द्वारा सॉर्ट किया जाता है, तो दो 5s को क्रमबद्ध आउटपुट में उसी क्रम में रहना चाहिए, जिसमें वे मूल रूप से थे। जब वे एक गैर-स्थिर सॉर्ट के साथ सॉर्ट किए जाते हैं, तो 5 एस विपरीत में समाप्त हो सकते हैं। क्रमबद्ध आउटपुट में आदेश।
इससे पता चलता है कि छंटाई सही है लेकिन यह बदल गया। तो असली दुनिया में भी अगर छँटाई सही है तो हमें यह सुनिश्चित करना होगा कि हमें वही मिले जिसकी हमें उम्मीद है! यह सुपर महत्वपूर्ण है इसे भी ध्यान में रखें। अधिक जावास्क्रिप्ट उदाहरणों के लिए Array.prototype.sort () - डॉक्स: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects-Array/sort देखें
