Como acessar a primeira propriedade de um objeto Javascript?

Existe uma maneira elegante de acessar a primeira propriedade de um objeto ...

1. onde você não sabe o nome de suas propriedades
2. sem usar um loop como for .. inou jQuery$.each

Por exemplo, preciso acessar o foo1objeto sem saber o nome de foo1:

var example = {
    foo1: { /* stuff1 */},
    foo2: { /* stuff2 */},
    foo3: { /* stuff3 */}
};

var obj = { first: 'someVal' };
obj[Object.keys(obj)[0]]; //returns 'someVal'

Usando isso, você também pode acessar outras propriedades por índices. Esteja ciente! Object.keysa ordem de devolução não é garantida de acordo com o ECMAScript, mas de maneira não oficial pelas principais implementações de navegadores, leia https://stackoverflow.com/a/23202095 para obter detalhes sobre isso.

Experimente o for … inloop e quebre após a primeira iteração:

for (var prop in object) {
    // object[prop]
    break;
}

Você também pode fazer Object.values(example)[0].

Use Object.keyspara obter uma matriz das propriedades em um objeto. Exemplo:

var example = {
    foo1: { /* stuff1 */},
    foo2: { /* stuff2 */},
    foo3: { /* stuff3 */}
};

var keys = Object.keys(example); // => ["foo1", "foo2", "foo3"] (Note: the order here is not reliable)

Documentação e correção entre navegadores fornecidos aqui . Um exemplo de seu uso pode ser encontrado em outra das minhas respostas aqui .

Edit : para maior clareza, eu só quero repetir o que foi afirmado corretamente em outras respostas: a ordem das chaves nos objetos javascript é indefinida.

Uma versão de uma regra:

var val = example[function() { for (var k in example) return k }()];

Não há uma propriedade "primeira". As chaves do objeto não são ordenadas.

Se você fizer um loop sobre eles (var foo in bar), obterá-os em alguma ordem, mas poderá mudar no futuro (especialmente se você adicionar ou remover outras chaves).

Solução com a biblioteca lodash :

_.find(example) // => {name: "foo1"}

mas não há garantia da ordem de armazenamento interno das propriedades do objeto, pois depende da implementação da VM em javascript.

Não. Um literal de objeto, conforme definido pelo MDC, é:

uma lista de zero ou mais pares de nomes de propriedades e valores associados de um objeto, entre chaves ({}).

Portanto, um literal de objeto não é uma matriz e você pode acessar apenas as propriedades usando o nome explícito ou um forloop usando a inpalavra - chave.

A resposta superior pode gerar toda a matriz e capturar da lista. Aqui está outro atalho eficaz

var obj = { first: 'someVal' };
Object.entries(obj)[0][1] // someVal

Isso já foi abordado aqui antes.

O conceito de primeiro não se aplica às propriedades do objeto, e a ordem de um loop for ... in não é garantida pelas especificações, no entanto, na prática, é confiável FIFO, exceto criticamente para o chrome ( relatório de bug ). Tome suas decisões de acordo.

Eu não recomendo que você use Object.keys, pois não é suportado nas versões antigas do IE. Mas se você realmente precisar disso, poderá usar o código acima para garantir a compatibilidade com versões anteriores:

if (!Object.keys) {
Object.keys = (function () {
var hasOwnProperty = Object.prototype.hasOwnProperty,
    hasDontEnumBug = !({toString: null}).propertyIsEnumerable('toString'),
    dontEnums = [
      'toString',
      'toLocaleString',
      'valueOf',
      'hasOwnProperty',
      'isPrototypeOf',
      'propertyIsEnumerable',
      'constructor'
    ],
    dontEnumsLength = dontEnums.length;

return function (obj) {
  if (typeof obj !== 'object' && typeof obj !== 'function' || obj === null) throw new TypeError('Object.keys called on non-object');

  var result = [];

  for (var prop in obj) {
    if (hasOwnProperty.call(obj, prop)) result.push(prop);
  }

  if (hasDontEnumBug) {
    for (var i=0; i < dontEnumsLength; i++) {
      if (hasOwnProperty.call(obj, dontEnums[i])) result.push(dontEnums[i]);
    }
  }
  return result;
}})()};

Recurso Firefox (Gecko) 4 (2.0) Chrome 5 Internet Explorer 9 Opera 12 Safari 5

Mais informações: https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Object/keys

Mas se você precisar apenas do primeiro, poderemos organizar uma solução mais curta, como:

var data = {"key1":"123","key2":"456"};
var first = {};
for(key in data){
    if(data.hasOwnProperty(key)){
        first.key = key;
        first.content =  data[key];
        break;
    }
}
console.log(first); // {key:"key",content:"123"}

Para obter o primeiro nome da chave no objeto, você pode usar:

var obj = { first: 'someVal' };
Object.keys(obj)[0]; //returns 'first'

Retorna uma string, para que você não possa acessar objetos aninhados, se houver, como:

var obj = { first: { someVal : { id : 1} }; Aqui com essa solução, você não pode acessar o id.

A melhor solução se você deseja obter o objeto real está usando o lodash, como:

obj[_.first(_.keys(obj))].id

Para retornar o valor da primeira chave (se você não souber exatamente o nome da primeira chave):

var obj = { first: 'someVal' };
obj[Object.keys(obj)[0]]; //returns 'someVal'

se você souber o nome da chave, use:

obj.first

ou

obj['first']

Se você precisar acessar "a primeira propriedade de um objeto", isso pode significar que há algo errado com sua lógica. A ordem das propriedades de um objeto não deve importar.

Use uma matriz em vez de um objeto (colchetes).

var example = [ {/* stuff1 */}, { /* stuff2 */}, { /* stuff3 */}];
var fist = example[0];

Observe que você perde os identificadores 'foo'. Mas você pode adicionar uma propriedade name aos objetos contidos:

var example = [ 
  {name: 'foo1', /* stuff1 */},
  {name: 'foo2', /* stuff2 */},
  {name: 'foo3', /* stuff3 */}
];
var whatWasFirst = example[0].name;

Alguma razão para não fazer isso?

> example.map(x => x.name);

(3) ["foo1", "foo2", "foo3"]

Você pode usar o Object.prototype.keysque retorna todas as chaves de um objeto na mesma ordem. Portanto, se você deseja o primeiro objeto, obtenha esse array e use o primeiro elemento como chave desejada.

const o = { "key1": "value1", "key2": "value2"};
const idx = 0; // add the index for which you want value
var key = Object.keys(o)[idx];
value = o[key]
console.log(key,value); // key2 value2

também podemos fazer com esse método.

var example = {
  foo1: { /* stuff1 */},
  foo2: { /* stuff2 */},
  foo3: { /* stuff3 */}
}; 
Object.entries(example)[0][1];

Aqui está uma maneira mais limpa de obter a primeira chave:

var example = {
    foo1: { /* stuff1 */},
    foo2: { /* stuff2 */},
    foo3: { /* stuff3 */}
};

var object2 = {
    needThis: 'This is a value of the property',
    foo2: { /* stuff2 */},
    foo3: { /* stuff3 */}
};

let [first] = Object.keys(example)
let [firstProp] = Object.keys(object2)

console.log(first)
//Prop : needThis, Value: This is a value of the property
console.log(`Prop : ${firstProp}, Value: ${object2[firstProp]}`)