整理js代码

function $(id) {
    return document.getElementById(id);
}

/**
 * [clientCheck 客户端检测]
 * @return {[type]} [description]
 */
function clientCheck() {
    //rendering engines
    var engine = {
        ie: 0,
        gecko: 0,
        webkit: 0,
        khtml: 0,
        opera: 0,

        //complete version
        ver: null
    };

    //browsers
    var browser = {

        //browsers
        ie: 0,
        firefox: 0,
        safari: 0,
        konq: 0,
        opera: 0,
        chrome: 0,

        //specific version
        ver: null
    };


    //platform/device/OS
    var system = {
        win: false,
        mac: false,
        x11: false,

        //mobile devices
        iphone: false,
        ipod: false,
        ipad: false,
        ios: false,
        android: false,
        nokiaN: false,
        winMobile: false,

        //game systems
        wii: false,
        ps: false
    };

    //detect rendering engines/browsers
    var ua = navigator.userAgent;
    if (window.opera) {
        engine.ver = browser.ver = window.opera.version();
        engine.opera = browser.opera = parseFloat(engine.ver);
    } else if (/AppleWebKit\/(\S+)/.test(ua)) {
        engine.ver = RegExp["$1"];
        engine.webkit = parseFloat(engine.ver);

        //figure out if it's Chrome or Safari
        if (/Chrome\/(\S+)/.test(ua)) {
            browser.ver = RegExp["$1"];
            browser.chrome = parseFloat(browser.ver);
        } else if (/Version\/(\S+)/.test(ua)) {
            browser.ver = RegExp["$1"];
            browser.safari = parseFloat(browser.ver);
        } else {
            //approximate version
            var safariVersion = 1;
            if (engine.webkit < 100) {
                safariVersion = 1;
            } else if (engine.webkit < 312) {
                safariVersion = 1.2;
            } else if (engine.webkit < 412) {
                safariVersion = 1.3;
            } else {
                safariVersion = 2;
            }

            browser.safari = browser.ver = safariVersion;
        }
    } else if (/KHTML\/(\S+)/.test(ua) || /Konqueror\/([^;]+)/.test(ua)) {
        engine.ver = browser.ver = RegExp["$1"];
        engine.khtml = browser.konq = parseFloat(engine.ver);
    } else if (/rv:([^\)]+)\) Gecko\/\d{8}/.test(ua)) {
        engine.ver = RegExp["$1"];
        engine.gecko = parseFloat(engine.ver);

        //determine if it's Firefox
        if (/Firefox\/(\S+)/.test(ua)) {
            browser.ver = RegExp["$1"];
            browser.firefox = parseFloat(browser.ver);
        }
    } else if (/MSIE ([^;]+)/.test(ua)) {
        engine.ver = browser.ver = RegExp["$1"];
        engine.ie = browser.ie = parseFloat(engine.ver);
    }

    //detect browsers
    browser.ie = engine.ie;
    browser.opera = engine.opera;


    //detect platform
    var p = navigator.platform;
    system.win = p.indexOf("Win") == 0;
    system.mac = p.indexOf("Mac") == 0;
    system.x11 = (p == "X11") || (p.indexOf("Linux") == 0);

    //detect windows operating systems
    if (system.win) {
        if (/Win(?:dows )?([^do]{2})\s?(\d+\.\d+)?/.test(ua)) {
            if (RegExp["$1"] == "NT") {
                switch (RegExp["$2"]) {
                    case "5.0":
                        system.win = "2000";
                        break;
                    case "5.1":
                        system.win = "XP";
                        break;
                    case "6.0":
                        system.win = "Vista";
                        break;
                    case "6.1":
                        system.win = "7";
                        break;
                    default:
                        system.win = "NT";
                        break;
                }
            } else if (RegExp["$1"] == "9x") {
                system.win = "ME";
            } else {
                system.win = RegExp["$1"];
            }
        }
    }

    //mobile devices
    system.iphone = ua.indexOf("iPhone") > -1;
    system.ipod = ua.indexOf("iPod") > -1;
    system.ipad = ua.indexOf("iPad") > -1;
    system.nokiaN = ua.indexOf("NokiaN") > -1;

    //windows mobile
    if (system.win == "CE") {
        system.winMobile = system.win;
    } else if (system.win == "Ph") {
        if (/Windows Phone OS (\d+.\d+)/.test(ua)) {;
            system.win = "Phone";
            system.winMobile = parseFloat(RegExp["$1"]);
        }
    }


    //determine iOS version
    if (system.mac && ua.indexOf("Mobile") > -1) {
        if (/CPU (?:iPhone )?OS (\d+_\d+)/.test(ua)) {
            system.ios = parseFloat(RegExp.$1.replace("_", "."));
        } else {
            system.ios = 2; //can't really detect - so guess
        }
    }

    //determine Android version
    if (/Android (\d+\.\d+)/.test(ua)) {
        system.android = parseFloat(RegExp.$1);
    }

    //gaming systems
    system.wii = ua.indexOf("Wii") > -1;
    system.ps = /playstation/i.test(ua);

    //return it
    return {
        engine: engine,
        browser: browser,
        system: system
    };

}


