Posso eseguire il ciclo di un oggetto javascript in ordine inverso?

Question

Così ho un oggetto JavaScript come questo:

foo = { 
    "one": "some", 
    "two": "thing", 
    "three": "else" 
}; 

posso ciclo questo tipo:

for (var i in foo) { 
    if (foo.hasOwnProperty(i)) { 
    // do something 
    } 
} 

che sarà un ciclo tra le proprietà in ordine di one>two>three.

Tuttavia a volte ho bisogno di passare in ordine inverso, quindi mi piacerebbe fare lo stesso ciclo, ma three>two>one.

Domanda:
Esiste una funzione di "oggetto-inverso". Se si trattasse di un array, potrei invertire o creare un nuovo array con unshift ma sono perso con cosa fare con un oggetto, quando ho bisogno di invertire le sue proprietà. Qualche idea?

Grazie!

Answer 1

oggetti JavaScript non hanno un ordine intrinseco garantito, quindi non esiste un ordine di "inverso".

4.3.3 Oggetto Un oggetto è un membro del tipo Oggetto. È una collezione non ordinata di proprietà ognuna delle quali contiene un valore, oggetto o funzione primitivo . Una funzione memorizzata in una proprietà di un oggetto viene chiamata metodo.

browser sembrano restituire le proprietà nello stesso ordine in cui sono stati aggiunti per l'oggetto, ma dal momento che questo non è standard, probabilmente non dovrebbe fare affidamento su questo comportamento.

una semplice funzione che chiama una funzione per ogni proprietà in ordine inverso a quello già assegnato dal for..in del browser, è questa:

// f is a function that has the obj as 'this' and the property name as first parameter 
function reverseForIn(obj, f) { 
    var arr = []; 
    for (var key in obj) { 
    // add hasOwnPropertyCheck if needed 
    arr.push(key); 
    } 
    for (var i=arr.length-1; i>=0; i--) { 
    f.call(obj, arr[i]); 
    } 
} 

//usage 
reverseForIn(obj, function(key){ console.log('KEY:', key, 'VALUE:', this[key]); }); 

lavoro JsBin: http://jsbin.com/aPoBAbE/1/edit

Ancora una volta dico che l'ordine di for..in non è garantito, quindi l'ordine inverso non è garantito. Usare con cautela!

Answer 2

v'è alcun modo per eseguire un ciclo attraverso un oggetto indietro, ma se si ricrea l'oggetto in ordine inverso allora siete d'oro! Essere precauzioni, tuttavia, non v'è nulla che dice che l'ordine dell'oggetto rimarrà lo stesso come cambia e quindi questo potrebbe portare a qualche risultato interessante, ma per la maggior parte funziona ...

function ReverseObject(Obj){ 
    var TempArr = []; 
    var NewObj = []; 
    for (var Key in Obj){ 
     TempArr.push(Key); 
    } 
    for (var i = TempArr.length-1; i >= 0; i--){ 
     NewObj[TempArr[i]] = []; 
    } 
    return NewObj; 
} 

Il giusto fare lo swap sul vostro oggetto come questo-

MyObject = ReverseObject(MyObject); 

l'anello sarebbe quindi simile a questo-

for (var KeysAreNowBackwards in MyObject){ 
    alert(MyObject[KeysAreNowBackwards]); 
} 

Answer 3

È possibile utilizzare la funzione di non innesto per memorizzare i tuoi oggetti in ordine inverso all'interno di una n array.

function reverse(items, func){ 
    var reversed = Array(); 
    for(var key in items){ 
     reversed.unshift(items[key]); 
    } 
    if(func){ 
     for(var key in reversed){ 
      func(key, reversed[key]); 
     } 
    } 
    return reversed; 
} 

Uso

// Loop through your object in reverse order 
reverse(foo, function(key, obj){ 
    console.log(key, obj); 
}); 

// Get a reversed copy of your object 
var reversedObject = reverse(foo); 

// Loop through your object in reverse order and get a reversed copy 
var reversedObject = reverse(foo, function(key, obj){ 
    console.log(key, obj); 
});