Benchmark: Hashable JSON + md4

HTML Preparation code:

<script src="https://unpkg.com/js-md4"></script>

Script Preparation code:

var obj = {
  za: {
    wannabe: [
      "Yo, I'll tell you what I want, what I really, really want",
      "So tell me what you want, what you really, really want",
      "I'll tell you what I want, what I really, really want",
      "So tell me what you want, what you really, really want",
      "I wanna, (ha) I wanna, (ha) I wanna, (ha) I wanna, (ha)",
      "I wanna really, really, really wanna zigazig ah",
    ],
  },
  12: 12,
  "": "empty",
  abcd: {
    objAsArray: {
      0: { n: "val", e: "val" },
      1: { n: "val", e: "val" },
      2: { n: "val", e: "val" },
      3: { n: "val", e: "val" },
      4: { n: "val", e: "val" },
      5: { n: "val", e: "val" },
      6: { n: "val", e: "val" },
      7: { n: "val", e: "val" },
      8: { n: "val", e: "val" },
      9: { n: "val", e: "val" },
      10: { n: "val", e: "val", r: { n: 12, 3: 3 } },
    },
    l: { id: "asdfas" },
    array: [ 12, 3, 13, 32, 134, 1234, 5, 213, 2, 34, 5, 134, 0, 51, 234124, 12, 51, 235, 123, 4, 32, 42, 5, 235, 1235, 1253, ],
    "😄": "💩",
    "-0": 123,
  },
};


function customcanonicalize(_, value) {
    if (value === null || typeof value !== 'object' || Array.isArray(value)) {
        return value;
    }

    var keys = Object.keys(value).sort();
    var length = keys.length;
    var object = {};

    for (var i = 0; i < length; i++) {
        object[keys[i]] = value[keys[i]];
    }

    return object;
}

function customStringify(obj) {
    return JSON.stringify(obj, customcanonicalize);
};


var canonicalize = function(object) {

    var buffer = '';
    serialize(object);
    return buffer;

    function serialize(object) {
        if (object !== null && typeof object === 'object') {
            if (Array.isArray(object)) {
                buffer += '[';
                let next = false;
                // Array - Maintain element order
                object.forEach((element) => {
                    if (next) {
                        buffer += ',';
                    }
                    next = true;
                    // Recursive call
                    serialize(element);
                });
                buffer += ']';
            } else {
                buffer += '{';
                let next = false;
                // Object - Sort properties before serializing
                Object.keys(object).sort().forEach((property) => {
                    if (next) {
                        buffer += ',';
                    }
                    next = true;
                    // Properties are just strings - Use ES6
                    buffer += JSON.stringify(property);
                    buffer += ':';
                    // Recursive call
                    serialize(object[property]);
                });
                buffer += '}';
            }
        } else {
            // Primitive data type - Use ES6
            buffer += JSON.stringify(object);
        }
    }
};

var json = typeof JSON !== 'undefined' ? JSON : require('jsonify');

function stableStringify(obj, opts) {
    if (!opts) opts = {};
    if (typeof opts === 'function') opts = { cmp: opts };
    var space = opts.space || '';
    if (typeof space === 'number') space = Array(space+1).join(' ');
    var cycles = (typeof opts.cycles === 'boolean') ? opts.cycles : false;
    var replacer = opts.replacer || function(key, value) { return value; };

    var cmp = opts.cmp && (function (f) {
        return function (node) {
            return function (a, b) {
                var aobj = { key: a, value: node[a] };
                var bobj = { key: b, value: node[b] };
                return f(aobj, bobj);
            };
        };
    })(opts.cmp);

    var seen = [];
    return (function stringify (parent, key, node, level) {
        var indent = space ? ('\n' + new Array(level + 1).join(space)) : '';
        var colonSeparator = space ? ': ' : ':';

        if (node && node.toJSON && typeof node.toJSON === 'function') {
            node = node.toJSON();
        }

        node = replacer.call(parent, key, node);

        if (node === undefined) {
            return;
        }
        if (typeof node !== 'object' || node === null) {
            return json.stringify(node);
        }
        if (isArray(node)) {
            var out = [];
            for (var i = 0; i < node.length; i++) {
                var item = stringify(node, i, node[i], level+1) || json.stringify(null);
                out.push(indent + space + item);
            }
            return '[' + out.join(',') + indent + ']';
        }
        else {
            if (seen.indexOf(node) !== -1) {
                if (cycles) return json.stringify('__cycle__');
                throw new TypeError('Converting circular structure to JSON');
            }
            else seen.push(node);

            var keys = objectKeys(node).sort(cmp && cmp(node));
            var out = [];
            for (var i = 0; i < keys.length; i++) {
                var key = keys[i];
                var value = stringify(node, key, node[key], level+1);

                if(!value) continue;

                var keyValue = json.stringify(key)
                    + colonSeparator
                    + value;
                ;
                out.push(indent + space + keyValue);
            }
            seen.splice(seen.indexOf(node), 1);
            return '{' + out.join(',') + indent + '}';
        }
    })({ '': obj }, '', obj, 0);
};