/****************************************************************
 * 修改 2015-08-10 charset utf-8
 *
 * DOM操作
 ****************************************************************/


/**
 * [viewPortSize 网页区域的宽度,减去了工具栏的宽度和高度]
 * @return {[String]} [字符串格式的宽度和高度]
 */
function viewPortSize() {
    // IE9+ 等主流浏览器
    var pageWidth = window.innerWidth,
        pageHeight = window.innerHeight;

    // IE8和以下浏览器
    if (typeof pageWidth != 'number') {
        // 标准模式
        if (document.compatMode == 'CSS1Compat') {
            pageWidth = document.documentElement.clientWidth;
            pageHeight = document.documentElement.clientHeight;
        } else {
            // 混杂模式
            pageWidth = document.body.clientWidth;
            pageHeight = document.body.clientHeight;
        }
    }

    return '视口宽度' + pageWidth + ' 视口宽度' + pageHeight
}

/**
 * [scrollOffset 窗口滚动条的偏移量]
 * @param  {[type]} obj [description]
 * @return {[type]}   [description]
 */
function scrollOffset(obj) {
    var w = obj || window;
    // 使用指定窗口，不带参数则为当前窗口
    // 除IE8和之前浏览器都支持
    if (w.pageXOffset != null) {
        return '左偏移量：' + w.pageXOffset + '上偏移量：' + w.pageYOffset;
    }

    // 标准模式的IE 或者任何浏览器
    var d = w.document;
    if (document.compatMode == 'CSS1Compat') {
        return '左偏移量：' + d.documentElement.scrollLeft + '上偏移量：' + d.documentElement.scrollTop;
    } else {
        return '左偏移量：' + d.body.scrollLeft + '上偏移量：' + d.body.scrollTop;
    }
}
/**
 * [screenWidthHeight 获取屏幕的宽度和高度，屏幕的可用宽度和可用高度]
 * @return {[String]} [字符串]
 */
function screenWidthHeight() {
    var availW = screen.availWidth,
        availH = screen.availHeight,
        w = screen.width,
        h = screen.height;

    var str = '可用的宽度: ' + availW + '可用的高度: ' + availH + '\n' + '屏幕宽度: ' + w + '屏幕高度: ' + h
    return str;
}

/**
 * [getQueryStringArgs 查询字符串参数]
 * @return {[type]} [返回一个保存了值的对象]
 */
function getQueryStringArgs() {
    // 取得字符串，并去掉开头的问号。
    var qs = location.search.length > 0 ? location.search.substring(1) : '';
    // 保存数据的对象
    var o = {},
        // 每条数据项
        item,
        name,
        value,
        // 将字符串分割成数组
        qsArray = qs.split('&');

    for (var i = 0, len = qsArray.length; i < len; i++) {
        item = qsArray[i].split('=');
        name = decodeURIComponent(item[0]);
        value = decodeURIComponent(item[1]);

        if (name.length) {
            o[name] = value;
        }
    }
    return o;
};

/**
 * [isHostMethod 目前可靠的能力检测,确定对象是否具有某个属性]
 * @param  {[type]}  obj [对象]
 * @param  {[type]}  pro [属性]
 * @return {Boolean}     [布尔值]
 * 
 * typeof document.createElement在IE8中和之前返回的是object而不是function
 * IE的typeof xhr.open返回unknown
 * 
 * 实例
 * console.log(isHostMethod(document,'createElement'));
 */
function isHostMethod(obj, pro) {
    var t = typeof obj[pro];

    return t == 'function' || (!!(t == 'object' && obj[pro])) || t == 'unknown';
};

