ordenar las propiedades del objeto y JSON.stringify

Mi aplicación tiene una gran variedad de objetos, que clasifico y guardo en el disco. Desafortunadamente, cuando los objetos de la matriz se manipulan y, a veces, se reemplazan, las propiedades de los objetos se enumeran en diferentes órdenes (¿su orden de creación?). Cuando hago JSON.stringify () en la matriz y la guardo, una diferencia muestra las propiedades que se enumeran en diferentes órdenes, lo cual es molesto cuando trato de fusionar los datos más con las diferencias y las herramientas de fusión.

Idealmente, me gustaría ordenar las propiedades de los objetos en orden alfabético antes de realizar la secuenciación, o como parte de la operación de secuenciación. Hay código para manipular los objetos de la matriz en muchos lugares, y sería difícil alterarlos para crear siempre propiedades en un orden explícito.

¡Cualquier sugerencia será bienvenida!

Un ejemplo condensado:

obj = {}; obj.name="X"; obj.os="linux";
JSON.stringify(obj);
obj = {}; obj.os="linux"; obj.name="X";
JSON.stringify(obj);

La salida de estas dos llamadas de stringify es diferente y se muestra en una diferencia de mis datos, pero mi aplicación no se preocupa por el orden de las propiedades. Los objetos se construyen de muchas formas y lugares.

El enfoque más simple, moderno y actualmente compatible con el navegador es simplemente este:

JSON.stringify(sortMyObj, Object.keys(sortMyObj).sort());

Sin embargo, este método elimina los objetos anidados a los que no se hace referencia y no se aplica a los objetos dentro de las matrices. También querrá aplanar el objeto de clasificación si desea algo como este resultado:

{"a":{"h":4,"z":3},"b":2,"c":1}

Puedes hacer eso con esto:

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

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

        if ((typeof ob[i]) == 'object') {
            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;
};

JSON.stringify(sortMyObj, Object.keys(flattenObject(sortMyObj)).sort());

Para hacerlo programáticamente con algo que puede modificar usted mismo, debe insertar los nombres de las propiedades del objeto en una matriz, luego ordenar la matriz alfabéticamente e iterar a través de esa matriz (que estará en el orden correcto) y seleccionar cada valor del objeto en ese orden. "hasOwnProperty" también está marcado, por lo que definitivamente solo tiene las propiedades propias del objeto. He aquí un ejemplo:

var obj = {"a":1,"b":2,"c":3};

function iterateObjectAlphabetically(obj, callback) {
    var arr = [],
        i;

    for (i in obj) {
        if (obj.hasOwnProperty(i)) {
            arr.push(i);
        }
    }

    arr.sort();

    for (i = 0; i < arr.length; i++) {
        var key = obj[arr[i]];
        //console.log( obj[arr[i]] ); //here is the sorted value
        //do what you want with the object property
        if (callback) {
            // callback returns arguments for value, key and original object
            callback(obj[arr[i]], arr[i], obj);
        }
    }
}

iterateObjectAlphabetically(obj, function(val, key, obj) {
    //do something here
});

Nuevamente, esto debería garantizar que se repita en orden alfabético.

Finalmente, yendo más allá de la manera más simple, esta biblioteca le permitirá de forma recursiva ordenar cualquier JSON que le pase: https://www.npmjs.com/package/json-stable-stringify

var stringify = require('json-stable-stringify');
var obj = { c: 8, b: [{z:6,y:5,x:4},7], a: 3 };
console.log(stringify(obj));

Salida

{"a":3,"b":[{"x":4,"y":5,"z":6},7],"c":8}

Creo que si tiene el control de la generación JSON (y parece que lo tiene), entonces, para sus propósitos, esta podría ser una buena solución: json-stable-stringify

Desde el sitio web del proyecto:

JSON.stringify () determinista con clasificación personalizada para obtener hashes deterministas a partir de resultados en cadena

Si el JSON producido es determinista, debería poder diferenciarlo / fusionarlo fácilmente.

