Come accedere alla prima proprietà di un oggetto Javascript?

Esiste un modo elegante per accedere alla prima proprietà di un oggetto ...

1. dove non conosci il nome delle tue proprietà
2. senza usare un ciclo come for .. ino jQuery$.each

Ad esempio, devo accedere foo1all'oggetto senza conoscere il nome di foo1:

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

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

Usando questo puoi accedere anche ad altre proprietà tramite indici. Attenzione però! Object.keysl'ordine di reso non è garantito come da ECMAScript, ma ufficiosamente è implementato da tutte le principali implementazioni dei browser, per favore leggi https://stackoverflow.com/a/23202095 per dettagli su questo.

Prova il for … inciclo e interrompi dopo la prima iterazione:

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

Puoi anche fare Object.values(example)[0].

Utilizzare Object.keysper ottenere una matrice delle proprietà su un oggetto. Esempio:

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

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

Documentazione e shim cross-browser forniti qui . Un esempio del suo utilizzo può essere trovato in un'altra delle mie risposte qui .

Modifica : per chiarezza, voglio solo fare eco a ciò che è stato correttamente affermato in altre risposte: l'ordine delle chiavi negli oggetti javascript non è definito.

Una versione a una regola:

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

Non esiste una "prima" proprietà. I tasti oggetto non sono ordinati.

Se li attraversi con un ciclo, li (var foo in bar)otterrai in un certo ordine, ma potrebbe cambiare in futuro (soprattutto se aggiungi o rimuovi altre chiavi).

Soluzione con la libreria lodash :

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

ma non esiste alcuna garanzia dell'ordine di archiviazione interno delle proprietà dell'oggetto poiché dipende dall'implementazione della VM javascript.

No. Un oggetto letterale, come definito da MDC è:

un elenco di zero o più coppie di nomi di proprietà e valori associati di un oggetto, racchiuso tra parentesi graffe ({}).

Pertanto un oggetto letterale non è un array e puoi accedere alle proprietà solo usando il loro nome esplicito o un forciclo usando la inparola chiave.

La risposta migliore potrebbe generare l'intero array e quindi catturare dall'elenco. Ecco un'altra scorciatoia efficace

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

Questo è stato trattato qui prima.

Il concetto di first non si applica alle proprietà degli oggetti, e l'ordine di un ciclo for ... in non è garantito dalle specifiche, tuttavia in pratica è affidabile FIFO tranne che criticamente per chrome ( bug report ). Prendi le tue decisioni di conseguenza.

Non ti consiglio di usare Object.keys poiché non è supportato nelle vecchie versioni di IE. Ma se ne hai davvero bisogno, potresti usare il codice sopra per garantire la retrocompatibilità:

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;
}})()};

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

Ulteriori informazioni: https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Object/keys

Ma se hai solo bisogno del primo, potremmo organizzare una soluzione più breve come:

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"}

Per ottenere il primo nome chiave nell'oggetto è possibile utilizzare:

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

Restituisce una stringa, quindi non è possibile accedere agli oggetti nidificati se presenti, come:

var obj = { first: { someVal : { id : 1} }; Qui con quella soluzione non è possibile accedere all'ID.

La soluzione migliore se vuoi ottenere l'oggetto reale è usare lodash come:

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

Per restituire il valore della prima chiave, (se non si conosce esattamente il nome della prima chiave):

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

se conosci il nome della chiave basta usare:

obj.first

o

obj['first']

Se devi accedere alla "prima proprietà di un oggetto", potrebbe significare che c'è qualcosa di sbagliato nella tua logica. L'ordine delle proprietà di un oggetto non dovrebbe avere importanza.

Utilizzare un array anziché un oggetto (parentesi quadre).

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

Nota che perdi gli identificatori "pieni". Ma potresti aggiungere una proprietà name agli oggetti contenuti:

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

Qualche motivo per non farlo?

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

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

È possibile utilizzare Object.prototype.keysquale restituisce tutte le chiavi di un oggetto nello stesso ordine. Quindi, se vuoi il primo oggetto, prendi quell'array e usa il primo elemento come chiave desiderata.

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

possiamo anche fare con questo approch.

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

Ecco un modo più pulito di ottenere la prima chiave:

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