isCircularObject vs isCircular vs isCircularES5

JavaScript performance comparison

Revision 6 of this test case created by Xotic750

Preparation code

<script>
/*!
 * utility v0.3.0
 * http://code.google.com/p/utility-js/
 *
 * Developed by:
 * - Xotic750
 *
 * GPL version 3 or any later version; http://www.gnu.org/copyleft/gpl.html
 */


/*jslint sub: true, maxerr: 50, maxlen: 250, indent: 4 */
/*global window,document,console,alert,jQuery,GM_getValue,GM_setValue,GM_deleteValue,GM_listValues,localStorage,sessionStorage,rison,Components */

(function utility_closure() {
    "use strict";

    ///////////////////////////
    //       Variables
    ///////////////////////////

    var core = {},
        defineProperty = Object.defineProperty,
        getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor,
        getOwnPropertyNames = Object.getOwnPropertyNames,
        hasOwnProperty = Object.prototype.hasOwnProperty,
        getPrototypeOf = Object.getPrototypeOf,
        oKeys = Object.keys,
        oToString = Object.prototype.toString,
        sSlice = String.prototype.slice,
        cNull = null,
        cUndefined;

    ///////////////////////////
    //       Utility
    ///////////////////////////

    function Utility(obj) {
        defineProperty(this, "refersTo", {
            enumerable: true,
            value: obj
        });

        return this;
    }

    ///////////////////////////
    //       utility
    ///////////////////////////

    function utility(obj) {
        switch (utility.typeOf(obj)) {
        case "object":
            if (utility.isPlainObject(obj)) {
                Utility.prototype = core.Object.prototype;
            } else {
                Utility.prototype = core.Common.prototype;
            }

            break;
        case "array":
            Utility.prototype = core.Array.prototype;
            break;
        case "function":
            Utility.prototype = core.Function.prototype;
            break;
        case "string":
            Utility.prototype = core.String.prototype;
            break;
        case "number":
            Utility.prototype = core.Number.prototype;
            break;
        case "boolean":
            Utility.prototype = core.Boolean.prototype;
            break;
        case "date":
            Utility.prototype = core.Date.prototype;
            break;
        case "regexp":
            Utility.prototype = core.RegExp.prototype;
            break;
        case "arguments":
            Utility.prototype = core.Arguments.prototype;
            break;
        case "error":
            Utility.prototype = core.Error.prototype;
            break;
        default:
            Utility.prototype = core.Common.prototype;
        }

        return new Utility(obj);
    }

    defineProperty(utility, "version", {
        value: "0.3.0"
    });

    defineProperty(utility, "inheriting", {
        value: {}
    });

    defineProperty(utility, "mixin", {
        value: function (obj, inheritFrom, keys) {
            keys.forEach(function (key) {
                defineProperty(obj, key, getOwnPropertyDescriptor(inheritFrom, key));
            });
        }
    });

    defineProperty(utility, "isUndefined", {
        value: function (obj) {
            return obj === cUndefined;
        }
    });

    defineProperty(utility, "isNull", {
        value: function (obj) {
            return obj === cNull;
        }
    });

    defineProperty(utility, "isInitialised", {
        value: function (obj) {
            return !(obj === cUndefined || obj === cNull);
        }
    });

    function generateClassIs(typeArr) {
        if (oToString.call(typeArr) !== "[object Array]" || typeArr.length < 1) {
            throw new TypeError("'typeArr' must be an array with elements");
        }

        var prop = "is" + typeArr[0];

        if (typeArr[0] === "Array" && oToString.call(Array.isArray) === "[object Function]") {
            defineProperty(utility, prop, {
                value: Array.isArray
            });
        } else {
            defineProperty(utility, prop, {
                value: function (obj) {
                    var matched = typeArr.some(function (type) {
                        return obj !== cUndefined && obj !== cNull && oToString.call(obj) === "[object " + type + "]";
                    });

                    return matched;
                }
            });
        }
    }

    defineProperty(utility, "classStringToType", {
        value: (function () {
            var a = ["Boolean", "Number", "String", "Function", "Array", "Date", "RegExp", "Arguments", "Error", "Object"],
                o = {};

            a.forEach(function (type) {

                o["[object " + type + "]"] = type.toLowerCase();

                generateClassIs([type]);
            });

            return o;
        }())
    });

    defineProperty(utility, "toClassString", {
        value: function (obj) {
            return oToString.call(obj);
        }
    });

    defineProperty(utility, "typeOf", {
        value: function (obj) {
            if (!utility.isInitialised(obj)) {
                return String(obj);
            }

            return utility.classStringToType[utility.toClassString(obj)] || typeof obj;
        }
    });

    defineProperty(utility, "isNumeric", {
        value: (function () {
            var rx = /^-/;

            return function (obj) {
                return (utility.isNumber(obj) || (utility.isString(obj) && obj.length > 0)) && !isNaN(parseFloat(obj)) && isFinite(obj.toString().replace(rx, ''));
            };
        }())
    });

    defineProperty(utility, "isInt", {
        value: function (obj) {
            return utility.isNumeric(obj) && parseInt(obj, 10) === parseFloat(obj);
        }
    });

    defineProperty(utility, "isCircular", {
        value: function isCircular(obj, a) {
            if (!utility.isObject(obj) && !utility.isFunction(obj)) {
                return false;
            }

            if (!utility.isArray(a)) {
                if (utility.isInitialised(a)) {
                    throw new TypeError("Expected attribute to be an array");
                }

                a = [];
            }

            a.push(obj);
            var val,
                c = oKeys(obj).some(function (key) {
                    val = obj[key];

                    return (utility.isObject(val) || utility.isFunction(val)) && (a.indexOf(val) >= 0 || isCircular(val, a));
                });

            a.pop();
            return c;
        }
    });

    defineProperty(utility, "isNativeFunction", {
        value: (function () {
            var e = "{ [native code] }",
                m = e.length;

            return function (fn) {
                return utility.isFunction(fn) && sSlice.call(fn, -m) === e;
            };
        }())
    });

    defineProperty(utility, "has", {
        value: function (obj, prop) {
            return utility.isInitialised(obj) && utility.isString(prop) && prop.length > 0 && prop in obj;
        }
    });

    defineProperty(utility, "hasOwn", {
        value: function (obj, prop) {
            return utility.isInitialised(obj) && utility.isString(prop) && prop.length > 0 && hasOwnProperty.call(obj, prop);
        }
    });

    defineProperty(utility, "isDom", {
        value: (function () {
            var p = "[object HTML",
                l = p.length,
                a = ["Element", "Attr", "Text", "CDATASection", "EntityReference", "Entity", "ProcessingInstruction", "Comment", "Document", "DocumentType", "DocumentFragment", "Notation"],
                o = {};

            a.forEach(function (type) {
                o["[object " + type + "]"] = true;

                generateClassIs(["DOMType" + type]);
            });

            return function (obj) {
                var classString = utility.toClassString(obj);

                return utility.isObject(obj) && (o[classString] || sSlice.call(classString, 0, l) === p);

            };
        }())
    });

    generateClassIs(["HTMLDocument"]);

    generateClassIs(["Window", "global"]);

    defineProperty(utility, "isPlainObject", {
        value: (function () {
            var cp = getPrototypeOf({});

            return function (obj) {
                try {
                    return obj !== null && typeof obj === "object" && typeof obj.constructor === "function" && getPrototypeOf(obj) === cp;
                } catch (e) {
                    return false;
                }
            };
        }())
    });

    defineProperty(utility, "isEmptyObject", {
        value: function (obj) {
            if (!utility.isPlainObject(obj)) {
                throw new TypeError("Cannot call method 'isEmptyObject' of " + utility.toClassString(obj));
            }

            return oKeys(obj).length === 0;
        }
    });

    defineProperty(utility, "lengthOf", {
        value: function (obj) {
            if (utility.isArray(obj) || utility.isString(obj) || utility.isArguments(obj) || ((utility.isObject(obj) || utility.isFunction(obj)) && utility.hasOwn(obj, "length"))) {
                return obj.length;
            }

            if (utility.isPlainObject(obj)) {
                return oKeys(obj).length;
            }

            if (utility.isDom(obj)) {
                return obj.childNodes.length;
            }

            throw new Error("Cannot call method 'lengthOf' of " + utility.toClassString(obj));
        }
    });

    defineProperty(utility, "hasContent", {
        value: function (obj) {
            if (!utility.isInitialised(obj)) {
                return false;
            }

            if (utility.isFunction(obj) || utility.isBoolean(obj) || utility.isWindow(obj)) {
                return true;
            }

            if (utility.isNumber(obj) || utility.isDate(obj)) {
                return isFinite(obj);
            }

            if (utility.isRegExp(obj)) {
                return utility.isString(obj.source) && obj.source.length > 0 && obj.source !== "(?:)";
            }

            if (utility.isError(obj)) {
                return utility.isString(obj.stack) && obj.stack.length > 0;
            }

            try {
                return utility.lengthOf(obj) > 0;
            } catch (e) {
                throw new Error("Cannot call method 'hasContent' of " + utility.toClassString(obj));
            }
        }
    });

    defineProperty(utility, "setContent", {
        value: function (obj, val) {
            if (utility.hasContent(obj)) {
                return obj;
            }

            return val;
        }
    });

    defineProperty(utility, "hasIndexOf", {
        value: function (obj, val) {
            return ((utility.isArray(obj) || !utility.isString(obj)) && obj.length > 0 && obj.indexOf(val) >= 0) || (utility.isPlainObject(obj) && oKeys(obj).indexOf(val) >= 0);
        }
    });

    defineProperty(utility, "addEvent", {
        value: function addEvent(obj, type, fn) {
            if (!utility.isDom(obj) || (!utility.has(obj, "attachEvent") && !utility.has(obj, "addEventListener"))) {
                throw new TypeError("Cannot call method 'addEvent' of " + utility.toClassString(obj));
            }

            if (!utility.isString(obj) || obj.length < 1) {
                throw new TypeError("Attribute 'type' is not a valid identifier");
            }

            if (!utility.isFunction(obj)) {
                throw new TypeError("Attribute 'fn' is not a function");
            }

            if (utility.isFunction(obj, "attachEvent")) {
                obj['e' + type + fn] = fn;
                obj[type + fn] = function () {
                    obj['e' + type + fn](window.event);
                };

                obj.attachEvent('on' + type, obj[type + fn]);
            } else if (utility.isFunction(obj, "addEventListener")) {
                obj.addEventListener(type, fn, false);
            } else {
                throw new Error("unable to call method 'addEvent' of" + utility.toClassString(obj));
            }
        }
    });

    defineProperty(utility, "removeEvent", {
        value: function (obj, type, fn) {
            if (!utility.isDom(obj) || (!utility.has(obj, "detachEvent") && !utility.has(obj, "removeEventListener"))) {
                throw new TypeError("Cannot call method 'removeEvent' of " + utility.toClassString(obj));
            }

            if (!utility.isString(obj) || obj.length < 1) {
                throw new TypeError("Attribute 'type' is not a valid identifier");
            }

            if (!utility.isFunction(obj)) {
                throw new TypeError("Attribute 'fn' is not a function");
            }

            if (utility.isFunction(obj, "detachEvent")) {
                obj.detachEvent('on' + type, obj[type + fn]);
                obj[type + fn] = null;
            } else if (utility.isFunction(obj, "removeEventListener")) {
                obj.removeEventListener(type, fn, false);
            } else {
                throw new Error("unable to call method 'removeEvent' of" + utility.toClassString(obj));
            }
        }
    });

    defineProperty(utility, "escapeRegExp", {
        value: (function () {
            var a = ['.', '*', '+', '?', '^', '=', '!', ':', '$', '{', '}', '(', ')', '|', '[', ']', '/', '\\'],
                rx = new RegExp("([\\" + a.join('\\') + "])", "gm");

            return function (str) {
                if (!utility.isString(str)) {
                    throw new TypeError("Attribute 'str' is not a string");
                }

                if (str.length === 0) {
                    return str;
                }

                return str.replace(rx, '\\$1');
            };
        }())
    });

    ///////////////////////////
    //       Mixin functions
    ///////////////////////////

    function mixinCommon(obj) {
        var a = ["ref", "toString", "toLocaleString", "valueOf"];

        utility.mixin(obj.prototype, core.Common.prototype, a);
    }

    function mixinRelavant(obj, inheritFrom) {
        var a = ["constructor", "prototype", "hasOwnProperty", "propertyIsEnum", "isPrototypeOf", "valueOf", "toString", "toLocaleString", "callee", "caller", "__defineGetter__", "__lookupGetter__", "__defineSetter__", "__lookupSetter__"];

        getOwnPropertyNames(inheritFrom).forEach(function (key) {
            var src = getOwnPropertyDescriptor(inheritFrom, key);

            if (a.indexOf(key) < 0) {
                if (utility.isFunction(src.value)) {
                    defineProperty(obj, key, {
                        value: function () {
                            return inheritFrom[key].apply(this.refersTo, arguments);
                        }
                    });
                } else if (utility.isUndefined(src.value) || (utility.isUndefined(src.get) && !utility.isUndefined(src.set))) {
                    defineProperty(obj, key, {
                        get: function () {
                            return this.refersTo[key];
                        }
                    });
                } else if (utility.isUndefined(src.get) && utility.isUndefined(src.set)) {
                    defineProperty(obj, key, {
                        get: function () {
                            return this.refersTo[key];
                        },
                        set: function (val) {
                            this.refersTo[key] = val;
                        }
                    });
                } else if (!utility.isUndefined(src.get) && utility.isUndefined(src.set)) {
                    defineProperty(obj, key, {
                        set: function (val) {
                            this.refersTo[key] = val;
                        }
                    });
                } else {
                    throw new Error("Did not find any expected property descripter elements in " + key);
                }
            }
        });
    }

    ///////////////////////////
    //       Common
    ///////////////////////////

    defineProperty(core, "Common", {
        value: function UCommon() {}
    });

    defineProperty(core.Common.prototype, "ref", {
        get: function () {
            return this.refersTo;
        }
    });

    defineProperty(core.Common.prototype, "valueOf", {
        value: function () {
            if (!utility.isInitialised(this.refersTo)) {
                return this.refersTo;
            }

            return this.refersTo.valueOf();
        }
    });

    defineProperty(core.Common.prototype, "toString", {
        value: function () {
            if (!utility.isInitialised(this.refersTo)) {
                return String(this.refersTo);
            }

            return this.refersTo.toString();
        }
    });

    defineProperty(core.Common.prototype, "toLocaleString", {
        value: function () {
            if (!utility.isInitialised(this.refersTo)) {
                return String(this.refersTo);
            }

            return this.refersTo.toLocaleString();
        }
    });

    ///////////////////////////
    //       Object
    ///////////////////////////

    defineProperty(core, "Object", {
        value: function UObject() {}
    });

    mixinCommon(core.Object);
    mixinRelavant(core.Object.prototype, Object.prototype);

    ///////////////////////////
    //       Array
    ///////////////////////////


    defineProperty(core, "Array", {
        value: function UArray() {}
    });

    mixinCommon(core.Array);
    mixinRelavant(core.Array.prototype, Array.prototype);

    ///////////////////////////
    //       function
    ///////////////////////////

    defineProperty(core, "Function", {
        value: function UFunction() {}
    });

    mixinCommon(core.Function);
    mixinRelavant(core.Function.prototype, Function.prototype);

    ///////////////////////////
    //       String
    ///////////////////////////

    defineProperty(core, "String", {
        value: function UString() {}
    });

    mixinCommon(core.String);
    mixinRelavant(core.String.prototype, String.prototype);

    ///////////////////////////
    //       Number
    ///////////////////////////

    defineProperty(core, "Number", {
        value: function UNumber() {}
    });

    mixinCommon(core.Number);
    mixinRelavant(core.Number.prototype, Number.prototype);

    ///////////////////////////
    //       Date
    ///////////////////////////

    defineProperty(core, "Date", {
        value: function UDate() {}
    });

    mixinCommon(core.Date);
    mixinRelavant(core.Date.prototype, Date.prototype);

    ///////////////////////////
    //       RegExp
    ///////////////////////////

    defineProperty(core, "RegExp", {
        value: function URegExp() {}
    });

    mixinCommon(core.RegExp);
    mixinRelavant(core.RegExp.prototype, RegExp.prototype);

    ///////////////////////////
    //       Arguments
    ///////////////////////////

    defineProperty(core, "Arguments", {
        value: function UArguments() {}
    });

    mixinCommon(core.Arguments);
    mixinRelavant(core.Arguments.prototype, arguments);

    ///////////////////////////
    //       Error
    ///////////////////////////

    defineProperty(core, "Error", {
        value: function UError() {}
    });

    mixinCommon(core.Error);
    mixinRelavant(core.Error.prototype, Error.prototype);

    ///////////////////////////
    //       Boolean
    ///////////////////////////

    defineProperty(core, "Boolean", {
        value: function UBoolean() {}
    });

    mixinCommon(core.Boolean);
    mixinRelavant(core.Boolean.prototype, Boolean.prototype);

    ///////////////////////////
    //       Expose
    ///////////////////////////

    window.$u = utility;
}());

