जावास्क्रिप्ट में अपने मूल्यों के साथ एक साहचर्य सरणी कैसे सॉर्ट करें?

Question 1

मेरे पास सहयोगी सरणी है:

array["sub2"] = 1;
array["sub0"] = -1;
array["sub1"] = 0;
array["sub3"] = 1;
array["sub4"] = 0;

अपने मूल्यों द्वारा क्रमबद्ध (अवरोही) करने का सबसे सुंदर तरीका क्या है, जहां इस क्रम में संबंधित सूचकांकों के साथ एक सरणी होगी:

sub2, sub3, sub1, sub4, sub0

Question 2

जावास्क्रिप्ट में "साहचर्य सरणियाँ" नहीं हैं जिस तरह से आप उनके बारे में सोच रहे हैं। इसके बजाय, आपके पास सरणी-जैसे सिंटैक्स (आपके उदाहरण के अनुसार) का उपयोग करके ऑब्जेक्ट गुण सेट करने की क्षमता है, साथ ही किसी ऑब्जेक्ट के गुणों पर पुनरावृति करने की क्षमता है।

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

var tuples = [];

for (var key in obj) tuples.push([key, obj[key]]);

tuples.sort(function(a, b) {
    a = a[1];
    b = b[1];

    return a < b ? -1 : (a > b ? 1 : 0);
});

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

    // do something with key and value
}

आपको इसे एक फ़ंक्शन में लपेटना अधिक स्वाभाविक लग सकता है जो कॉलबैक लेता है:

function bySortedValue(obj, callback, context) {
  var tuples = [];

  for (var key in obj) tuples.push([key, obj[key]]);

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

  var length = tuples.length;
  while (length--) callback.call(context, tuples[length][0], tuples[length][1]);
}

bySortedValue({
  foo: 1,
  bar: 7,
  baz: 3
}, function(key, value) {
  document.getElementById('res').innerHTML += `${key}: ${value}<br>`
});

<p id='res'>Result:<br/><br/><p>

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

Question 3

'साहचर्य सरणी' के शब्दार्थ पर आपको सही करने के बजाय, मुझे लगता है कि आप यही चाहते हैं:

function getSortedKeys(obj) {
    var keys = keys = Object.keys(obj);
    return keys.sort(function(a,b){return obj[b]-obj[a]});
}

के लिए वास्तव में पुराने ब्राउज़र , तब इस का उपयोग करें:

function getSortedKeys(obj) {
    var keys = []; for(var key in obj) keys.push(key);
    return keys.sort(function(a,b){return obj[b]-obj[a]});
}

आप किसी ऑब्जेक्ट में (आपकी तरह) डंप करते हैं और चाबियों का एक सरणी प्राप्त करते हैं - एह गुण - पीछे, सॉर्ट किए गए अवरोही (संख्यात्मक) मान, एह, के मान, एह, ऑब्जेक्ट।

यह तभी काम करता है जब आपके मूल्य संख्यात्मक हों। function(a,b)आरोही काम करने के लिए छँटाई तंत्र को बदलने के लिए या stringमूल्यों के लिए काम करने के लिए थोड़ा उदाहरण दें (उदाहरण के लिए)। पाठक के लिए एक अभ्यास के रूप में छोड़ दिया।

Question 4

मूल्य पर एक (साहचर्य) सरणी को कैसे सॉर्ट करना है पर जारी चर्चा और अन्य समाधान ? सबसे अच्छा समाधान (मेरे मामले के लिए) saml (नीचे उद्धृत) द्वारा किया जा रहा है ।

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

var status = new Array();
status.push({name: 'BOB', val: 10});
status.push({name: 'TOM', val: 3});
status.push({name: 'ROB', val: 22});
status.push({name: 'JON', val: 7});

यदि आपको status.pushविधि पसंद है , तो आप इसे निम्न प्रकार से कर सकते हैं:

status.sort(function(a,b) {
    return a.val - b.val;
});

Question 5

वास्तव में जावास्क्रिप्ट में "साहचर्य सरणी" जैसी कोई चीज नहीं है। आपको जो मिला है, वह सिर्फ एक पुरानी पुरानी वस्तु है। वे तरह-तरह के सहयोगी सरणियों की तरह काम करते हैं, और चाबियां उपलब्ध हैं, लेकिन चाबियों के क्रम के आसपास कोई शब्दार्थ नहीं है।