/**
 * [eventUtil 事件相对操作]
 * @return {[Object]} [返回一个对象]
 */
function eventUtil() {
    return {
        // 添加事件
        addHandler: function(ele, type, handler) {
            if (ele.addEventListener) {
                // 冒泡
                ele.addEventListener(type, handler, false);
            } else if (ele.attachEvent) {
                ele.attachEvent('on' + type, handler);
            } else {
                ele['on' + type] = handler;
            }
        },
        // 移除事件
        removeHandler: function(ele, type, handler) {
            if (ele.removeEventListener) {
                ele.removeEventListener(type, handler, false);
            } else if (ele.detachEvent) {
                ele.detachEvent('on' + type, handler);
            } else {
                ele['on' + type] = null;
            }
        },
        //获取事件对象
        getEvent: function(event) {
            return event ? event : window.event;
        },
        // 获取事件的目标
        getTarget: function(event) {
            return event.target || event.srcElement;
        },
        // 阻止默认行为
        preventDefault: function(event) {
            if (event.preventDefault) {
                event.preventDefault();
            } else {
                // IE阻止默认行为
                event.returnValue = false;
            }
        },
        // 阻止冒泡
        stopPropagation: function(event) {
            if (event.stopPropagation) {
                event.stopPropagation();
            } else {
                // IE取消冒泡
                event.cancelBubble = true;
            };
        },
        // 页面坐标位置
        pageX: function(event) {
            var pageX = event.pageX;
            if (pageX === undefined) {
                pageX = event.clientX + (document.documentElement.scrollLeft || document.body.scrollLeft);
            }
            return pageX;
        },
        pageY: function(event) {
            var pageY = event.pageY;
            if (pageY === undefined) {
                pageY = event.clientY + (document.documentElement.scrollTop || document.body.scrollTop);
            }
            return pageY;
        },
        // 获取相关元素
        getRelatedTarget: function(event) {
            if (event.relatedTarget) {
                return event.relatedTarget;
            } else if (event.toElement) {
                // IE8和以下
                return event.toElement;
            } else if (event.fromElement) {
                return event.fromElement;
            } else {
                return null;
            }
        },
        // 是否按住了功能键
        getCtrlAltShift: function(event) {
            var keys = [];
            if (event.shiftKey) {
                keys.push('shift');
            }

            if (event.ctrlKey) {
                keys.push('ctrl');
            }

            if (event.altKey) {
                keys.push('alt');
            }
            // windows键有些浏览器不兼容
            if (event.metaKey) {
                keys.push('meta');
            }

            return keys;
        },
        // 鼠标按钮
        getButton: function(event) {
            if (document.implementation.hasFeature('MouseEvents', '2.0')) {
                return event.button;
            } else {
                // IE8和以下
                switch (event.button) {
                    case 0:
                    case 1:
                    case 3:
                    case 5:
                    case 7:
                        return 0;
                    case 2:
                    case 6:
                        return 2;
                    case 4:
                        return 1;
                }
            }
        },
        // 鼠标滚轮事件
        // 实例：
        // var eventObj = eventUtil();
        // function handlerMouseWheel(event) {
        //     var e = eventObj.getEvent(event);
        //     console.log(eventObj.getWheelDelta(e));
        // }
        // eventObj.addHandler(document,'mousewheel',handlerMouseWheel);
        // eventObj.addHandler(document,'DOMMouseScroll',handlerMouseWheel);

        getWheelDelta: function(event) {
            if (event.wheelDelta) {
                var client = clientCheck();
                // opera9.5以下版本 正负号颠倒
                return (client.engine.opera && client.engine.opera < 9.5) ? -event.wheelDelta : event.wheelDelta;
            } else {
                // 
                return -event.detail * 40;
            }
        },
        // 获取字符编码
        getCharCode: function(event) {
            // IE9 火狐 chrome safari 都支持一个charCode属性
            // 并且这个属性只发生在keypress事件中
            // IE8和opera之前版本保存在keyCode中
            // 火狐里面enter键keypress事件为的charCode为0,其他浏览器为13
            if (typeof event.charCode == "number") {
                return event.charCode;
            } else {
                return event.keyCode;
            }
        }
    };
};


/**
 * [convertToArray 将nodelist节点转换成数组]
 * @param  {[Object]} nodeList [节点对象]
 * @return {[Array]}          [数组]
 */
