Run results for: each-or-plain

Run details:

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/57.0.2987.37 Safari/537.36

Browser: Chrome 57

Operating system: Windows

Device Platform: Other

Date tested: 7 years ago

Test name	Executions per second
each	107.0 Ops/sec
for	244.6 Ops/sec

HTML Preparation code:

<script src="//ajax.googleapis.com/ajax/libs/jquery/1/jquery.min.js"></script>

Script Preparation code:

    var generateName = function(prefix) {
        return (prefix || '') + Math.random().toString(36).substr(2);
    };

    var generateValue = function(onlyTrivial) {
        var variants = [
            /* real number */
            function() { return Math.random(); },

            /* integer number */
            function() { return Math.floor(Math.random() * 1e16); },

            /* string */
            function() { return generateName(); },

            /* boolean */
            function() { return !Math.floor(Math.random() * 2); },

            /* array */
            function() {
                var result = [];

                for (var x = Math.floor(Math.random() * 3); x; x--) {
                    result.push(generateValue());
                }

                return result;
            },

            /* object */
            function() {
                var result = {};

                for (var x = Math.floor(Math.random() * 3); x; x--) {
                    result[generateName('x')] = generateValue();
                }

                return result;
            }
        ];

        if (onlyTrivial) {
            /* drop array and object variant */
            variants.pop();
            variants.pop();
        }

        return variants[Math.floor(Math.random() * variants.length)]();
    };

    var generateTree = function() {
        var args = Array.prototype.slice.call(arguments);
        var result = {};
        var loop = args.shift();
        var onlyTrivial = false;

        if (loop === false || loop === true) {
            onlyTrivial = loop;
            loop = args.shift();
        }

        args.unshift(onlyTrivial);

        for (; loop; loop--) {
            result[generateName('x')] = (args.length === 1) ? generateValue(onlyTrivial) : generateTree.apply(null, args);
        }

        return result;
    };

    var forbiddenElement = /^\[object (DIV|DOM|CSS|HTML|NamedNode|Node|Window)/;

    var isInvalidElement = function(element) {
        if (element) {
            if (element instanceof window.Node) {
                return true;
            }

            if ((element instanceof $) || (typeof element.css === 'function')) {
                return true;
            }

            if ((typeof element.toString === 'function') && forbiddenElement.test(element.toString())) {
                return true;
            }
        }

        return false;
    };

    var getKeys1 = function(tree, parent, order, skipEmpty) {
        parent = parent || '/';
        var keys = [];
        var type = $.type(tree);

        if ((type === 'object') && isInvalidElement(tree)) {
            type = 'invalid';
        }

        if (type === 'object' || type === 'array') {
            /* iterate over tree items */
            $.each(tree, function(key, value) {
                var leaf = parent + key;
                var valueType = $.type(value);

                keys.push(leaf);

                /* make sure that invalid elements (like: dom, $, window, etc) won't be parsed */
                if ((valueType === 'object') && isInvalidElement(value)) {
                    valueType = 'invalid';
                }

                /* if item is object or array, perform recursive call to get it's keys as well */
                if (valueType === 'object' || valueType === 'array') {
                    $.merge(keys, getKeys1(value, leaf + '/', null, skipEmpty));
                }
            });
        }

        return (typeof order === 'function') ? keys.sort(order) : keys.sort();
    };

    var getKeys2 = function(tree, parent, order, skipEmpty, level) {
        parent = parent || '/';
        level = level || 0;
        var result;
        var keys = [];
        var type = $.type(tree);

        if ((type === 'object') && isInvalidElement(tree)) {
            type = 'invalid';
        }

        if (type === 'object' || type === 'array') {
            /* iterate over tree items */
            for (var key in tree) {
                if (tree.hasOwnProperty(key)) {
                
                  
                var value = tree[key];
                var leaf = parent + key;
                var valueType = $.type(value);

                keys.push(leaf);

                /* make sure that invalid elements (like: dom, $, window, etc) won't be parsed */
                if ((valueType === 'object') && isInvalidElement(value)) {
                    valueType = 'invalid';
                }

                /* if item is object or array, perform recursive call to get it's keys as well */
                if (valueType === 'object' || valueType === 'array') {
                    $.merge(keys, getKeys2(value, leaf + '/', null, skipEmpty, level + 1));
                }

                
                }
            }
        }

        if (level === 0) {
            result = (typeof order === 'function') ? keys.sort(order) : keys.sort();
        } else {
            result = keys;
        }

        return result;
    };

Tests:

each
var z = window.zzz1; if (!z) { z = generateTree(3, 3, 3, 3, 2, 4); window.zzz1 = z; } getKeys1(z);
for
var z = window.zzz2; if (!z) { z = generateTree(3, 3, 3, 3, 2, 4); window.zzz2 = z; } getKeys2(z);