Comment convertir un objet {} en un tableau [] de paires clé-valeur en JavaScript

Je veux convertir un objet comme celui-ci:

{"1":5,"2":7,"3":0,"4":0,"5":0,"6":0,"7":0,"8":0,"9":0,"10":0,"11":0,"12":0}

dans un tableau de paires clé-valeur comme ceci:

[[1,5],[2,7],[3,0],[4,0]...].

Comment puis-je convertir un objet en un tableau de paires clé-valeur en JavaScript?

Vous pouvez utiliser Object.keys()et map()pour ce faire

var obj = {"1":5,"2":7,"3":0,"4":0,"5":0,"6":0,"7":0,"8":0,"9":0,"10":0,"11":0,"12":0}
var result = Object.keys(obj).map(function(key) {
  return [Number(key), obj[key]];
});

console.log(result);

La meilleure façon est de faire:

var obj ={"1":5,"2":7,"3":0,"4":0,"5":0,"6":0,"7":0,"8":0,"9":0,"10"‌​:0,"11":0,"12":0} 
Object.entries(obj);

L'appel entries, comme indiqué ici, renverra des [key, value]paires, comme l'a demandé le demandeur.

Alternativement, vous pouvez appeler Object.values(obj), qui ne renverra que des valeurs.

Object.entries()renvoie un tableau dont les éléments sont des tableaux correspondant aux [key, value]paires de propriétés énumérables trouvées directement sur object. L'ordre des propriétés est le même que celui donné en bouclant manuellement les valeurs des propriétés de l'objet.

^{- https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/entries#Description}

La Object.entriesfonction renvoie presque la sortie exacte que vous demandez, sauf que les clés sont des chaînes au lieu de chiffres.

const obj = {"1":5,"2":7,"3":0,"4":0,"5":0,"6":0,"7":0,"8":0,"9":0,"10":0,"11":0,"12":0};

console.log(Object.entries(obj));

Si vous avez besoin que les clés soient des nombres, vous pouvez mapper le résultat sur un nouveau tableau avec une fonction de rappel qui remplace la clé de chaque paire par un numéro forcé.

const obj = {"1":5,"2":7,"3":0,"4":0,"5":0,"6":0,"7":0,"8":0,"9":0,"10":0,"11":0,"12":0};

const toNumericPairs = input => {
    const entries = Object.entries(input);
    return entries.map(entry => Object.assign(entry, { 0: +entry[0] }));
}

console.log(toNumericPairs(obj));

J'utilise une fonction de flèche et Object.assignpour le rappel de carte dans l'exemple ci-dessus afin de pouvoir le conserver dans une instruction en tirant parti du fait que Object.assignrenvoie l'objet auquel est affecté, et la valeur de retour d'une seule fonction de flèche d'instruction est le résultat de l'instruction.

Cela équivaut à:

entry => {
    entry[0] = +entry[0];
    return entry;
}

Comme mentionné par @TravisClarke dans les commentaires, la fonction de carte pourrait être raccourcie à:

entry => [ +entry[0], entry[1] ]

Cependant, cela créerait un nouveau tableau pour chaque paire clé-valeur, au lieu de modifier le tableau existant en place, doublant ainsi la quantité de tableaux de paires clé-valeur créés. Bien que le tableau d'entrées d'origine soit toujours accessible, il et ses entrées ne seront pas récupérés.

Maintenant, même si l'utilisation de notre méthode sur place utilise toujours deux tableaux qui contiennent les paires clé-valeur (les tableaux d'entrée et de sortie), le nombre total de tableaux ne change que d'un. Les tableaux d'entrée et de sortie ne sont pas réellement remplis de tableaux, mais plutôt les références aux tableaux et ces références occupent une quantité négligeable d'espace en mémoire.

• La modification de chaque paire clé-valeur sur place entraîne une augmentation négligeable de la mémoire, mais nécessite la saisie de quelques caractères supplémentaires.
• La création d'un nouveau tableau pour chaque paire clé-valeur entraîne le doublement de la quantité de mémoire requise, mais nécessite de taper quelques caractères de moins.

Vous pouvez aller plus loin et éliminer complètement la croissance en modifiant le tableau d'entrées en place au lieu de le mapper à un nouveau tableau:

const obj = {"1":5,"2":7,"3":0,"4":0,"5":0,"6":0,"7":0,"8":0,"9":0,"10":0,"11":0,"12":0};

const toNumericPairs = input => {
  const entries = Object.entries(obj);
  entries.forEach(entry => entry[0] = +entry[0]);
  return entries;
}

