Acessar propriedades não numéricas do objeto por índice?

Se eu tiver uma matriz como esta:

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

Posso acessar diferentes partes fazendo isto:

console.log(arr[1]);

Como posso acessar as propriedades do objeto por sua ordem em vez de por chave?

Exemplo:

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

Como obteria a primeira propriedade para cada objeto - "algo" de obje "ainda mais" de jbo- sem usar explicitamente o nome da propriedade?

Agora, alguns de vocês parecem pensar que estou atrás de algo como:

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

Este não é o caso, estou procurando especificamente direcionar o índice, assim como o primeiro exemplo - se for possível.

"Estou procurando especificamente direcionar o índice, assim como o primeiro exemplo - se for possível."

Não, não é possível.

O mais próximo que você pode obter é obter um Array das chaves do objeto e usar isso:

var keys = Object.keys( obj );

... mas não há garantia de que as chaves serão devolvidas na ordem que você definiu. Então, pode acabar parecendo:

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

A única maneira que consigo pensar em fazer isso é criando um método que forneça a propriedade using 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/

Seria possível estender isso a todos os objetos usando Object.prototype; mas isso geralmente não é recomendado.

Em vez disso, use um auxiliar de função:

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

Você pode usar o Object.values()método se não quiser usar o Object.keys().

Ao contrário do Object.keys()método que retorna uma matriz das propriedades enumeráveis ​​de um determinado objeto, por exemplo:

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

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

Imprime a seguinte matriz:

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

O Object.values()método retorna uma matriz da propriedade enumerável de um determinado objeto values.

Portanto, se você tiver o mesmo objeto, mas usar valores em vez disso,

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

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

Você obteria a seguinte matriz:

[ 'somestring', 42, false ]

Portanto, se você quiser acessar o object1.b, mas usando um índice, poderá usar:

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

Você pode ler mais sobre este método aqui .

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:

"Estou procurando especificamente direcionar o índice, assim como o primeiro exemplo - se for possível."

Na verdade, o 'índice' é a chave. Se você deseja armazenar a posição de uma chave, você precisa criar um objeto personalizado para lidar com isso.

por jquery você pode fazer isso:

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

Pegue a matriz de chaves, inverta-a e execute seu loop

  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
  }

você pode criar uma matriz que preenche os campos do seu objeto e usar um índice na matriz e acessar as propriedades do objeto por meio desse

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

this.myObject[this.propertiesName[0]]

Eu fui em frente e fiz uma função para você:

 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 você não tiver certeza de que Object.keys () retornará as chaves na ordem certa, você pode tentar esta lógica

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