Comment accéder à la première propriété d'un objet Javascript?

Existe-t-il un moyen élégant d'accéder à la première propriété d'un objet ...

1. où vous ne connaissez pas le nom de vos propriétés
2. sans utiliser une boucle comme for .. inou jQuery$.each

Par exemple, j'ai besoin d'accéder à un foo1objet sans connaître le nom de foo1:

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

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

En utilisant cela, vous pouvez également accéder à d'autres propriétés par des index. Soyez conscient tho! Object.keysl'ordre de retour n'est pas garanti selon ECMAScript, mais officieusement c'est par toutes les implémentations principales des navigateurs, veuillez lire https://stackoverflow.com/a/23202095 pour plus de détails à ce sujet.

Essayez la for … inboucle et coupez après la première itération:

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

Vous pouvez aussi le faire Object.values(example)[0].

Utilisez Object.keyspour obtenir un tableau des propriétés d'un objet. Exemple:

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

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

Documentation et module d'interface multi-navigateur fournis ici . Un exemple de son utilisation peut être trouvé dans une autre de mes réponses ici .

Edit : pour plus de clarté, je veux juste faire écho à ce qui a été correctement déclaré dans d'autres réponses: l'ordre des touches dans les objets javascript n'est pas défini.

Une version à une règle:

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

Il n'y a pas de "première" propriété. Les clés d'objet ne sont pas ordonnées.

Si vous les parcourez avec pour (var foo in bar)vous les obtiendrez dans un certain ordre, mais cela peut changer à l'avenir (surtout si vous ajoutez ou supprimez d'autres clés).

Solution avec la bibliothèque lodash :

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

mais il n'y a aucune garantie de l'ordre de stockage interne des propriétés de l'objet car cela dépend de l'implémentation de la machine virtuelle javascript.

Non. Un littéral objet, tel que défini par MDC, est:

une liste de zéro ou plusieurs paires de noms de propriété et des valeurs associées d'un objet, entre accolades ({}).

Par conséquent, un littéral d'objet n'est pas un tableau et vous ne pouvez accéder aux propriétés qu'en utilisant leur nom explicite ou une forboucle en utilisant le inmot clé.

La première réponse pourrait générer l'ensemble du tableau, puis capturer à partir de la liste. Voici un autre raccourci efficace

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

Cela a déjà été abordé ici.

Le concept de premier ne s'applique pas aux propriétés des objets, et l'ordre d'une boucle for ... in n'est pas garanti par les spécifications, mais dans la pratique, il est fiable FIFO sauf de manière critique pour chrome ( rapport de bogue ). Prenez vos décisions en conséquence.

Je ne vous recommande pas d'utiliser Object.keys car il n'est pas pris en charge dans les anciennes versions d'IE. Mais si vous en avez vraiment besoin, vous pouvez utiliser le code ci-dessus pour garantir la compatibilité arrière:

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

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

Plus d'informations: https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Object/keys

Mais si vous n'avez besoin que du premier, nous pourrions organiser une solution plus courte comme:

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

Pour obtenir le premier nom de clé dans l'objet, vous pouvez utiliser:

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

Renvoie une chaîne, vous ne pouvez donc pas accéder aux objets imbriqués s'il y en avait, comme:

var obj = { first: { someVal : { id : 1} }; Ici, avec cette solution, vous ne pouvez pas accéder à id.

La meilleure solution si vous souhaitez obtenir l'objet réel est d'utiliser lodash comme:

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

Pour renvoyer la valeur de la première clé (si vous ne connaissez pas exactement le premier nom de clé):

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

si vous connaissez le nom de la clé, utilisez simplement:

obj.first

ou

obj['first']

Si vous devez accéder à "la première propriété d'un objet", cela peut signifier qu'il y a un problème avec votre logique. L'ordre des propriétés d'un objet ne devrait pas avoir d'importance.

Utilisez un tableau au lieu d'un objet (crochets).

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

Notez que vous perdez les identifiants «foo». Mais vous pouvez ajouter une propriété de nom aux objets contenus:

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

Une raison de ne pas faire ça?

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

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

Vous pouvez utiliser Object.prototype.keysqui renvoie toutes les clés d'un objet dans le même ordre. Donc, si vous voulez le premier objet, obtenez simplement ce tableau et utilisez le premier élément comme clé souhaitée.

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

on peut aussi faire avec cette approche.

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

Voici une façon plus propre d'obtenir la première clé:

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