console.log(toNumericPairs(obj));

Pour récapituler certaines de ces réponses dès 2018, où ES6 est la norme.

En commençant par l'objet:

let const={"1":9,"2":8,"3":7,"4":6,"5":5,"6":4,"7":3,"8":2,"9":1,"10":0,"12":5};

• Obtention aveugle des valeurs sur un tableau, ne vous souciez pas des clés:

const obj={"1":9,"2":8,"3":7,"4":6,"5":5,"6":4,"7":3,"8":2,"9":1,"10":0,"12":5};
console.log(Object.values(obj));
//[9,8,7,6,5,4,3,2,1,0,5]

• Obtention simple des paires sur un tableau:

const obj={"1":9,"2":8,"3":7,"4":6,"5":5,"6":4,"7":3,"8":2,"9":1,"10":0,"12":5};
console.log(Object.entries(obj));
//[["1",9],["2",8],["3",7],["4",6],["5",5],["6",4],["7",3],["8",2],["9",1],["10",0],["12",5]]

• Identique à la précédente, mais avec des touches numériques sur chaque paire:

const obj={"1":9,"2":8,"3":7,"4":6,"5":5,"6":4,"7":3,"8":2,"9":1,"10":0,"12":5};
console.log(Object.entries(obj).map(([k,v])=>[+k,v]));
//[[1,9],[2,8],[3,7],[4,6],[5,5],[6,4],[7,3],[8,2],[9,1],[10,0],[12,5]]

• Utiliser la propriété d'objet comme clé pour un nouveau tableau (pourrait créer des tableaux clairsemés):

const obj={"1":9,"2":8,"3":7,"4":6,"5":5,"6":4,"7":3,"8":2,"9":1,"10":0,"12":5};
console.log(Object.entries(obj).reduce((ini,[k,v])=>(ini[k]=v,ini),[]));
//[undefined,9,8,7,6,5,4,3,2,1,0,undefined,5]

Cette dernière méthode, elle pourrait également réorganiser l'ordre des tableaux en fonction de la valeur des clés. Parfois, cela pourrait être le comportement souhaité (parfois pas). Mais l'avantage est maintenant que les valeurs sont indexées sur le bon emplacement de tableau, essentiel et trivial pour faire des recherches dessus.

• Carte au lieu de tableau

