JavaScript récupérant un objet / json par index

Vous pouvez utiliser Object.values

var x = {"email":["This Position"]}
var value = Object.values(x)[0][0]

Utilisez Object.values ​​ comme ceci:

var x = {"email":["This Position"]};
const [[res]] = Object.values(x);
console.log(res);

Ceci est possible dans les implémentations où les objets JavaScript sont classés par séquence d'insertion. Cette réponse , ainsi que les autres réponses dans le fil de discussion, offre un bon aperçu du moment où vous pouvez vous y fier et sous quelles restrictions. Le reste de cette réponse suppose que l'ordre est garanti par l'implémentation ES.

La solution la plus directe est d'utiliser Object.values ​​(obj) [0] , Object.keys (obj) [0] ou Object.entries (obj) [0] . Cependant, ces méthodes visitent chaque entrée de l'objet, ce qui entraîne une complexité en temps O (n), donc ces approches ne sont utiles que pour des cas d'utilisation simples qui ne sont pas critiques pour les performances. div class = "snippet" data-lang = "js" data-hide = "false" data-console = "true" data-babel = "false">

// use a generator function for maximum flexibility

function *iterEntries(obj) {
  for (const k in obj) yield [k, obj[k]];
}

const firstEntries = (obj, n=1) => {
  const gen = iterEntries(obj);
  return Array(n).fill().map(_ => gen.next().value);
};

/* warning: linear search */
const entryAtIndex = (obj, i) => {
  const gen = iterEntries(obj);
  
  while (i--) gen.next();
  
  return gen.next().value;
};

const obj = Object.fromEntries(
  Array(26).fill().map((_, i) => [String.fromCharCode(i + 65), i])
);

console.log(iterEntries(obj).next().value);
console.log(firstEntries(obj, 4));
console.log(entryAtIndex(obj, 4));

Le plus rapide consiste à parcourir les clés avec dans et à renvoyer la première. Cela nécessite un peu plus de code mais offre une amélioration considérable de la complexité pour les objets volumineux.

// use a loop and return after the first element, O(1):

const getFirstVal = obj => {
  for (const k in obj) return obj[k];
};

const getFirstKey = obj => {
  for (const k in obj) return k;
};

const getFirstEntry = obj => {
  for (const k in obj) return [k, obj[k]];
};

const obj = {
  foobar: ["This position"],
  foobaz: ["That position"]
};

console.log(getFirstVal(obj));
console.log(getFirstKey(obj));
console.log(getFirstEntry(obj));

Une solution générale au problème des "premières n entrées" est de créer une version génératrice de Object.entries . Vous pouvez utiliser le générateur pour parcourir les entrées de l'objet, en allant uniquement aussi loin que vous en avez besoin et selon vos besoins.

L'inconvénient est qu'il y a un peu de gestion du générateur pour l'appelant, mais cela peut être abstrait avec une fonction. Utilisez cette option lorsque vous prévoyez que vous pourriez avoir besoin de plus que la première entrée du code critique pour les performances.

const obj = {
  foobar: ["This position"],
  foobaz: ["That position"]
};

// succinct but linear:

console.log(Object.keys(obj)[0]);
console.log(Object.values(obj)[0]);
console.log(Object.entries(obj)[0]);

// since you want the first array element of the first value, use:
console.log(Object.values(obj)[0][0]);

Vous pouvez créer des versions spécifiques aux valeurs ou aux clés selon vos besoins. Comme indiqué, cette technique est également efficace pour "indexer" dans la n -ème clé d'un objet ordonné. Cependant, si vous constatez que vous faites cela fréquemment, envisagez d'utiliser un tableau au lieu (ou à côté) d'un objet qui est la structure de données correcte pour un accès aléatoire aux index.