function convertToArray(nodeList) {
    var array = null;
    try {
        // 针对非IE
        array = Array.prototype.slice.call(nodeList, 0);
    } catch (e) {
        array = new array();
        // IE8和之前浏览器是com对象
        for (var i = 0, len = nodeList.length; i < len; i++) {
            array.push(nodeList[i]);
        }
    }
    return array;
}

/**
 * [judgePreNextSelf 可以判断当前节点是否为唯一的节点]
 * @param  {[type]} ele [子节点对象]
 * @return {[type]}     [没有返回值]
 */
function judgePreNextSelf(ele) {
    if (ele.nextSibling === null) {
        alert('我是最后一个节点！');
    }
    if (ele.previousSibling === null) {
        alert('我是第一个节点！');
    }
    if (ele.nextSibling === ele.nextSibling) {
        alert('当前只有一个子节点!');
    }
}

/**
 * [judgeFirstLast 可以判断当前节点是否为唯一的节点]
 * @param  {[type]} ele [父节点对象]
 * @return {[type]}     [没有返回值]
 */
function judgeFirstLast(ele) {
    // 判断方法一
    if (ele.firstChild === ele.lastChild && ele.firstChild !== null) {
        alert('当前只有一个子节点！');
    }
    // 判断方法二
    if (ele.childNodes[0] === ele.childNodes[ele.childNodes.length - 1] && ele.firstChild !== null) {
        alert('当前只有一个子节点！');
    }

    // 没有子节点的时候
    if (ele.firstChild === null && ele.lastChild === null) {
        alert('当前元素没有子节点');
    }
}

/**
 * [outputAttributes 遍历元素的属性]
 * @param  {[Object]} ele [元素对象]
 * @return {[type]}     [返回用空格隔开的字符串]
 *
 * 实例
 * console.log(outputAttributes($('wrap')));
 */
function outputAttributes(ele) {
    var keyValue = new Array(),
        attrName, attrValue, i, len;

    for (i = 0, len = ele.attributes.length; i < len; i++) {
        // ele.attributes[i] 有属性nodeName表示属性名字
        // ele.attributes[i] 有属性nodeValue表示属性值
        attrName = ele.attributes[i].nodeName;
        attrValue = ele.attributes[i].nodeValue;

        // specified表示设置过的属性为true 没有设置过的属性为false
        // 为了兼容IE7和以下
        if (ele.attributes[i].specified) {
            keyValue.push(attrName + "=\"" + attrValue + "\"");
        }
    }
    return keyValue.join(' ');
}

/****************************************************************
 * 2015-07-29备份 charset utf-8
 ****************************************************************/

/**
 * [fixedTop 固定在最上方的导航]
 * @param  {[type]} ele [对象]
 * @return {[type]}     [没有返回值]
 */
function fixedTop(ele) {
    ele.style.top = (document.documentElement.scrollTop || document.body.scrollTop) + 'px';
}

/**
 * [abs 求绝对值]
 * @param  {[number]} x [数值类型]
 * @return {[number]}   [number]
 */
function abs(x) {
    if (x >= 0) {
        return x;
    } else {
        return -x;
    }
}

/**
 * [factorial 第一个计算阶乘的方法]
 * @param  {[type]} x [description]
 * @return {[type]}   [description]
 */
function factorial(x) {
    if (x == 1) {
        return 1;
    }

    return x * arguments.callee(x - 1);
}

function factorial2(x) {
    var result = 1;
    while (x > 1) {
        result *= x;
        x--;
    }

    return result;
}

function factorial3(x) {
    var result = 1;
    for (var i = 1; i <= x; i++) {
        result *= i;
    }
    return result;
}



/****************************************************************
 * 2015-08-06 charset utf-8
 ****************************************************************/

/**
 * [getStyle 获取计算出来的样式]
 * @param  {[type]} obj  [元素对象]
 * @param  {[type]} attr [属性名]
 * @return {[type]}      [对应属性名的值]
 */
function getStyle(obj, attr) {
    /*兼容IE678*/
    if (obj.currentStyle) {
        // IE
        return obj.currentStyle[attr];
    } else {
        // 其他
        return getComputedStyle(obj, false)[attr];
    }
}

/**
 * [startMove 完美运动框架缓冲运动]
 * @param  {[Ojbect]} obj    [description]
 * @param  {[Ojbect json]} jsonObj [json对象]
 * @return {[type]}        [没有返回值]
 */
