¿Cómo puedo transformar un gran object a array con lodash?

var obj = {
  22: {name:"John", id:22, friends:[5,31,55], works:{books:[], films:[],}
  12: {name:"Ivan", id:12, friends:[2,44,12], works:{books:[], films:[],}
}

//transform to 
var arr = [{name:"John", id:22...},{name:"Ivan", id:12...}]
  • Creo que debe referirse a los docs al menos una vez.
InformationsquelleAutor siavolt | 2014-07-10

10 Comentarios

  1. 224

    Que usted puede hacer

    var arr = _.values(obj);

    Para la documentación de ver aquí.

    • Qué pasa si quería conservar la clave como una propiedad? (en este ejemplo, si el id de propiedad no existen y de que quería crear se basa en la clave de cada objeto.
    • Se podría hacer algo como esto: var arr = _.values(_.mapKeys(obj, function(value, key) { value.id = key; return value; }));
    • No estoy seguro de lo que hice mal, pero que muestra sólo devuelve 1 fila para mí. 🙁 Así que lo que hice es empuje manualmente el return valor a una matriz como esta: const divisionsList = []; _.mapKeys(divisions, (value, key) => { divisionsList[key] = value; }); agradecería cualquier comentario o sugerencia para mejorar este enfoque.
    • Creo que voy a necesitar para el uso mapValues por ejemplo, en lugar const toArrayWithKey = (obj, keyAs) => _.values(_.mapValues(obj, (value, key) => { value[keyAs] = key; return value; }));
    • Sí, realmente me di cuenta de esto, simplemente se olvidó de actualizar. Gracias por eso.
  2. 36
    _.toArray(obj);

    Salidas como:

    [
      {
        "name": "Ivan",
        "id": 12,
        "friends": [
          2,
          44,
          12
        ],
        "works": {
          "books": [],
          "films": []
        }
      },
      {
        "name": "John",
        "id": 22,
        "friends": [
          5,
          31,
          55
        ],
        "works": {
          "books": [],
          "films": []
        }
      }
    ]"
    • lodash.com/docs#toArray
    • _.toArray() Funciona bien @jivings
    • para obtener sólo los valores es una buena opción, pero en toArray no hay manera de preservar las llaves, si es necesario.
  3. 21

    Una moderna solución nativa si alguien está interesado:

    const arr = Object.keys(obj).map(key => ({ key, value: obj[key] }));

    gracias por la mejora de @KoushikChatterjee

    • ¿por qué no Object.keys(obj).map(key=>({key,value: obj[key]}))
    • Me gusta que ni siquiera el usuario lodash, bien hecho, señor!
    • Ahora ha cambiado su respuesta completa y se la llevó de mi comentario, incluso sin una mención (que ha editado la que fuera). Bien hecho 👏 😁😁
    • añadido nuevo
    • mejor respuesta ya que la clave se conserva también
    • Sería más útil? const arr = Object.keys(obj).map(id => ({ id, ...obj[id] })); esto traería sobre el objeto en los datos devueltos no? (el uso de ‘id’ ya que el original asker quería para almacenar su clave como el id prop)
    • ¿qué pasa si el objeto contiene la id propiedad? también ¿cómo se puede separar el único valor? usted necesita para volver a leer y dele la id propiedad

  4. 19

    Para mí, esto funcionó:

    _.map(_.toPairs(data), d => _.fromPairs([d]));

    Se convierte

    {"a":"b", "c":"d", "e":"f"} 

    en

    [{"a":"b"}, {"c":"d"}, {"e":"f"}]
    • puede por favor explicar esto un poco mejor….!
    • Yo necesitaba para transformar un objeto en una Matriz, de manera que cada clave/valor del objeto original sería un {clave:valor}-objeto en la matriz. _.toPairs(datos) toma el objeto {«a»:»b», «c»:»d», «e»:»f»} y la devuelve como un array de arrays como [[«a»,»b»], [«c»:»d»], [«e»:»f»]]. _.fromPairs hace lo contrario, se toma una Matriz con 2 elementos: [«a»,»b»] y la devuelve como un objeto: {«a»:»b»}. El uso de _.mapa I iterado la matriz de si las matrices creadas por _.toPairs para transformarla en una matriz de objetos con la ayuda de _.fromPairs.
    • Me alegro de haber desplazado hacia abajo para ver esto. La solución que funcionó para mí! Gracias!
    • Usted no necesita aplicar un mapa de la matriz (de la matriz), usted puede aplicarlo directamente en el objeto de entrada y de retorno de cada valor de la clave par _.map(data, (v,k)=>({[k]: v})) ver mi respuesta para el detalle. _.toPairs y _fromPairs es adicional e innecesario aquí.
    • Esto no es lo que la pregunta es para. porque es un poco dificil de utilizar el resultado como cada entrada contiene una clave (que no y saber) y, de nuevo, usted necesita ir a través de algunos de lógica (por ejemplo, el Objeto.teclas u Objeto.los valores) para cada entrada independiente para obtener el valor de cada uno, si el juguete que desea conservar las llaves, a continuación, puede crear una matriz de objetos que stuctrured como [{key: 'someKey', val: 'The value'}, {....},...]
  5. 11

    Si quieres la clave (id, en este caso) para ser conservado como una propiedad de cada elemento de matriz se puede hacer

    const arr = _(obj) //wrap object so that you can chain lodash methods
                .mapValues((value, id)=>_.merge({}, value, {id})) //attach id to object
                .values() //get the values of the result
                .value() //unwrap array of objects
  6. 7

    2017 actualización: Objeto.los valores de, lodash los valores de y toArray hacerlo. Y para preservar las teclas de mapa y la propagación del operador jugar bonito:

    JS:

    //import { toArray, map } from 'lodash'
    const map = _.map
    
    const input = {
      key: {
        value: 'value'
      }
    }
    
    const output = map(input, (value, key) => ({
      key,
      ...value
    }))
    
    console.log(output)
    //>> [{key: 'key', value: 'value'}])

    HTML:

    <script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.4/lodash.js"></script>

  7. 7

    Objeto la transformación de la matriz con llanura de JavaScript(ECMAScript-2016) Objeto.valores:

    JS:

    var obj = {
        22: {name:"John", id:22, friends:[5,31,55], works:{books:[], films:[]}},
        12: {name:"Ivan", id:12, friends:[2,44,12], works:{books:[], films:[]}}
    }
    
    var values = Object.values(obj)
    
    console.log(values);

    Si usted también quiere mantener las teclas de uso Objeto.entradas y Array#mapa como este:

    JS:

    var obj = {
        22: {name:"John", id:22, friends:[5,31,55], works:{books:[], films:[]}},
        12: {name:"Ivan", id:12, friends:[2,44,12], works:{books:[], films:[]}}
    }
    
    var values = Object.entries(obj).map(([k, v]) => ({[k]: v}))
    
    console.log(values);

  8. 7

    Hay muy pocas maneras de obtener el resultado que usted está después. Permite romper en categorías:

    ES6 Valores sólo:

    Método principal para esto es Objeto.los valores de. Pero el uso de Objeto.claves y Array.mapa usted puede también conseguir el resultado esperado:

    Object.values(obj)
    Object.keys(obj).map(k => obj[k])

    JS:

    var obj = {
      A: {
        name: "John"
      },
      B: {
        name: "Ivan"
      }
    }
    
    console.log('Object.values:', Object.values(obj))
    console.log('Object.keys:', Object.keys(obj).map(k => obj[k]))

    ES6 Clave & Valor:

    El uso de mapa y ES6 dynamic/calculada propiedades y desestructuración puede conservar la clave y devuelve un objeto del mapa.

    Object.keys(obj).map(k => ({[k]: obj[k]}))
    Object.entries(obj).map(([k,v]) => ({[k]:v}))

    JS:

    var obj = {
      A: {
        name: "John"
      },
      B: {
        name: "Ivan"
      }
    }
    
    console.log('Object.keys:', Object.keys(obj).map(k => ({
      [k]: obj[k]
    })))
    console.log('Object.entries:', Object.entries(obj).map(([k, v]) => ({
      [k]: v
    })))

    Lodash Valores sólo:

    El método diseñado para esto es _.valores sin embargo, hay «atajos» como _.mapa y el método de utilidad _.toArray que también podría devolver un array que contiene sólo los valores desde el objeto. Usted también podría _.map aunque la _.keys y obtener los valores de los objetos mediante el uso de la obj[key] notación.

    Nota: _.map cuando se pasa un objeto de utilizar sus mapa controlador que es básicamente forEach en las propiedades del objeto.

    _.values(obj)
    _.map(obj)
    _.toArray(obj)
    _.map(_.keys(obj), k => obj[k])

    JS:

    var obj = {
      A: {
        name: "John"
      },
      B: {
        name: "Ivan"
      }
    }
    
    console.log('values:', _.values(obj))
    console.log('map:', _.map(obj))
    console.log('toArray:', _.toArray(obj))
    console.log('keys:', _.map(_.keys(obj), k => obj[k]))

    HTML:

    <script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.10/lodash.min.js"></script>

    Lodash Clave & Valor:

    //Outputs an array with [[KEY, VALUE]]
    _.entries(obj)
    _.toPairs(obj)
    
    //Outputs array with objects containing the keys and values
    _.map(_.entries(obj), ([k,v]) => ({[k]:v}))
    _.map(_.keys(obj), k => ({[k]: obj[k]}))
    _.transform(obj, (r,c,k) => r.push({[k]:c}), [])
    _.reduce(obj, (r,c,k) => (r.push({[k]:c}), r), [])

    JS:

    var obj = {
      A: {
        name: "John"
      },
      B: {
        name: "Ivan"
      }
    }
    
    //Outputs an array with [KEY, VALUE]
    console.log('entries:', _.entries(obj))
    console.log('toPairs:', _.toPairs(obj))
    
    //Outputs array with objects containing the keys and values
    console.log('entries:', _.map(_.entries(obj), ([k, v]) => ({
      [k]: v
    })))
    console.log('keys:', _.map(_.keys(obj), k => ({
      [k]: obj[k]
    })))
    console.log('transform:', _.transform(obj, (r, c, k) => r.push({
      [k]: c
    }), []))
    console.log('reduce:', _.reduce(obj, (r, c, k) => (r.push({
      [k]: c
    }), r), []))

    HTML:

    <script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.10/lodash.min.js"></script>

    Tenga en cuenta que en los ejemplos anteriores ES6 se utiliza (flecha funciones y propiedades dinámicas).
    Usted puede utilizar lodash _.fromPairs y otros métodos para componer un objeto si ES6 es un problema.

  9. 5

    var arr = _.map(obj)

    Puede utilizar _.map función (de ambos lodash y underscore) con object así, que internamente se manejar ese caso, iterar sobre cada valor y la clave con su iteratee, y, finalmente, devolver una matriz. De hecho, se puede utilizar sin ningún tipo de iteratee (sólo _.map(obj)) si lo que desea es una matriz de valores. La parte buena es que, si usted necesita cualquier transformación en el medio, se puede hacer en un ir.

    Ejemplo:

    JS:

    var obj = {
        key1: {id: 1, name: 'A'},
        key2: {id: 2, name: 'B'},
        key3: {id: 3, name: 'C'}
    };
    
    var array1 = _.map(obj, v=>v);
    console.log('Array 1: ', array1);
    
    /*Actually you don't need the callback v=>v if you
    are not transforming anything in between, v=>v is default*/
    
    //SO simply you can use
    var array2 = _.map(obj);
    console.log('Array 2: ', array2);

    HTML:

    <script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.4/lodash.js"></script>

    Sin embargo, si usted desea transformar su objeto puede hacerlo, incluso si usted necesita para preservar la clave, usted puede hacer eso ( _.map(obj, (v, k) => {...}) con el argumento adicional en map y, a continuación, utilizarlo como quiera.

    Sin embargo, hay otros Vainilla JS solución a este (como todos los lodash solución no debería puro JS versión de la misma) como:

    • Object.keys y, a continuación, map a los valores
    • Object.values (en ES-2017)
    • Object.entries y, a continuación, map cada uno de los pares de clave/valor (en ES-2017)
    • for...in bucle y el uso de cada una de las claves para feting valores

    Y mucho más. Pero ya que esta pregunta es para lodash (y suponiendo que alguien ya lo tienen), entonces usted no tendrá que pensar mucho acerca de la versión, el apoyo de los métodos y el manejo de errores si estos no se encuentran.

    Hay otros lodash soluciones como _.values (más legible para determinados perpose), o la obtención de los pares y, a continuación, mapa y así sucesivamente. pero en el caso de que el código de la necesidad de flexibilidad que se puede actualizar en el futuro a medida que la necesidad de preservar keys o la transformación de los valores de un bit, entonces la mejor solución es utilizar una sola _.map como addresed en esta respuesta. Que bt no es tan difícil como por la legibilidad también.

    • Bonito, muy simple y concisa.
  10. 3

    Si quieres un poco de asignación personalizada (como la de la Matriz original.el prototipo.el mapa) de Objeto en una Matriz, sólo se puede utilizar _.forEach:

    let myObject = {
      key1: "value1",
      key2: "value2",
      //...
    };
    
    let myNewArray = [];
    
    _.forEach(myObject, (value, key) => {
      myNewArray.push({
        someNewKey: key,
        someNewValue: value.toUpperCase() //just an example of new value based on original value
      });
    });
    
    //myNewArray => [{ someNewKey: key1, someNewValue: 'VALUE1' }, ... ];

    Ver lodash de doc _.forEach https://lodash.com/docs/#forEach

Dejar respuesta

Please enter your comment!
Please enter your name here