Instead of delving into the semantics of an 'associative array', I believe this approach may better suit your needs:

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

For outdated browsers, consider using the following alternative:

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

This function takes an object (similar to yours) as input and outputs an array of sorted keys in descending order based on the numerical values within the object.

Keep in mind that this method is tailored for numerical values. Adjust the function(a,b) within the sorting algorithm to handle ascending order or non-numerical values (such as strings). A challenge left for the reader to tackle.

Expanded dialogue & additional solutions can be found at How to organize an (associative) array by its values?, where the most suitable solution (in my situation) was provided by saml (referenced below).

Arrays are restricted to numerical indexes. To address this, the array should be restructured either as an Object or an Array of Objects.

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

If the status.push method is preferred, it can be sorted using the following:

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

In the realm of JavaScript, the concept of an "associative array" is merely a myth. What you actually have is a basic object. While they may resemble associative arrays in some ways, the keys are accessible without any inherent key order.

If needed, you can transform your object into an array of objects containing key/value pairs and then apply a sorting function:

function sortObject(obj, sortFunction) {
  var result = [];
  for (var key in obj) {
    if(obj.hasOwnProperty(key)) result.push({key: key, value: obj[key]});
  }
  result.sort(function(item1, item2) {
    return sortFunction(item1.key, item2.key);
  });
  return result;
}

Simply invoke this function with a custom comparator function.

In my view, the most effective strategy for this particular case is the recommendation made by commonpike. To enhance it for modern browsers, I would propose the following adjustment:

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

This method can be easily implemented and perform exceptionally well in this specific scenario. Here's an example of how you can utilize it:

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]});

// loop through the sorted keys in `sk` to perform tasks
for (let i=sk.length-1;i>=0;--i){
 // manipulate sk[i] or aoo[sk[i]]
}

In addition, I have included a more "generic" function below that allows for sorting in a wider range of situations. It combines my suggested improvement with the methods from answers provided by Ben Blank and PopeJohnPaulII, enabling you to choose between ascending and descending order:

// aao := the "associative array" you wish to "sort"
// comp := the "field" to compare or "" if no "fields" and only need to compare values
// intVal := false if comparing non-integer values
// desc := set to true to sort keys in descending order (default is ascending)
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});
    }
  }
}

You can experiment with the functionality using the code snippets below:

let items={};
items['Edward']=21;
items['Sharpe']=37;
items['And']=45;
items['The']=-12;
items['Magnetic']=13;
items['Zeros']=37;

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));

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));

Feel free to loop through the sorted keys using the below code:

let sk=sortedKeys(aoo);
// loop through the sorted keys in `sk` to perform tasks
for (let i=sk.length-1;i>=0;--i){
 // manipulate sk[i] or aoo[sk[i]]
}

Finally, I have included some helpful references to Object.keys and Array.sort

If you prefer not using tuples, here's an alternative to ben blank's answer that can save you some characters.

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];
  // Implement your logic for key and value.
}

No need for unnecessary complexity...

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

Utilizing the power of jQuery's $.each function, the following ArraySort function can be improved using a for loop:

        //.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;
              }               
     };

By making the above adjustment, the sorting can now be achieved as follows:

    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);

For those who are in search of tuple-based sorting options, here's a method that compares elements based on their positions within an object array. The comparison is done by the first element, followed by the second, and so on. In the example below, the comparison is done first based on "a", then "b", and so forth.

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))

OUTPUTS

 [ { 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 } ]

Here's a contemporary approach for handling this:

const topFiveSorted = Object.fromEntries(Object.entries(data).sort((a, b) => b[1] - a[1]).slice(0, 5));

Note: I included an optional slice function, feel free to omit it based on your needs.