function startMove(obj, jsonObj, fn) {
    clearInterval(obj.timer);

    obj.timer = setInterval(function() {
        // 用来存标记
        var array = [];
        // 开始设都没有达到目标点
        var flag = false;
        for (var attr in jsonObj) {
            // 获取当前值
            if (attr == 'opacity') {
                // 因为opacity是小数，所以用 parseFloat
                // 用parseFloat之后会出现，52.00000000000001的情况，所以要加上Math.round
                // 这里很奇怪 parseInt(parseFloat(getStyle(obj, attr) * 100));在谷歌里面不兼容
                // 其他浏览器都得到了很好的兼容
                var curr = Math.round(parseFloat(getStyle(obj, attr) * 100));

            } else {
                var curr = parseInt(getStyle(obj, attr));
            };

            // 求速度 
            var speed = (jsonObj[attr] - curr) / 6;
            speed = speed > 0 ? Math.ceil(speed) : Math.floor(speed);


            if (attr == 'opacity') {
                obj.style.opacity = (curr + speed) / 100;
                obj.style.filter = 'alpha(opacity=' + (curr + speed) + ')';
            } else {
                obj.style[attr] = (curr + speed) + 'px';
            };

            // 检测停止 
            if (jsonObj[attr] == curr) {
                flag = true;
            } else {
                flag = false;
            }


            array.push(flag);

        };

        // console.log(array);

        for (var i = 0, len = array.length; i < len; i++) {
            // 在这个数组里面只要有一个false就把标记flag设为false
            if (array[i] == false) {
                flag = false;
            }
        }

        // 清除定时器
        if (flag) {
            clearInterval(obj.timer);
            if (fn) {
                fn();
            }
        }

        // console.log('width' + ": " + parseInt(getStyle(obj, 'width')));
        console.log('height' + ": " + parseInt(getStyle(obj, 'height')));
        // console.log('opacity' + ": " + Math.round(parseFloat(getStyle(obj, 'opacity') * 100)));
        // console.log('fontSize' + ": " + parseInt(getStyle(obj, 'fontSize')));
    }, 30);
}


function uniformMove(obj, json, speed, fn) {
    // 速度
    // var speed = speed;

    clearInterval(obj.timer);
    obj.timer = setInterval(function() {
        var flag = false;
        var array = [];
        for (var attr in json) {
            // 取值
            if (attr == 'opacity') {
                var curr = Math.round(parseFloat(getStyle(obj, attr)) * 100);
            } else {
                var curr = parseInt(getStyle(obj, attr));
            }

            // 当最后一次的运动不足用来加speed的时候，直接运动到结束
            if (Math.abs(json[attr] - curr) < Math.abs(speed)) {
                if (attr == 'opacity') {
                    obj.style.opacity = json[attr] / 100;
                    obj.style.filter = 'alpha(opacity=' + json[attr] + ')';
                } else {
                    obj.style[attr] = json[attr] + 'px';
                };
            } else {
                if (attr == 'opacity') {
                    obj.style.opacity = (curr + speed) / 100;
                    obj.style.filter = 'alpha(opacity=' + (curr + speed) + ')';
                } else {
                    obj.style[attr] = (curr + speed) + 'px';
                };
            };


            if (curr == json[attr]) {
                flag = true;
            } else {
                flag = false;
            };

            array.push(flag);

        };

        // 检测停止
        for (var i = 0, len = array.length; i < len; i++) {
            if (array[i] == false) {
                flag = false;
            }
        };

        if (flag == true) {
            clearInterval(obj.timer);
            if (fn) {
                fn();
            }
        };
        // console.log('width' + ": " + parseInt(getStyle(obj, 'width')));
        // console.log('height' + ": " + parseInt(getStyle(obj, 'height')));
        // console.log('opacity' + ": " + Math.round(parseFloat(getStyle(obj, 'opacity') * 100)));
        // console.log('fontSize' + ": " + parseInt(getStyle(obj, 'fontSize')));
        console.log(parseFloat(getStyle(obj, 'opacity')));
    }, 30);
}


/****************************************************************
 * 2015-08-10 charset utf-8
 * string 拓展
 ****************************************************************/

/**
 * [trim 清除字符串两边的空格]
 * @return {[String]} [清除了两边空格的字符串]
 */
String.prototype.trim = function() {
    return this.replace(/(^\s*)|(\s*$)/g, '');
};

/**
 * [resetBlank 合并多个空格为一个空格  ]
 * @return {[type]} [description]
 */