Enfin (ne fait pas partie de la question d'origine, mais pour être complet), si vous avez besoin de rechercher facilement à l'aide de la clé ou de la valeur, mais que vous ne voulez pas de tableaux clairsemés, pas de doublons et pas de réorganisation sans avoir besoin de convertir en touches numériques ( même peut accéder à des clés très complexes), alors le tableau (ou l'objet) n'est pas ce dont vous avez besoin. Je recommanderai Mapplutôt:

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map

let r=new Map(Object.entries(obj));
r.get("4"); //6
r.has(8); //true

Encore une autre solution Object.entriesqui ne fonctionnera pas pour vous.

const obj = {
      '1': 29,
      '2': 42
    };
const arr = Array.from(Object.keys(obj), k=>[`${k}`, obj[k]]);
console.log(arr);

Dans Ecmascript 6,

var obj = {"1":5,"2":7,"3":0,"4":0,"5":0,"6":0,"7":0,"8":0,"9":0,"10":0,"11":0,"12":0};

var res = Object.entries(obj);

console.log(res);

violon

Utilisation Object.keyset Array#mapméthodes.

var obj = {
  "1": 5,
  "2": 7,
  "3": 0,
  "4": 0,
  "5": 0,
  "6": 0,
  "7": 0,
  "8": 0,
  "9": 0,
  "10": 0,
  "11": 0,
  "12": 0
};
// get all object property names
var res = Object.keys(obj)
  // iterate over them and generate the array
  .map(function(k) {
    // generate the array element 
    return [+k, obj[k]];
  });

console.log(res);

Utilisez Object.entriespour obtenir chaque élément de l'objet au key & valueformat, puis à maptravers eux comme ceci:

var obj = {"1":5,"2":7,"3":0,"4":0,"5":0,"6":0,"7":0,"8":0,"9":0,"10":0,"11":0,"12":0}

var res = Object.entries(obj).map(([k, v]) => ([Number(k), v]));

console.log(res);

Mais, si vous êtes certain que les touches seront dans un ordre progressif, vous pouvez utiliser Object.valueset Array#mapfaire quelque chose comme ceci:

var obj = {"1":5,"2":7,"3":0,"4":0,"5":0,"6":0,"7":0,"8":0,"9":0,"10":0,"11":0,"12":0}; 

                        // idx is the index, you can use any logic to increment it (starts from 0)
let result = Object.values(obj).map((e, idx) => ([++idx, e]));

console.log(result);

Si vous utilisez lodash, cela pourrait être aussi simple que cela:

var arr = _.values(obj);

Avec lodash, en plus de la réponse fournie ci-dessus, vous pouvez également avoir la clé dans le tableau de sortie.

Sans les clés d'objet dans le tableau de sortie

pour:

const array = _.values(obj);

Si obj est le suivant:

{ “art”: { id: 1,  title: “aaaa” }, “fiction”: { id: 22,  title: “7777”} }

Le tableau sera alors:

[ { id: 1, title: “aaaa” }, { id: 22, title: “7777” } ]

Avec les clés d'objet dans le tableau de sortie

Si vous écrivez à la place («genre» est une chaîne que vous choisissez):

const array= _.map(obj, (val, id) => {
    return { ...val, genre: key };
  });

Tu auras:

[ 
  { id: 1, title: “aaaa” , genre: “art”}, 
  { id: 22, title: “7777”, genre: “fiction” }
]

Je suggère cette solution la plus simple à utiliser Object.entries()

var obj = {"1":5,"2":7,"3":0,"4":0,"5":0,"6":0,"7":0,"8":0,"9":0,"10":0,"11":0,"12":0}
var result =Object.entries(obj)

console.log(result);

Vous pouvez utiliser Object.values([]), vous pourriez avoir besoin de ce polyfill si vous ne l'avez pas déjà:

const objectToValuesPolyfill = (object) => {
  return Object.keys(object).map(key => object[key]);
};
Object.values = Object.values || objectToValuesPolyfill;

https://stackoverflow.com/a/54822153/846348

Ensuite, vous pouvez simplement faire:

var object = {1: 'hello', 2: 'world'};
var array = Object.values(object);

N'oubliez pas que les tableaux en js ne peuvent utiliser que des touches numériques, donc si vous avez utilisé autre chose dans l'objet, ceux-ci deviendront `0,1,2 ... x ''

Il peut être utile de supprimer des doublons par exemple si vous avez une clé unique.

var obj = {};
object[uniqueKey] = '...';

Utiliser pour dans

var obj = { "10":5, "2":7, "3":0, "4":0, "5":0, "6":0, "7":0,
            "8":0, "9":0, "10":0, "11":0, "12":0 };

var objectToArray = function(obj) {
    var _arr = [];

    for (var key in obj) {
        _arr.push([key, obj[key]]);
    }
    return _arr;
}

console.log(objectToArray(obj));

Convertir récursivement un objet en tableau

function is_object(mixed_var) {
    if (mixed_var instanceof Array) {
        return false;
    } else {
        return (mixed_var !== null) && (typeof( mixed_var ) == 'object');
    }
}


function objectToArray(obj) {
    var array = [], tempObject;
    for (var key in obj) {

        tempObject = obj[key];

        if (is_object(obj[key])) {
            tempObject = objectToArray(obj[key]);
        }
        array[key] = tempObject;
    }
    return array;
}

Nous pouvons changer le nombre en type de chaîne pour la clé comme ci-dessous:

var obj = {"1":5,"2":7,"3":0,"4":0,"5":0,"6":0,"7":0,"8":0,"9":0,"10":0,"11":0,"12":0}
var result = Object.keys(obj).map(function(key) {
  return [String(key), obj[key]];
});
    
console.log(result);

Ceci est ma solution, j'ai le même problème et il semble que cette solution fonctionne pour moi.

yourObj = [].concat(yourObj);

Voici ma simple implémentation barebone:

let obj = {
  "1": 5,
  "2": 7,
  "3": 0,
  "4": 0,
  "5": 0,
  "6": 0,
  "7": 0,
  "8": 0,
  "9": 0,
  "10": 0,
  "11": 0,
  "12": 0
};    

const objectToArray = obj => {
      let sol = [];
      for (key in obj) {
        sol.push([key, obj[key]]);
      }
      return sol;
    };

objectToArray(obj)

Solution simple

"

var result = Object.keys(records).map(function (value) {
         return { [value]: records[value] };
});
console.log(result);

vous pouvez utiliser _.castArray (obj) .

exemple: _.castArray({ 'a': 1 }); // => [{ 'a': 1 }]