function isCircular(obj, arr) {
    "use strict";

    var type = typeof obj,
        propName,
        thisVal,
        iterArr,
        lastArr;

    if (type !== "object" && type !== "function") {
        return false;
    }

    if (Object.prototype.toString.call(arr) !== '[object Array]') {
        type = typeof arr; // jslint sake
        if (!(type === "undefined" || type === null)) {
            throw new TypeError("Expected attribute to be an array");
        }

        arr = [];
    }

    arr.push(obj);
    lastArr = arr.length - 1;

    for (propName in obj) {
        thisVal = obj[propName];
        type = typeof thisVal;

        if (type === "object" || type === "function") {
            for (iterArr = lastArr; iterArr >= 0; iterArr -= 1) {
                if (thisVal === arr[iterArr]) {
                    return true;
                }
            }

            if (isCircular(thisVal, arr)) {
                return true;
            }

        }
    }

    arr.pop(obj);
    return false;
}

function isCircularES5Hybrid1(obj, arr) {
    "use strict";

    var type = typeof obj,
        propName,
        keys,
        thisVal,
        iterKeys;


    if (type !== "object" && type !== "function") {
        return false;
    }

    if (!Array.isArray(arr)) {
        type = typeof arr; // jslint sake
        if (!(type === "undefined" || type === null)) {
            throw new TypeError("Expected attribute to be an array");
        }

        arr = [];
    }

    arr.push(obj);

    for (propName in obj) {
        thisVal = obj[propName];
        type = typeof thisVal;

        if (type === "object" || type === "function") {
            if (arr.indexOf(obj[propName]) >= 0) {
                return true;
            }

            if (isCircular(thisVal, arr)) {
                return true;
            }

        }
    }

    arr.pop(obj);
    return false;
}

