isCircularObject vs isCircular vs isCircularES5

JavaScript performance comparison

Revision 7 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,
        oToString = Object.prototype.toString,
        aSlice = Array.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") {
            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 (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 = Object.keys(obj).some(function (key) {
                    val = obj[key];

                    return (utility.isObject(val) || utility.isFunction(val)) && (a.indexOf(val) >= 0 || utility.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) && fn.toString().slice(-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] || classString.slice(0, l) === p);

            };
        }())
    });

    generateClassIs(["HTMLDocument"]);

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

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

            return function (obj) {
                try {
                    return utility.isObject(obj) && getPrototypeOf(obj).isPrototypeOf(o);
                } 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 Object.keys(obj).length === 0;
        }
    });

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

            if (utility.isPlainObject(obj)) {
                return Object.keys(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) && Object.keys(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, "escapeRegExpString", {
        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 " + utility.toClassString(str));
                }

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

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

    defineProperty(utility, "repeatString", {
        value: function (str, num) {
            if (!utility.isString(str)) {
                throw new TypeError("Attribute 'str' is not a string " + utility.toClassString(str));
            }

            if (str.length === 0 || !utility.isNumber(num) || !utility.isNumeric(num) || num <= 1) {
                if (num === 1) {
                    return str;
                }

                return '';
            }

            var result = '',
                pattern = str;

            /*jslint bitwise: true */
            while (num > 0) {
                if (num & 1) {
                    result += pattern;
                }

                num >>= 1;
                pattern += pattern;
            }
            /*jslint bitwise: false */

            return result;
        }
    });

    defineProperty(utility, "lpadString", {
        value: function (obj, str, num) {
            if (!utility.isString(obj)) {
                throw new TypeError("Attribute 'obj' is not a string " + utility.toClassString(obj));
            }

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

            return utility.repeatString(str, num) + obj;
        }
    });

    defineProperty(utility, "rpadString", {
        value: function (obj, str, num) {
            if (!utility.isString(obj)) {
                throw new TypeError("Attribute 'obj' is not a string " + utility.toClassString(obj));
            }

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

            return utility.repeatString(str, num) + obj;
        }
    });

    defineProperty(utility, "decodeURIQueryString", {
        value: (function () {
            var rx = /\+/g;

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

                return str.replace(rx, ' ');
            };
        }())
    });

    defineProperty(utility, "toQueryParams", {
        value: (function () {
            var mrx = new RegExp("([^?#]*)(#.*)?$"),
                qrx = new RegExp("(?:^|&)([^&=]*)=?([^&]*)", "g");

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

                var hash = {};

                str.trim().match(mrx)[1].replace(qrx, function () {
                    var args = aSlice.call(arguments),
                        key = args[1],
                        value = args[2];

                    if (utility.isString(key) && key.length > 0) {
                        key = utility.decodeURIQueryString(decodeURIComponent(key));

                        if (utility.isString(value) && value.length > 0) {
                            value = utility.decodeURIQueryString(decodeURIComponent(value));
                        } else {
                            value = "";
                        }

                        if (utility.isString(key) && key.length > 0) {
                            if (utility.isInitialised(hash[key])) {
                                if (!utility.isArray(hash[key])) {
                                    hash[key] = [hash[key]];
                                }

                                hash[key].push(value);
                            } else {
                                hash[key] = value;
                            }
                        }
                    }
                });

                return hash;
            };
        }())
    });

    defineProperty(utility, "toUriParts", {
        value: (function () {
            var srx = new RegExp("^(?:([^:\\/?#]+):)?(?:\\/\\/((?:(([^:@]*)(?::([^:@]*))?)?@)?([^:\\/?#]*)(?::(\\d*))?))?((((?:[^?#\\/]*\\/)*)([^?#]*))(?:\\?([^#]*))?(?:#(.*))?)"),
                lrx = new RegExp("^(?:(?![^:@]+:[^:@\\/]*@)([^:\\/?#.]+):)?(?:\\/\\/)?((?:(([^:@]*)(?::([^:@]*))?)?@)?([^:\\/?#]*)(?::(\\d*))?)(((\\/(?:[^?#](?![^?#\\/]*\\.[^?#\\/.]+(?:[?#]|$)))*\\/?)?([^?#\\/]*))(?:\\?([^#]*))?(?:#(.*))?)"),
                keys = ["source", "protocol", "authority", "userInfo", "user", "password", "host", "port", "relative", "path", "directory", "file", "query", "anchor"];

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

                var uri = {},
                    vals;

                if (strict === true) {
                    vals = srx.exec(str);
                } else {
                    vals = lrx.exec(str);
                }

                keys.forEach(function (key, index) {
                    var val = vals[index];

                    if (utility.isString(val) && val.length > 0) {
                        uri[key] = decodeURIComponent(val);
                    } else {
                        uri[key] = "";
                    }
                });

                if (uri.query.length > 0) {
                    uri.queryKey = utility.toQueryParams(uri.query);
                } else {
                    uri.queryKey = {};
                }

                if (uri.anchor.length > 0) {
                    uri.anchorKey = utility.toQueryParams(uri.anchor);
                } else {
                    uri.anchorKey = {};
                }

                return uri;
            };
        }())
    });

    defineProperty(utility, "toNumberIfNumeric", {
        value: function (str) {
            if (utility.isNumeric(str)) {
                return parseFloat(str);
            }

            return str;
        }
    });

    defineProperty(utility, "regex", {
        value: function (str, obj, flags) {
            if (!utility.isString(str)) {
                throw new TypeError("Attribute 'str' is not a string " + utility.toClassString(str));
            }

            if (!utility.isString(obj) && !utility.isRegExp(obj)) {
                throw new TypeError("Attribute 'obj' is not a string or regexp " + utility.toClassString(obj));
            }

            var matches,
                rx,
                uflags = '',
                cflags = '',
                interim = [],
                results = [];

            if (utility.isString(obj) && utility.isString(flags)) {
                if (flags.indexOf("g") >= 0) {
                    uflags += 'g';
                }

                if (flags.indexOf("i") >= 0) {
                    uflags += 'i';
                }
            }

            if (utility.isString(obj)) {
                matches = str.match(new RegExp(utility.escapeRegExpString(obj), uflags));
            } else {
                matches = str.match(obj);
            }
            if (!utility.isArray(matches)) {
                return utility.toNumberIfNumeric(matches);
            }

            if (utility.isRegExp(obj)) {
                if (obj.global) {
                    if (obj.multiline) {
                        cflags += 'm';
                    }

                    if (obj.ignoreCase) {
                        cflags += 'i';
                    }

                    rx = new RegExp(obj.source, cflags);

                    matches.forEach(function (match) {
                        interim.push(utility.regex(match, rx));
                    });
                } else {
                    if (matches.length > 1) {
                        interim = matches.slice(1);
                    } else {
                        return matches.pop();
                    }
                }

                interim.forEach(function (element) {
                    if (utility.isArray(element)) {
                        var a = [];

                        element.forEach(function (sub) {
                            a.push(utility.toNumberIfNumeric(sub));
                        });

                        results.push(a);
                    } else {
                        results.push(utility.toNumberIfNumeric(element));
                    }
                });
            } else {
                matches.forEach(function (match) {
                    results.push(utility.toNumberIfNumeric(match));
                });
            }

            return results;
        }
    });

    ///////////////////////////
    //       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