Puede pasar una matriz ordenada de los nombres de propiedad como segundo argumento de JSON.stringify():

JSON.stringify(obj, Object.keys(obj).sort())

No entiendo por qué se necesita la complejidad de las mejores respuestas actuales para obtener todas las claves de forma recursiva. A menos que se necesite un rendimiento perfecto, me parece que podemos llamar JSON.stringify()dos veces, la primera para obtener todas las claves y la segunda para hacer realmente el trabajo. De esa manera, toda la complejidad de la recursividad es manejada por stringify, y sabemos que conoce sus cosas y cómo manejar cada tipo de objeto:

function JSONstringifyOrder( obj, space )
{
    var allKeys = [];
    JSON.stringify( obj, function( key, value ){ allKeys.push( key ); return value; } )
    allKeys.sort();
    return JSON.stringify( obj, allKeys, space );
}

Actualización 2018-7-24:

Esta versión clasifica objetos anidados y también admite matrices:

function sortObjByKey(value) {
  return (typeof value === 'object') ?
    (Array.isArray(value) ?
      value.map(sortObjByKey) :
      Object.keys(value).sort().reduce(
        (o, key) => {
          const v = value[key];
          o[key] = sortObjByKey(v);
          return o;
        }, {})
    ) :
    value;
}


function orderedJsonStringify(obj) {
  return JSON.stringify(sortObjByKey(obj));
}

Caso de prueba:

  describe('orderedJsonStringify', () => {
    it('make properties in order', () => {
      const obj = {
        name: 'foo',
        arr: [
          { x: 1, y: 2 },
          { y: 4, x: 3 },
        ],
        value: { y: 2, x: 1, },
      };
      expect(orderedJsonStringify(obj))
        .to.equal('{"arr":[{"x":1,"y":2},{"x":3,"y":4}],"name":"foo","value":{"x":1,"y":2}}');
    });

    it('support array', () => {
      const obj = [
        { x: 1, y: 2 },
        { y: 4, x: 3 },
      ];
      expect(orderedJsonStringify(obj))
        .to.equal('[{"x":1,"y":2},{"x":3,"y":4}]');
    });

  });

Respuesta obsoleta:

Una versión concisa en ES2016. Crédito a @codename, de https://stackoverflow.com/a/29622653/94148

function orderedJsonStringify(o) {
  return JSON.stringify(Object.keys(o).sort().reduce((r, k) => (r[k] = o[k], r), {}));
}

https://gist.github.com/davidfurlong/463a83a33b70a3b6618e97ec9679e490

const replacer = (key, value) =>
    value instanceof Object && !(value instanceof Array) ? 
        Object.keys(value)
        .sort()
        .reduce((sorted, key) => {
            sorted[key] = value[key];
            return sorted 
        }, {}) :
        value;

Esto es lo mismo que la respuesta de Satpal Singh

function stringifyJSON(obj){
    keys = [];
    if(obj){
        for(var key in obj){
            keys.push(key);
        }
    }
    keys.sort();
    var tObj = {};
    var key;
    for(var index in keys){
        key = keys[index];
        tObj[ key ] = obj[ key ];
    }
    return JSON.stringify(tObj);
}

obj1 = {}; obj1.os="linux"; obj1.name="X";
stringifyJSON(obj1); //returns "{"name":"X","os":"linux"}"

obj2 = {}; obj2.name="X"; obj2.os="linux";
stringifyJSON(obj2); //returns "{"name":"X","os":"linux"}"

Puede agregar una toJSONfunción personalizada a su objeto que puede usar para personalizar la salida. Dentro de la función, agregar propiedades actuales a un nuevo objeto en un orden específico debería preservar ese orden cuando se cadena.

Mira aquí:

https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/JSON/stringify

No hay un método incorporado para controlar los pedidos porque los datos JSON deben ser accedidos por claves.

Aquí hay un jsfiddle con un pequeño ejemplo:

http://jsfiddle.net/Eq2Yw/