String.prototype.resetBlank = function() {
    return this.replace(/\s+/g, ' ');
};

/**
 * [onlyRetain 只保留字符串中的数字]
 * @return {[type]} [description]
 */
String.prototype.onlyRetainNum = function() {
    return this.replace(/[^\d]/g, '');
};

/**
 * [onlyRetainCH 只保留中文]
 * @return {[type]} [description]
 */
String.prototype.onlyRetainCH = function() {
    return this.replace(/[^\u4e00-\u9fa5\uf900-\ufa2d]/g, '')
};


/****************************************************************
 * 工具函数
 * 2015-08-11 charset utf-8
 * 查询属性
 ****************************************************************/

/**
 * [queryPro description]
 * @param  {[type]} obj [description]
 * @return {[type]}     [description]
 */
function queryPro(obj) {
    return {
        /**
         * 检测属性还有以下方法
         * 1.in   pro in obj 自有属性或者继承属性中包含则返回true
         * 2.hasOwnProperty obj.hasOwnProperty(pro) 只检测自有属性,继承属性返回false
         * 3.propertyIsEnumerable obj.propertyIsEnumerable(pro) 自有属性，并且可以枚举
         *
         * for(o in obj){
         *     //跳过继承的属性
         *     if(!obj.hasOwnProperty(o)) continue;
         * }
         *
         * for(o in obj){
         *     //跳过方法,不显示方法
         *     if(typeof obj[o] == 'function') continue;
         * }
         * 
         */

        /**
         * [selfAblePro 遍历可枚举的自身属性
         * 可枚举的意思就是该属性的[[Enumerable]]特性为true,自身属性的意思就是该属性不是从原型链上继承下来的.]
         * @return {[type]} [description]
         */
        selfAblePro: function() {
            var pro = Object.keys(obj);
            console.log(pro.join('\n'));
        },
        /**
         * [selfPro 遍历所有的自身属性]
         * 特性为不可枚举的属性也并不是遍历不到,ES5给我们提供了getOwnPropertyNames方法,可以获取到一个对象的所有自身属性.
         * @return {[type]} [description]
         */
        selfPro: function() {
            var pro = Object.getOwnPropertyNames(obj);
            console.log(pro.join('\n'));
        },
        /**
         * [selfExtendsAblePro 遍历可枚举的自身属性和继承属性]
         * 继承属性怎么遍历,你应该知道,就是最常用的for in遍历
         * @return {[type]} [description]
         */
        selfExtendsAblePro: function() {
            var arr = [];
            for (var pro in obj) {
                arr.push(pro);
            }
            console.log(arr.join('\n'));
        },
        /**
         * [selfExtendsAllPro 遍历所有的自身属性和继承属性]
         * 这种遍历主要用在各种js调试工具的代码补全功能上.比如Firebug的.
         * @return {[type]} [description]
         */
        selfExtendsAllPro: function() {
            var arr = [];
            do {
                arr = arr.concat(Object.getOwnPropertyNames(obj));
                // obj的原型对象 就是被继承的对象
                // 原型的原型 就是被继承的被继承对象
            } while (obj = Object.getPrototypeOf(obj));

            console.log(arr.join('\n'));
        }
    };
};

/****************************************************************
 * 对象操作 
 * 2015-08-12 charset utf-8
 * 
 ****************************************************************/

/**
 * [createObj 创建对象]
 * @param  {[type]} obj [对象，或者函数]
 * @return {[type]}     [返回一个新的对象]
 */
function createObj(obj) {
    // obj必须是对象，但是不能为null
    // Object.create(Object.prototype);和{},new Object()等价
    // Object.create()传入的对象作为新对象的原型
    if (obj == null) throw TypeError();
    if (Object.create) return Object.create(obj);

    var t = typeof obj;
    // 如果不是对象，或者函数则报错
    if (t !== 'object' && t !== 'function') throw TypeError();

    function f() {};
    // 将原型属性设置为obj
    f.prototype = obj;
    // 创建p的继承对象
    return new f();
}


/****************************************************************
 * 数组操作 
 * 2015-08-13 charset utf-8
 ****************************************************************/

/**
 * [clear 清空数组]
 * @return {[type]} [description]
 */
