web-dev-qa-db-fra.com

Meilleure façon d’aplatir un objet JS (clés et valeurs) en un seul tableau de profondeur

J'ai écrit cette petite fonction pour obtenir toutes les clés et les valeurs d'un objet et les stocker dans un tableau. L'objet peut contenir des tableaux en tant que valeurs ...

Object { 0: [1,2,3,4] } à [0,1,2,3,4] convertir tous les éléments en entiers

Je me demande s'il existe un moyen plus rapide/plus propre de le faire:

function flattenObject(obj) {
    // Returns array with all keys and values of an object
    var array = [];
    $.each(obj, function (key, value) {
        array.Push(key);
        if ($.isArray(value)) {
            $.each(value, function (index, element) {
                array.Push(element);
            });
        }
        else {
            array.Push(value);
        }
    });

    return array
}
javascriptarraysobject
4
ddomingo

Vous pouvez simplement concaténer toutes les clés et toutes les valeurs. (Cela ne résout pas le type transtypage en nombre pour les clés.)

var object =  { 0: [1, 2, 3, 4] },
    result = Object.keys(object).reduce(function (r, k) {
        return r.concat(k, object[k]);
    }, []);
    
console.log(result);

9
Nina Scholz

Je voulais aplatir mon objet profond à un niveau de profondeur. Aucune des solutions ci-dessus n'a fonctionné pour moi.

Mon entrée: 

{
    "user": {
        "key_value_map": {
            "CreatedDate": "123424",
            "Department": {
                "Name": "XYZ"
            }
        }
    }
}

Production attendue: 

{
    "user.key_value_map.CreatedDate": "123424",
    "user.key_value_map.Department.Name": "XYZ"
}

Code qui a fonctionné pour moi: 

function flattenObject(ob) {
    var toReturn = {};

    for (var i in ob) {
        if (!ob.hasOwnProperty(i)) continue;

        if ((typeof ob[i]) == 'object' && ob[i] !== null) {
            var flatObject = flattenObject(ob[i]);
            for (var x in flatObject) {
                if (!flatObject.hasOwnProperty(x)) continue;

                toReturn[i + '.' + x] = flatObject[x];
            }
        } else {
            toReturn[i] = ob[i];
        }
    }
    return toReturn;
}
7
Muthukrishnan

Générez un tableau de tuples (tableaux à deux éléments) de clés et de valeurs (qui peuvent être eux-mêmes des tableaux), puis aplatissez-le à fond.

function flattenObject(obj) { 
      return flatten(Object.keys(obj).map(k => [toNumber(k), obj[k]]));
}

// Substitute your own favorite flattening algorithm.
const flatten = a => Array.isArray(a) ? [].concat(...a.map(flatten)) : a;

// Convert to number, if you can.
const toNumber = n => isNaN(+n) ? n : +n;

console.log(flattenObject({a: [1, 2], b: 3, 0: [1, 2, 3, 4, 5]}));

2
user663031

Vous pouvez ignorer la boucle interne si vous devez transférer le contenu d'un tableau vers un autre. Voir si cela aide -

function flattenObject(obj) {
// Returns array with all keys and values of an object
var array = [];
$.each(obj, function (key, value) {
    array.Push(key);
    if ($.isArray(value)) {
        Array.prototype.Push.apply(array, value);
    }
    else {
        array.Push(value);
    }
});

return array;
}
var obj = {"key1" : [1,3,3],"key2" : "val", "key3":23};
var output = flattenObject(obj);
console.log(output);

Lien de violon - https://jsfiddle.net/0wu5z79a/1/

EDIT: Cette solution n’est valable que pour votre scénario dans lequel vous savez que l’imbrication n’est jusqu’à un niveau, sinon vous avez besoin d’une certaine récursion pour les objets intérieurs profonds.

2
RahulB

J'avais besoin de quelque chose de vraiment simple et voici un one-liner que j'ai créé:

function flatten(obj){
  return Object.values(obj).flat()
}


const flatten=(obj)=>Object.values(obj).flat()

const=nt x={x:[1,2,3],y:[4,5,6,7]}

console.log(flatten(x))

0
husayt