function isCircularES5(obj, arr) {
    "use strict";

    var type = typeof obj,
        propName,
        keys,
        thisVal,
        iterKeys;


    if (type !== "object" && type !== "function") {
        return false;
    }

    if (!Array.isArray(arr)) {
        type = typeof arr; // jslint sake
        if (!(type === "undefined" || type === null)) {
            throw new TypeError("Expected attribute to be an array");
        }

        arr = [];
    }

    arr.push(obj);

    keys = Object.keys(obj);
    for (iterKeys = keys.length - 1; iterKeys >= 0; iterKeys -= 1) {
        propName = keys[iterKeys];
        thisVal = obj[keys[iterKeys]];
        type = typeof thisVal;

        if (type === "object" || type === "function") {
            if (arr.indexOf(obj[propName]) >= 0) {
                return true;
            }

            if (isCircular(thisVal, arr)) {
                return true;
            }

        }
    }

    arr.pop(obj);
    return false;
}

function isCircularObject(node, parents) {
    parents = parents || [];

    if (!node || typeof node != "object") {
        return false;
    }

    var keys = Object.keys(node), i, value;

    parents.push(node); // add self to current path
    for (i = keys.length-1; i >= 0; i--) {
        value = node[keys[i]];
        if (value && typeof value == "object") {
            if (parents.indexOf(value) >= 0) {
                // circularity detected!
                return true;
            }

            // check child nodes
            if (arguments.callee(value, parents)) {
                return true;
            }

        }
    }

    parents.pop(node);
    return false;
}
</script>
<script>
Benchmark.prototype.setup = function() {
    var testObject = Object;
};
</script>

Test runner

Warning! For accurate results, please disable Firebug before running the tests. (Why?)

Java applet disabled.

Testing in unknown unknown
Test Ops/sec
isCircularObject
isCircularObject(testObject);
pending…
isCircular
isCircular(testObject);
pending…
isCircularES5
isCircularES5(testObject);
pending…
isCircularES5Hybrid1
isCircularES5Hybrid1(testObject);
pending…
$u.isCircular
$u.isCircular(testObject);
pending…

Compare results of other browsers

Revisions

You can edit these tests or add even more tests to this page by appending /edit to the URL. Here’s a list of current revisions for this page:

0 comments

Add a comment