Array.prototype.clear = function() {
    this.length = 0;

    // 两种清空数组的效率对比,直接将数组设置为空效率更加的高
    // 方式2，赋值为[] var ary = [1,2,3,4]; ary = []; 
    // var a = [];
    // for (var i = 0; i < 1000000; i++) {
    //     a.push(i);
    // }
    // var start = new Date();
    //a = []; a.length = 0; var end = new Date(); alert(end - start);
};

/**
 * [selfIndexOf 判断数据项在数组中的位置]
 * @param  {[type]} obj [被判断的元素]
 * @param  {[type]} from [初始位置]
 * @return {[type]}     [返回位置]
 */

Array.prototype.selfIndexOf = function(obj /*,from*/ ) {
    var that = this;
    var from = arguments[1] || 0;
    if (!Array.prototype.indexOf) {
        return (function(obj) {
            for (var i = from, len = that.length; i < len; i++) {
                if (that[i] == obj) {
                    return i;
                }
            }
            // 没有找到返回-1
            return -1;
        })(obj);
    } else {
        return this.indexOf(obj, from);
    }
};


/**
 * [numberOrder 数组排序大到小排序]
 * @param  {[type]} a [description]
 * @param  {[type]} b [description]
 * @return {[type]}   [description]
 *
 * var arr = ['A','a','nihao']
 * alert(arr.sort(numberOrder));
 * 
 */
function numberOrder(a, b) {
    // 数值从大到小排序
    // arr.sort() 字母表排序
    return a - b;
}

function letterOrder(a, b) {
    // 数值从大到小排序
    // arr.sort();区分大小写 Dog,dog,ant,act
    var a = a.toLowerCase();
    var b = b.toLowerCase();

    if (a > b) return 1;
    if (a < b) return -1;
    return 0;
}

/**
 * [isArrayLike 判断是否是一个类数组对象]
 * @param  {[type]}  obj [传入的]
 * @return {Boolean}     [是类数组返回true,否则返回false]
 */
function isArrayLike(obj) {
    // 不能是null undefined
    if (obj &&
        // 必须是对象 alert(typeof array); 返回object 
        typeof obj == 'object' &&
        // 是个有限数字
        isFinite(obj.length) &&
        // 长度大于等于0
        obj.length >= 0 &&
        // 必须是整数
        obj.length === Math.floor(obj.length) &&
        // 小于数组的最大长度
        obj.length < 4294967296
    ) {
        return true;
    } else {
        return false;
    }
};

/**
 * [isFunction 判断是否是一个函数]
 * @param  {[type]}  obj [description]
 * @return {Boolean}     [description]
 */
function isFunction(obj) {
    return Object.prototype.toString.call(obj) === '[object Function]';
}

/**
 * [isArray 判断是否是一个数组]
 * @param  {[type]}  obj [description]
 * @return {Boolean}     [description]
 */
function isArray(obj) {
    return Object.prototype.toString.call(obj) === '[object Array]';
}


/****************************************************************
 * DOM操作 
 * 2015-08-17 charset utf-8
 * 
 ****************************************************************/

/**
 * [loadasync 从指定的url异步加载脚本]
 * @param  {[type]} url [description]
 * @return {[type]}     [description]
 */
function loadasync(url) {
    var head = document.getElementsByTagName('head')[0];
    var s = document.createElement('script');
    s.src = url;
    head.appendChild(s);
}

/**
 * [textContent 获取文本内容]
 * @return {[type]} [description]
 */
function textContent(obj) {
    return obj.textContent || obj.innerText;
}


/**
 * [documentFragment 倒序排列子节点]
 * @param  {[type]} obj [等待排序的节点对象]
 * @return {[type]}     [description]
 */
function documentFragment(obj) {
    var f = document.createDocumentFragment();
    // 从后面循环把obj对象的节点放到f中
    // obj的最后一个节点变成f的第一个节点
    // 给f添加节点,obj中的节点会自动删除
    while (obj.lastChild) {
        f.appendChild(obj.lastChild)
    }
    // 最后把f的所有节点一次性全部移回到obj中
    obj.appendChild(f);
}

/**
 * [getElementPosition 求出offsetLeft的值]
 * @param  {[type]} obj [description]
 * @return {[type]}     [description]
 */
function getElementPosition(obj) {
    var x = 0,
        y = 0;
    //当 offsetParent为null的时候,这些属性都是文档坐标
    while (obj != null) {
        x += obj.offsetLeft;
        y += obj.offsetTop;
        obj = obj.offsetParent;
    }
    return {
        x: x,
        y: y
    };

}