Accedere alle proprietà dell'oggetto non numerico per indice?

Se ho un array come questo:

var arr = ['one','two','three'];

Posso accedere a diverse parti in questo modo:

console.log(arr[1]);

Come posso accedere alle proprietà degli oggetti in base al loro ordine anziché in base alla chiave?

Esempio:

var obj = {
    'something' : 'awesome',
    'evenmore'  : 'crazy'
},
jbo = {
    'evenmore'  : 'crazy',
    'something' : 'awesome'
};

Come posso ottenere la prima proprietà per ogni oggetto - "qualcosa" da obje "ancora di più" - jbosenza utilizzare esplicitamente il nome della proprietà?

Ora, alcuni di voi sembrano pensare che io stia cercando qualcosa come:

console.log(obj['something']);

Questo non è il caso, sto specificatamente cercando di indirizzare l'indice, proprio come il primo esempio, se possibile.

"Sto specificatamente cercando di indirizzare l'indice, proprio come il primo esempio, se possibile."

No, non è possibile.

Il più vicino che puoi ottenere è ottenere un array delle chiavi dell'oggetto e usarlo:

var keys = Object.keys( obj );

... ma non c'è garanzia che le chiavi vengano restituite nell'ordine che hai definito. Quindi potrebbe finire per sembrare:

keys[ 0 ];  // 'evenmore'
keys[ 1 ];  // 'something'

L'unico modo in cui posso pensare di farlo è creare un metodo che ti dia la proprietà usando Object.keys();.

var obj = {
    dog: "woof",
    cat: "meow",
    key: function(n) {
        return this[Object.keys(this)[n]];
    }
};
obj.key(1); // "meow"

Demo: http://jsfiddle.net/UmkVn/

Sarebbe possibile estenderlo a tutti gli oggetti utilizzando, Object.prototype;ma di solito non è raccomandato.

Utilizza invece un helper di funzione:

var object = {
  key: function(n) {
    return this[ Object.keys(this)[n] ];
  }
};

function key(obj, idx) {
  return object.key.call(obj, idx);
}

key({ a: 6 }, 0); // 6

Puoi usare il Object.values()metodo se non vuoi usare il Object.keys().

Al contrario del Object.keys()metodo che restituisce un array di proprietà enumerabili di un dato oggetto, quindi per esempio:

const object1 = {
 a: 'somestring',
 b: 42,
 c: false
};

console.log(Object.keys(object1));

Stamperebbe il seguente array:

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

Il Object.values()metodo restituisce un array della proprietà enumerabile di un determinato oggetto values.

Quindi, se hai lo stesso oggetto ma usi invece i valori,

const object1 = {
 a: 'somestring',
 b: 42,
 c: false
};

console.log(Object.values(object1));

Otterrai il seguente array:

[ 'somestring', 42, false ]

Quindi, se volessi accedere al file object1.b , ma usando invece un indice potresti usare:

Object.values(object1)[1] === 42

Puoi leggere di più su questo metodo qui .

var obj = {
    'key1':'value',
    '2':'value',
    'key 1':'value'
}

console.log(obj.key1)
console.log(obj['key1'])
console.log(obj['2'])
console.log(obj['key 1'])

// will not work
console.log(obj.2)

Modificare:

"Sto specificatamente cercando di indirizzare l'indice, proprio come il primo esempio, se possibile."

In realtà l '"indice" è la chiave. Se vuoi memorizzare la posizione di una chiave devi creare un oggetto personalizzato per gestirla.

da jquery puoi farlo:

var arr = $.map(obj,function(value, key) {
    return value;
});
alert(obj[0]);

Prendi l'array di chiavi, invertilo, quindi esegui il ciclo

  var keys = Object.keys( obj ).reverse();
  for(var i = 0; i < keys.length; i++){
    var key = keys[i];
    var value = obj[key];
    //do stuff backwards
  }

è possibile creare un array riempito con i campi oggetto e utilizzare un indice sull'array e accedere alle proprietà dell'oggetto tramite quello

propertiesName:['pr1','pr2','pr3']

this.myObject[this.propertiesName[0]]

Sono andato avanti e ho creato una funzione per te:

 Object.prototype.getValueByIndex = function (index) {
     /*
         Object.getOwnPropertyNames() takes in a parameter of the object, 
         and returns an array of all the properties.
         In this case it would return: ["something","evenmore"].
         So, this[Object.getOwnPropertyNames(this)[index]]; is really just the same thing as:
         this[propertyName]
    */
    return this[Object.getOwnPropertyNames(this)[index]];
};

let obj = {
    'something' : 'awesome',
    'evenmore'  : 'crazy'
};

console.log(obj.getValueByIndex(0)); // Expected output: "awesome"

Se non sei sicuro che Object.keys () ti restituirà le chiavi nell'ordine corretto, puoi invece provare questa logica

var keys = []
var obj = {
    'key1' : 'value1',
    'key2' : 'value2',
    'key3' : 'value3',
}
for (var key in obj){
    keys.push(key)
}
console.log(obj[keys[1]])
console.log(obj[keys[2]])
console.log(obj[keys[3]])