¿Acceder a propiedades de objetos no numéricos por índice?

Si tengo una matriz como esta:

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

Puedo acceder a diferentes partes haciendo esto:

console.log(arr[1]);

¿Cómo puedo acceder a las propiedades del objeto por su orden en lugar de por clave?

Ejemplo:

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

¿Cómo obtendría la primera propiedad para cada objeto - "algo" de obje "incluso más" de - jbosin usar explícitamente el nombre de la propiedad?

Ahora, algunos de ustedes parecen pensar que estoy detrás de algo como:

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

Este no es el caso, estoy buscando específicamente apuntar al índice, al igual que en el primer ejemplo, si es posible.

"Estoy buscando específicamente apuntar al índice, como en el primer ejemplo, si es posible".

No, no es posible.

Lo más cercano que puede obtener es obtener una matriz de las claves del objeto y usarla:

var keys = Object.keys( obj );

... pero no hay garantía de que las claves se devuelvan en el orden que definió. Entonces podría terminar pareciendo:

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

La única forma en que puedo pensar en hacer esto es creando un método que le proporcione la propiedad using Object.keys();.

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

Demostración: http://jsfiddle.net/UmkVn/

Sería posible extender esto a todos los objetos que usan, Object.prototype;pero generalmente no se recomienda.

En su lugar, use una función auxiliar:

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

Puede utilizar el Object.values()método si no desea utilizar elObject.keys() .

A diferencia del Object.keys()método que devuelve una matriz de las propiedades enumerables propias de un objeto dado, por ejemplo:

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

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

Imprimiría la siguiente matriz:

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

El Object.values()método devuelve una matriz de la propiedad enumerable propia de un objeto dado.values .

Entonces, si tiene el mismo objeto pero usa valores en su lugar,

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

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

Obtendría la siguiente matriz:

[ 'somestring', 42, false ]

Entonces, si desea acceder al object1.b , pero usando un índice en su lugar, puede usar:

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

Puede leer más sobre este método aquí .

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)

Editar:

"Estoy buscando específicamente apuntar al índice, como en el primer ejemplo, si es posible".

En realidad, el 'índice' es la clave. Si desea almacenar la posición de una clave, debe crear un objeto personalizado para manejar esto.

por jquery puedes hacer esto:

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

Obtenga la matriz de claves, inviértala, luego ejecute su 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
  }

puede crear una matriz que se llene con los campos de su objeto y usar un índice en la matriz y acceder a las propiedades del objeto a través de eso

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

this.myObject[this.propertiesName[0]]

Seguí adelante e hice una función para ti:

 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 no está seguro de que Object.keys () le devolverá las claves en el orden correcto, puede probar esta lógica en su lugar

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