Accéder aux propriétés d'objets non numériques par index?

Si j'ai un tableau comme celui-ci:

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

Je peux accéder à différentes parties en faisant ceci:

console.log(arr[1]);

Comment puis-je accéder aux propriétés des objets par leur ordre plutôt que par clé?

Exemple:

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

Comment puis-je obtenir la première propriété pour chaque objet - "quelque chose" à partir objet "encore plus" de - jbosans utiliser explicitement le nom de la propriété?

Maintenant, quelques-uns d'entre vous semblent penser que je suis après quelque chose comme:

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

Ce n'est pas le cas, je cherche spécifiquement à cibler l'index, tout comme le premier exemple - si c'est possible.

"Je cherche spécifiquement à cibler l'index, tout comme le premier exemple - si c'est possible."

Non, ce n'est pas possible.

Le plus proche que vous puissiez obtenir est d'obtenir un tableau des clés de l'objet et de l'utiliser:

var keys = Object.keys( obj );

... mais il n'y a aucune garantie que les clés seront retournées dans l'ordre que vous avez défini. Cela pourrait donc ressembler à:

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

La seule façon dont je peux penser à faire cela est de créer une méthode qui vous donne la propriété en utilisant Object.keys();.

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

Démo: http://jsfiddle.net/UmkVn/

Il serait possible d'étendre cela à tous les objets en utilisant Object.prototype;mais ce n'est généralement pas recommandé.

Au lieu de cela, utilisez un assistant de fonction:

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

Vous pouvez utiliser la Object.values()méthode si vous ne souhaitez pas utiliser le Object.keys().

Contrairement à la Object.keys()méthode qui retourne un tableau des propres propriétés énumérables d'un objet donné, par exemple:

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

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

Imprime le tableau suivant:

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

La Object.values()méthode retourne un tableau de la propriété énumérable propre à un objet donné values.

Donc, si vous avez le même objet mais utilisez des valeurs à la place,

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

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

Vous obtiendrez le tableau suivant:

[ 'somestring', 42, false ]

Donc, si vous souhaitez accéder au object1.b, mais en utilisant un index à la place, vous pouvez utiliser:

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

Vous pouvez en savoir plus sur cette méthode ici .

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)

Éditer:

"Je cherche spécifiquement à cibler l'index, tout comme le premier exemple - si c'est possible."

En fait, l '«index» est la clé. Si vous souhaitez stocker la position d'une clé, vous devez créer un objet personnalisé pour gérer cela.

par jquery vous pouvez faire ceci:

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

Récupérez le tableau de clés, inversez-le, puis exécutez votre boucle

  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
  }

vous pouvez créer un tableau rempli de vos champs d'objet et utiliser un index sur le tableau et accéder aux propriétés de l'objet via ce

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

this.myObject[this.propertiesName[0]]

Je suis allé de l'avant et j'ai créé une fonction pour vous:

 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"

Si vous n'êtes pas sûr qu'Object.keys () va vous renvoyer les clés dans le bon ordre, vous pouvez essayer cette logique à la place

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