आप अपने ऑब्जेक्ट को ऑब्जेक्ट्स (की / वैल्यू पेयर) में बदल सकते हैं और सॉर्ट कर सकते हैं:

function sortObj(object, sortFunc) {
  var rv = [];
  for (var k in object) {
    if (object.hasOwnProperty(k)) rv.push({key: k, value:  object[k]});
  }
  rv.sort(function(o1, o2) {
    return sortFunc(o1.key, o2.key);
  });
  return rv;
}

फिर आप इसे एक तुलनित्र फ़ंक्शन के साथ कहेंगे।

Question 6

यदि आप टुपल्स पसंद नहीं करते हैं, तो यहां बेन ब्लैंक के उत्तर की भिन्नता है।

यह आपको कुछ वर्ण बचाता है।

var keys = [];
for (var key in sortme) {
  keys.push(key);
}

keys.sort(function(k0, k1) {
  var a = sortme[k0];
  var b = sortme[k1];
  return a < b ? -1 : (a > b ? 1 : 0);
});

for (var i = 0; i < keys.length; ++i) {
  var key = keys[i];
  var value = sortme[key];
  // Do something with key and value.
}

Question 7

कोई अनावश्यक जटिलता की आवश्यकता नहीं है ...

function sortMapByValue(map)
{
    var tupleArray = [];
    for (var key in map) tupleArray.push([key, map[key]]);
    tupleArray.sort(function (a, b) { return a[1] - b[1] });
    return tupleArray;
}

Question 8

मैं jquery के $ .each का उपयोग करता हूं, लेकिन आप इसे लूप के साथ बना सकते हैं, एक सुधार यह है:

        //.ArraySort(array)
        /* Sort an array
         */
        ArraySort = function(array, sortFunc){
              var tmp = [];
              var aSorted=[];
              var oSorted={};

              for (var k in array) {
                if (array.hasOwnProperty(k)) 
                    tmp.push({key: k, value:  array[k]});
              }

              tmp.sort(function(o1, o2) {
                    return sortFunc(o1.value, o2.value);
              });                     

              if(Object.prototype.toString.call(array) === '[object Array]'){
                  $.each(tmp, function(index, value){
                      aSorted.push(value.value);
                  });
                  return aSorted;                     
              }

              if(Object.prototype.toString.call(array) === '[object Object]'){
                  $.each(tmp, function(index, value){
                      oSorted[value.key]=value.value;
                  });                     
                  return oSorted;
              }               
     };

तो अब आप कर सकते हैं

    console.log("ArraySort");
    var arr1 = [4,3,6,1,2,8,5,9,9];
    var arr2 = {'a':4, 'b':3, 'c':6, 'd':1, 'e':2, 'f':8, 'g':5, 'h':9};
    var arr3 = {a: 'green', b: 'brown', c: 'blue', d: 'red'};
    var result1 = ArraySort(arr1, function(a,b){return a-b});
    var result2 = ArraySort(arr2, function(a,b){return a-b});
    var result3 = ArraySort(arr3, function(a,b){return a>b});
    console.log(result1);
    console.log(result2);       
    console.log(result3);

Question 9

मेरी राय में, यहां के विशिष्ट मामले के लिए सबसे अच्छा तरीका एक आम सुझाव है। थोड़ा सुधार मैं सुझाव दूंगा कि आधुनिक ब्राउज़रों में काम करता है:

// aao is the "associative array" you need to "sort"
Object.keys(aao).sort(function(a,b){return aao[b]-aao[a]});

यह आसानी से लागू हो सकता है और विशिष्ट मामले में शानदार काम कर सकता है ताकि आप कर सकें:

let aoo={};
aao["sub2"]=1;
aao["sub0"]=-1;
aao["sub1"]=0;
aao["sub3"]=1;
aao["sub4"]=0;

let sk=Object.keys(aao).sort(function(a,b){return aao[b]-aao[a]});

// now you can loop using the sorted keys in `sk` to do stuffs
for (let i=sk.length-1;i>=0;--i){
 // do something with sk[i] or aoo[sk[i]]
}

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

