trier les propriétés des objets et JSON.stringify

je pense que si vous êtes en contrôle de la génération JSON( et il semble que vous êtes), alors pour vos besoins ce pourrait être une bonne solution: JSON-stable-stringify

du site Web du projet:

deterministic JSON.stringify () avec tri personnalisé pour obtenir déterministe à partir de hachages stringified résultats

si le JSON produit est déterministe vous devriez être capable de le différencier/le fusionner facilement.

vous pouvez passer un tableau trié des noms de propriétés comme deuxième argument de JSON.stringify() :

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

mise à jour 2018-7-24:

cette version trie les objets imbriqués et supporte le tableau aussi bien:

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));
}

cas de Test:

  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}]');
    });

  });

réponse dépréciée:

Une version concise dans ES2016. Crédit à @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), {}));
}

c'est la même chose que la réponse 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"}"

Vous pouvez ajouter des toJSON fonction de votre objet que vous pouvez utiliser pour personnaliser la sortie. À l'intérieur de la fonction, l'ajout de propriétés courantes à un nouvel objet dans un ordre spécifique devrait préserver cet ordre lors de la stringification.

voir ici:

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

il n'y a pas de méthode intégrée pour contrôler commande parce que les données JSON sont destinées à être accessibles par des clés.

voici un jsfiddle avec un petit exemple:

http://jsfiddle.net/Eq2Yw/

essayez de commenter la fonction toJSON - l'ordre des propriétés est inversé. Veuillez noter que cela peut être spécifique au navigateur, c'est-à-dire que la commande n'est pas officiellement prise en charge dans la spécification. Il fonctionne dans la version actuelle de Firefox, mais si vous voulez une solution 100% robuste, vous pouvez avoir à écrire votre propre fonction stringifier.

Edit:

Voir Aussi cette question concernant la sortie non déterministe de stringify, en particulier les détails de Daff sur les différences de navigateur:

Comment vérifier de façon déterministe qu'un objet JSON n'a pas été modifié?

récursive et simplifié réponse:

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);

j'ai pris la réponse de @Jason Parham et fait quelques améliorations

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;
}

cela corrige le problème des tableaux convertis en objets, et vous permet également de définir comment trier les tableaux.

exemple:

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

sortie:

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

Fonctionne avec lodash, objets imbriqués, de toute valeur d'attribut de l'objet:

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)

il s'appuie sur le comportement de Chrome et de Node pour que la première clé assignée à un objet soit émise en premier par JSON.stringify .

, Essayez:

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);

j'ai créé une fonction pour trier les objets, et avec rappel .. qui créent réellement un nouvel objet

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;
    },{});
}

et appelez-le avec objet .

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

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

JSON.stringify( result )

qui imprime {"value":"msio","os":"windows","name":"anu"} , et pour le tri avec valeur .

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

JSON.stringify( result )

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

vous pouvez trier un objet par nom de propriété dans EcmaScript 2015

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

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;

si les objets de la liste n'ont pas les mêmes propriétés, générer un objet maître combiné avant stringify:

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 );
}

/ / exemple ci-dessous. dans chaque couche, pour les objets comme {}, aplatie dans le tri de clés. pour tableaux, nombres ou cordes, aplatis comme/avec 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,"une":[{"h":3,"j":8},{"a":3,"b":7}],"b":{"e":9,"y":4,"z":2},"c":9}"

Extension AJP réponse, pour gérer des tableaux:

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;
}

il est Array.sort méthode qui peut être utile pour vous. Par exemple:

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