var isArray = Array.isArray || function (x) {
    return {}.toString.call(x) === '[object Array]';
};

var objectKeys = Object.keys || function (obj) {
    var has = Object.prototype.hasOwnProperty || function () { return true };
    var keys = [];
    for (var key in obj) {
        if (has.call(obj, key)) keys.push(key);
    }
    return keys;
};

function fastStableStringify(data, opts) {
    if (!opts) opts = {};
    if (typeof opts === 'function') opts = { cmp: opts };
    var cycles = (typeof opts.cycles === 'boolean') ? opts.cycles : false;

    var cmp = opts.cmp && (function (f) {
        return function (node) {
            return function (a, b) {
                var aobj = { key: a, value: node[a] };
                var bobj = { key: b, value: node[b] };
                return f(aobj, bobj);
            };
        };
    })(opts.cmp);

    var seen = [];
    return (function stringify (node) {
        if (node && node.toJSON && typeof node.toJSON === 'function') {
            node = node.toJSON();
        }

        if (node === undefined) return;
        if (typeof node == 'number') return isFinite(node) ? '' + node : 'null';
        if (typeof node !== 'object') return JSON.stringify(node);

        var i, out;
        if (Array.isArray(node)) {
            out = '[';
            for (i = 0; i < node.length; i++) {
                if (i) out += ',';
                out += stringify(node[i]) || 'null';
            }
            return out + ']';
        }

        if (node === null) return 'null';

        if (seen.indexOf(node) !== -1) {
            if (cycles) return JSON.stringify('__cycle__');
            throw new TypeError('Converting circular structure to JSON');
        }

        var seenIndex = seen.push(node) - 1;
        var keys = Object.keys(node).sort(cmp && cmp(node));
        out = '';
        for (i = 0; i < keys.length; i++) {
            var key = keys[i];
            var value = stringify(node[key]);

            if (!value) continue;
            if (out) out += ',';
            out += JSON.stringify(key) + ':' + value;
        }
        seen.splice(seenIndex, 1);
        return '{' + out + '}';
    })(data);
};

function davidStringify(obj) {
    const allObjectKeys = getAllKeys(obj);

    return JSON.stringify(obj, allObjectKeys.sort());
}

function getAllKeys(obj) {
    let keys = [];

    Object.entries(obj).forEach(([key, value]) => {
        keys.push(key);

        if (value && typeof value === 'object') {
            keys = keys.concat(getAllKeys(value));
        }
    });

    return keys;
}

Tests:

Current implementation
md4(customStringify(obj))
json-stable-stringify
md4(stableStringify(obj))
fast-json-stable-stringify
md4(fastStableStringify(obj))
david-stringify
md4(davidStringify(obj))
json-canonicalization
md4(canonicalize(obj))

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Current implementation
json-stable-stringify
fast-json-stable-stringify
david-stringify
json-canonicalization

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 2 years ago)

User agent: Mozilla/5.0 (X11; Linux x86_64; rv:109.0) Gecko/20100101 Firefox/119.0

Browser/OS: Firefox 119 on Linux

View result in a separate tab

Test name	Executions per second
Current implementation	59245.2 Ops/sec
json-stable-stringify	38850.4 Ops/sec
fast-json-stable-stringify	52463.6 Ops/sec
david-stringify	32868.2 Ops/sec
json-canonicalization	47023.8 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):

LLMs can make mistakes. Check important info.

Based on the provided code and benchmark results, I'll try to answer your question.

The code appears to be a JavaScript function `customStringify` that converts an object into a JSON string. It seems to have some additional logic for handling circular references and other edge cases, which is why it's called "custom" and not just a simple `JSON.stringify`.

Comparing the benchmark results, we can see that:

* The `Current implementation` has the highest execution speed, suggesting that it's likely the most optimized.
* The `fast-json-stable-stringify` variant is significantly faster than the others, indicating that it might be using a more efficient algorithm or technique.
* The `json-canonicalization` and `json-stable-stringify` variants are slower than the others, which could be due to their additional logic for handling edge cases.

Given these observations, I'll take an educated guess:

It seems that the `fast-json-stable-stringify` variant is likely a optimized implementation of the original `customStringify` function. The fact that it's significantly faster suggests that it might be using some advanced techniques or optimizations that aren't present in the other variants.

If you'd like to confirm this, I can try to analyze the code for the `fast-json-stable-stringify` variant and see if I can identify any specific optimizations or techniques being used.

Related benchmarks:

Hashable JSON + md4 (version: 0)

Comparing performance of: Current implementation vs json-stable-stringify vs fast-json-stable-stringify vs david-stringify vs json-canonicalization

Created: 4 years ago by: Guest

Jump to the latest result

Current implementation

json-stable-stringify

fast-json-stable-stringify

david-stringify

json-canonicalization

Suite status: <idle, ready to run>

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one year ago):