// aao := is the "associative array" you need to "sort"
// comp := is the "field" you want to compare or "" if you have no "fields" and simply need to compare values
// intVal := must be false if you need comparing non-integer values
// desc := set to true will sort keys in descendant order (default sort order is ascendant)
function sortedKeys(aao,comp="",intVal=false,desc=false){
  let keys=Object.keys(aao);
  if (comp!="") {
    if (intVal) {
      if (desc) return keys.sort(function(a,b){return aao[b][comp]-aao[a][comp]});
      else return keys.sort(function(a,b){return aao[a][comp]-aao[a][comp]});
    } else {
      if (desc) return keys.sort(function(a,b){return aao[b][comp]<aao[a][comp]?1:aao[b][comp]>aao[a][comp]?-1:0});
      else return keys.sort(function(a,b){return aao[a][comp]<aao[b][comp]?1:aao[a][comp]>aao[b][comp]?-1:0});
    }
  } else {
    if (intVal) {
      if (desc) return keys.sort(function(a,b){return aao[b]-aao[a]});
      else return keys.sort(function(a,b){return aao[a]-aao[b]});
    } else {
      if (desc) return keys.sort(function(a,b){return aao[b]<aao[a]?1:aao[b]>aao[a]?-1:0});
      else return keys.sort(function(a,b){return aao[a]<aao[b]?1:aao[a]>aao[b]?-1:0});
    }
  }
}

आप निम्न कोड की तरह कुछ की कोशिश कर कार्यात्मकता का परीक्षण कर सकते हैं:

let items={};
items['Edward']=21;
items['Sharpe']=37;
items['And']=45;
items['The']=-12;
items['Magnetic']=13;
items['Zeros']=37;
//equivalent to:
//let items={"Edward": 21, "Sharpe": 37, "And": 45, "The": -12, ...};

console.log("1: "+sortedKeys(items));
console.log("2: "+sortedKeys(items,"",false,true));
console.log("3: "+sortedKeys(items,"",true,false));
console.log("4: "+sortedKeys(items,"",true,true));
/* OUTPUT
1: And,Sharpe,Zeros,Edward,Magnetic,The
2: The,Magnetic,Edward,Sharpe,Zeros,And
3: The,Magnetic,Edward,Sharpe,Zeros,And
4: And,Sharpe,Zeros,Edward,Magnetic,The
*/

items={};
items['k1']={name:'Edward',value:21};
items['k2']={name:'Sharpe',value:37};
items['k3']={name:'And',value:45};
items['k4']={name:'The',value:-12};
items['k5']={name:'Magnetic',value:13};
items['k6']={name:'Zeros',value:37};

console.log("1: "+sortedKeys(items,"name"));
console.log("2: "+sortedKeys(items,"name",false,true));
/* OUTPUT
1: k6,k4,k2,k5,k1,k3
2: k3,k1,k5,k2,k4,k6
*/

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

let sk=sortedKeys(aoo);
// now you can loop using the sorted keys in `sk` to do stuffs
for (let i=sk.length-1;i>=0;--i){
 // do something with sk[i] or aoo[sk[i]]
}

अंतिम, लेकिन कम से कम, Object.keys और Array.sort के लिए कुछ उपयोगी संदर्भ

Question 10

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

let arr = [
    {a:1, b:2, c:3},
    {a:3, b:5, c:1},
    {a:2, b:3, c:9},
    {a:2, b:5, c:9},
    {a:2, b:3, c:10}    
]

function getSortedScore(obj) {
    var keys = []; 
    for(var key in obj[0]) keys.push(key);
    return obj.sort(function(a,b){
        for (var i in keys) {
            let k = keys[i];
            if (a[k]-b[k] > 0) return -1;
            else if (a[k]-b[k] < 0) return 1;
            else continue;
        };
    });
}

console.log(getSortedScore(arr))

ouputs

 [ { a: 3, b: 5, c: 1 },
  { a: 2, b: 5, c: 9 },
  { a: 2, b: 3, c: 10 },
  { a: 2, b: 3, c: 9 },
  { a: 1, b: 2, c: 3 } ]

Question 11

@ कॉमनपाइक का जवाब "सही है", लेकिन जैसा कि वह टिप्पणी पर जाता है ...

आजकल ज्यादातर ब्राउज़र सिर्फ समर्थन करते हैं Object.keys()

हाँ .. Object.keys()है रास्ता बेहतर ।

लेकिन इससे भी बेहतर क्या है ? यह, यह में है coffeescript!

sortedKeys = (x) -> Object.keys(x).sort (a,b) -> x[a] - x[b]

sortedKeys
  'a' :  1
  'b' :  3
  'c' :  4
  'd' : -1

[ 'd', 'a', 'b', 'c' ]