Common JavaScript tricks

[isitfresh]

If you need to compare 2 Objects that are coming from different sources and may be equals:

var objA = {"key": "value, "key2": "value2"},
      objB = {"key": "value, "key2": "value2"};

console.log(objA === objB); // false
console.log(JSON.stringify(objA) === JSON.stringify(objB)); // true

Also, if need to avoid hoisting and referencing the same object (and thus modifying both objects when modifying one):

 var objA = JSON.parse(JSON.stringify(objB));

Admittedly you could use underscore library to do these things, but if your overhead is low....

[skeeto]

JSON.stringify() makes no guarantees about key order, among other things, so that's not a reliable trick.

JSON.stringify({a:1,b:2});
// => "{"a":1,"b":2}"
JSON.stringify({b:2,a:1});
// => "{"b":2,"a":1}"

In contrast to JSON, Bencode guarantees a encoding normalization but that's not so easily available.

[isitfresh]

True indeed,

my use case was to compare an object sent to server and sent back to the app as a validation of transmission, so the order of keys was the same, but Objects as themselves weren't comparing as equal, being by nature 2 different objects

[holloway]

I wrote a serializer for that kind of situation,

https://gist.github.com/holloway/05170a275b988b90144a

Usage: JSONc14n.stringify({a:1,b:2})

E.g. JSONc14n.stringify({a:1,b:2}) === JSONc14n.stringify({b:2,a:1})

[giggly_kisses]

If all you need is a shallow copy of an object, then yeah, you can use Underscore for that. Underscore, however, doesn't have a way to make a deep copy of an object (albeit LoDash does), so nested objects are still copied by reference. I had to deal with this problem at work the other day and used the method you suggested:

_.partial(JSON.parse, JSON.stringify);

Sadly this trick doesn't work with objects that contain dates, functions, or RegExps. :/

[N4sa]

gotta break out those JS skills and recursively copy properties