Intente comentar la toJSONfunción: el orden de las propiedades se invierte. Tenga en cuenta que esto puede ser específico del navegador, es decir, que la especificación no admite oficialmente el pedido. Funciona en la versión actual de Firefox, pero si desea una solución 100% robusta, es posible que deba escribir su propia función de secuenciador.

Editar:

También vea esta pregunta de SO sobre la salida no determinista de stringify, especialmente los detalles de Daff sobre las diferencias del navegador:

¿Cómo verificar determinísticamente que un objeto JSON no ha sido modificado?

Una respuesta recursiva y simplificada:

function sortObject(obj) {
    if(typeof obj !== 'object')
        return obj
    var temp = {};
    var keys = [];
    for(var key in obj)
        keys.push(key);
    keys.sort();
    for(var index in keys)
        temp[keys[index]] = sortObject(obj[keys[index]]);       
    return temp;
}

var str = JSON.stringify(sortObject(obj), undefined, 4);

Puede ordenar el objeto por nombre de propiedad en EcmaScript 2015

function sortObjectByPropertyName(obj) {
    return Object.keys(obj).sort().reduce((c, d) => (c[d] = obj[d], c), {});
}

Tomé la respuesta de @Jason Parham e hice algunas mejoras

function sortObject(obj, arraySorter) {
    if(typeof obj !== 'object')
        return obj
    if (Array.isArray(obj)) {
        if (arraySorter) {
            obj.sort(arraySorter);
        }
        for (var i = 0; i < obj.length; i++) {
            obj[i] = sortObject(obj[i], arraySorter);
        }
        return obj;
    }
    var temp = {};
    var keys = [];
    for(var key in obj)
        keys.push(key);
    keys.sort();
    for(var index in keys)
        temp[keys[index]] = sortObject(obj[keys[index]], arraySorter);       
    return temp;
}

Esto soluciona el problema de que las matrices se conviertan en objetos y también le permite definir cómo ordenar las matrices.

Ejemplo:

var data = { content: [{id: 3}, {id: 1}, {id: 2}] };
sortObject(data, (i1, i2) => i1.id - i2.id)

salida:

{content:[{id:1},{id:2},{id:3}]}

La respuesta aceptada no me funciona para objetos anidados por alguna razón. Esto me llevó a codificar el mío. Como es a fines de 2019 cuando escribo esto, hay algunas opciones más disponibles dentro del idioma.

Actualización: Creo que la respuesta de David Furlong es un enfoque preferible a mi intento anterior, y lo he descartado. El mío depende del soporte para Object.entries (...), por lo que no es compatible con Internet Explorer.

function normalize(sortingFunction) {
  return function(key, value) {
    if (typeof value === 'object' && !Array.isArray(value)) {
      return Object
        .entries(value)
        .sort(sortingFunction || undefined)
        .reduce((acc, entry) => {
          acc[entry[0]] = entry[1];
          return acc;
        }, {});
    }
    return value;
  }
}

JSON.stringify(obj, normalize(), 2);

-

MANTENER ESTA VERSIÓN ANTIGUA PARA REFERENCIA HISTÓRICA

Descubrí que una matriz simple y plana de todas las claves en el objeto funcionará. En casi todos los navegadores (no en Edge o Internet Explorer, como era de esperar) y Node 12+, hay una solución bastante corta ahora que Array.prototype.flatMap (...) está disponible. (El equivalente de lodash también funcionaría). Solo he probado en Safari, Chrome y Firefox, pero no veo ninguna razón por la que no funcione en ningún otro lugar que admita flatMap y JSON.stringify estándar (...) .

function flattenEntries([key, value]) {
  return (typeof value !== 'object')
    ? [ [ key, value ] ]
    : [ [ key, value ], ...Object.entries(value).flatMap(flattenEntries) ];
}

function sortedStringify(obj, sorter, indent = 2) {
  const allEntries = Object.entries(obj).flatMap(flattenEntries);
  const sorted = allEntries.sort(sorter || undefined).map(entry => entry[0]);
  return JSON.stringify(obj, sorted, indent);
}

Con esto, puede secuenciar sin dependencias de terceros e incluso pasar su propio algoritmo de ordenación que ordena los pares de entrada clave-valor, de modo que pueda ordenar por clave, carga útil o una combinación de los dos. Funciona para objetos anidados, matrices y cualquier combinación de tipos de datos antiguos.

const obj = {
  "c": {
    "z": 4,
    "x": 3,
    "y": [
      2048,
      1999,
      {
        "x": false,
        "g": "help",
        "f": 5
      }
    ]
  },
  "a": 2,
  "b": 1
};

console.log(sortedStringify(obj, null, 2));

Huellas dactilares:

{
  "a": 2,
  "b": 1,
  "c": {
    "x": 3,
    "y": [
      2048,
      1999,
      {
        "f": 5,
        "g": "help",
        "x": false
      }
    ],
    "z": 4
  }
}

Si debe tener compatibilidad con motores JavaScript más antiguos , puede usar estas versiones un poco más detalladas que emulan el comportamiento de flatMap. El cliente debe admitir al menos ES5, por lo que no Internet Explorer 8 o inferior.

Estos devolverán el mismo resultado que el anterior.

function flattenEntries([key, value]) {
  if (typeof value !== 'object') {
    return [ [ key, value ] ];
  }
  const nestedEntries = Object
    .entries(value)
    .map(flattenEntries)
    .reduce((acc, arr) => acc.concat(arr), []);
  nestedEntries.unshift([ key, value ]);
  return nestedEntries;
}

function sortedStringify(obj, sorter, indent = 2) {
  const sortedKeys = Object
    .entries(obj)
    .map(flattenEntries)
    .reduce((acc, arr) => acc.concat(arr), [])
    .sort(sorter || undefined)
    .map(entry => entry[0]);
  return JSON.stringify(obj, sortedKeys, indent);
}

Funciona con lodash, objetos anidados, cualquier valor de atributo de objeto:

function sort(myObj) {
  var sortedObj = {};
  Object.keys(myObj).sort().forEach(key => {
    sortedObj[key] = _.isPlainObject(myObj[key]) ? sort(myObj[key]) : myObj[key]
  })
  return sortedObj;
}
JSON.stringify(sort(yourObj), null, 2)

Depende del comportamiento de Chrome y Node que la primera clave asignada a un objeto se genere primero por JSON.stringify.

Tratar:

function obj(){
  this.name = '';
  this.os = '';
}

a = new obj();
a.name = 'X',
a.os = 'linux';
JSON.stringify(a);
b = new obj();
b.os = 'linux';
b.name = 'X',
JSON.stringify(b);

Hice una función para ordenar el objeto y con devolución de llamada ... que en realidad crea un nuevo objeto

function sortObj( obj , callback ) {

    var r = [] ;

    for ( var i in obj ){
        if ( obj.hasOwnProperty( i ) ) {
             r.push( { key: i , value : obj[i] } );
        }
    }

    return r.sort( callback ).reduce( function( obj , n ){
        obj[ n.key ] = n.value ;
        return obj;
    },{});
}

y llámalo con objeto.

var obj = {
    name : "anu",
    os : "windows",
    value : 'msio',
};

var result = sortObj( obj , function( a, b ){
    return a.key < b.key  ;    
});

JSON.stringify( result )

que imprime {"value":"msio","os":"windows","name":"anu"}y para clasificar con valor.

var result = sortObj( obj , function( a, b ){
    return a.value < b.value  ;    
});

JSON.stringify( result )

que imprime {"os":"windows","value":"msio","name":"anu"}

Si los objetos de la lista no tienen las mismas propiedades, genere un objeto maestro combinado antes de encadenar:

let arr=[ <object1>, <object2>, ... ]
let o = {}
for ( let i = 0; i < arr.length; i++ ) {
  Object.assign( o, arr[i] );
}
JSON.stringify( arr, Object.keys( o ).sort() );

function FlatternInSort( obj ) {
    if( typeof obj === 'object' )
    {
        if( obj.constructor === Object )
        {       //here use underscore.js
            let PaireStr = _( obj ).chain().pairs().sortBy( p => p[0] ).map( p => p.map( FlatternInSort ).join( ':' )).value().join( ',' );
            return '{' + PaireStr + '}';
        }
        return '[' + obj.map( FlatternInSort ).join( ',' ) + ']';
    }
    return JSON.stringify( obj );
}

// ejemplo como a continuación. en cada capa, para objetos como {}, aplanados en orden de clave. para matrices, números o cadenas, aplanadas como / con JSON.stringify.

FlatternInSort ({c: 9, b: {y: 4, z: 2, e: 9}, F: 4, a: [{j: 8, h: 3}, {a: 3, b: 7}] })

"{" F ": 4," a ": [{" h ": 3," j ": 8}, {" a ": 3," b ": 7}]," b ": {" e " : 9, "y": 4, "z": 2}, "c": 9} "

Extendiendo la respuesta de AJP, para manejar matrices:

function sort(myObj) {
    var sortedObj = {};
    Object.keys(myObj).sort().forEach(key => {
        sortedObj[key] = _.isPlainObject(myObj[key]) ? sort(myObj[key]) : _.isArray(myObj[key])? myObj[key].map(sort) : myObj[key]
    })
    return sortedObj;
}

Sorprendido que nadie haya mencionado la isEqualfunción de Lodash .

Realiza una comparación profunda entre dos valores para determinar si son equivalentes.

Nota: Este método admite la comparación de matrices, búferes de matriz, valores booleanos, objetos de fecha, objetos de error, mapas, números, objetos de objeto, expresiones regulares, conjuntos, cadenas, símbolos y matrices escritas. Los objetos objeto se comparan por sus propias propiedades enumerables, no heredadas. Las funciones y los nodos DOM se comparan por estricta igualdad, es decir ===.

https://lodash.com/docs/4.17.11#isEqual

Con el problema original, las claves están ordenadas de manera inconsistente, es una gran solución y, por supuesto, se detendrá si encuentra un conflicto en lugar de serializar ciegamente todo el objeto.

Para evitar importar toda la biblioteca, haga esto:

import { isEqual } from "lodash-es";

Ejemplo de bonificación: también puede usar esto con RxJS con este operador personalizado

export const distinctUntilEqualChanged = <T>(): MonoTypeOperatorFunction<T> => 
                                                pipe(distinctUntilChanged(isEqual));

Después de todo, necesita una matriz que almacene en caché todas las claves en el objeto anidado (de lo contrario, omitirá las claves no almacenadas en caché). La respuesta más antigua es simplemente incorrecta, porque el segundo argumento no se preocupa por la notación de puntos. Entonces, la respuesta (usando Set) se convierte en.

function stableStringify (obj) {
  const keys = new Set()
  const getAndSortKeys = (a) => {
    if (a) {
      if (typeof a === 'object' && a.toString() === '[object Object]') {
        Object.keys(a).map((k) => {
          keys.add(k)
          getAndSortKeys(a[k])
        })
      } else if (Array.isArray(a)) {
        a.map((el) => getAndSortKeys(el))
      }
    }
  }
  getAndSortKeys(obj)
  return JSON.stringify(obj, Array.from(keys).sort())
}

Aquí hay un enfoque de clonación ... clone el objeto antes de convertirlo a json:

function sort(o: any): any {
    if (null === o) return o;
    if (undefined === o) return o;
    if (typeof o !== "object") return o;
    if (Array.isArray(o)) {
        return o.map((item) => sort(item));
    }
    const keys = Object.keys(o).sort();
    const result = <any>{};
    keys.forEach((k) => (result[k] = sort(o[k])));
    return result;
}

Si es muy nuevo pero parece funcionar bien en archivos package.json.

Hay un Array.sortmétodo que puede resultarle útil. Por ejemplo:

yourBigArray.sort(function(a,b){
    //custom sorting mechanism
});