自己封装的几个函数

//判断arr是否为一个数组，返回一个bool值
    function isArray(arr) {
        return Object.prototype.toString.call(arr) === '[object Array]';
    }

---

// 判断fn是否为一个函数，返回一个bool值
    function isFunction(fn) {
        return Object.prototype.toString.call(fn) === '[object Function]';
        return fn.constructor == Function;
        return fn instanceof Function;
        return typeof(fn)==function;
    }

---

// 使用递归来实现一个深度克隆，可以复制一个目标对象，返回一个完整拷贝
// 被复制的对象类型会被限制为数字、字符串、布尔、日期、数组、Object对象。不会包含函数、正则对象等
    function cloneObject(obj) {
     // Handle the 3 simple types, and null or undefined,number,string,boolean
    if (obj == null || typeof obj != "object") return obj;

    // Handle Date
    if (obj instanceof Date) {
        var copy = new Date();
        copy.setTime(obj.getTime());
        return copy;
    }

    // Handle Array[1,2,3,4,5] length=5
    if (obj instanceof Array) {
        var copy = [];
        for (var i = 0; i < obj.length; i++) {
            copy[i] = cloneObject(obj[i]);
        }
        return copy;
    }

    // Handle Object
    if (obj instanceof Object) {
        var copy = {};
        for (var attr in obj) {
            if (obj.hasOwnProperty(attr)) {
                copy[attr] = cloneObject(obj[attr]);
            }
        }
        return copy;
    }

    throw new Error("Unable to copy obj! Its type isn't supported.");
    }

// 测试用例：
var srcObj = {
    a: 1,
    b: {
        b1: ["hello", "hi"],
        b2: "JavaScript"
    }
};
var abObj = srcObj;
var tarObj = cloneObject(srcObj);

srcObj.a = 2;
srcObj.b.b1[0] = "Hello";

console.log(abObj.a);//2
console.log(abObj.b.b1[0]);//Hello

console.log(tarObj.a);      // 1
console.log(tarObj.b.b1[0]);    // "hello"

---

// 对数组进行去重操作，只考虑数组中元素为数字或字符串，返回一个去重后的数组

    function uniqArray(arr) {
        //var arr=[1,2,3,4,5,4,3,2];
        var arr2=[];
        for(var i=0;i<arr.length;i++){
            for(var j=0;j<arr2.length;j++){
              if(arr[i]==arr[j]){
              break;
              }
            }
        if(j==arr2.length){
            arr2.push(arr[i]);
        }

        }
    return(arr2);
    }

---

// 对字符串头尾进行空格字符的去除、包括全角半角空格、Tab等，返回一个字符串
// 本例使用正则表达式
    function trim(str){
        return str.replace(/^[" "||"　"]*/,"").replace(/[" "|"　"]*$/, "");
    }

---

// 实现一个遍历数组的方法，针对数组中每一个元素执行fn函数，并将数组索引和元素作为参数传递
// 其中fn函数可以接受两个参数：item和index
    function output(item, index) {

        console.log(index + ': ' + item)

    }
    function each(arr,output){
        for(var i=0;i<arr.length;i++){

            var item=arr[i];
            var index=i;
            output(item,index);
        }

    }
    //写在原型方法里
    Object.prototype.each=function(output){
        for(var i=0;i<this.length;i++){

            var item=this[i];
            var index=i;
            output(item,index);
        }

    }

---

// 获取一个对象里面第一层元素的数量，返回一个整数
function getObjectLength(obj){
    var i=0;
    for( var attr in obj){
        if(obj.hasOwnProperty(attr)){
            i++;
        }
    }
    console.log(i);
}

---

// 判断是否为邮箱地址
    function isEmail(emailStr){
        var reg=/^[a-zA-Z0-9]+([._-]*[a-zA-Z0-9]*)*@[a-zA-Z0-9]+.[a-zA-Z0-9{2,5}$]/;
        var result=reg.test(emailStr);
        if(result){
            alert("ok");
        }else{
            alert("error");
    }

    }

---

// 判断是否为手机号 /^1[0-9]{10}/
    function isMobilePhone(phone){
        var reg=/^1\d{10}$/;
        if(reg.test(phone)){
            alert('ok');
        }else{
            alert('error');
        }
    }

---

//为element增加一个样式名为newClassName的新样式
    function addClass(element, newClassName){
        if (!element.className){ 
            element.className = newClassName; 
        }

            var reg=new RegExp('(\\s|^)'+newClassName+'(\\s|$)');
            var str=element.className.toString();
            // console.log(reg.test(str));
            var bool=reg.test(str);
        if(bool){
            return;
        }



        else { 
            aa = element.className; 
            aa+= " "; 
            aa+= newClassName ; 
            element.className = aa;
        }

    }

---

// 移除element中的样式oldClassName
    function removeClass(element, oldClassName){
            var reg=new RegExp('(\\s+|^)'+oldClassName+'(\\s+|$)');
            console.log(reg.test(element.className));
            if(reg.test(element.className)){
                element.className = element.className.replace(reg,' ');
            }
        }

---

// 判断siblingNode和element是否为同一个父元素下的同一级的元素，返回bool值

        function isSiblingNode(element, siblingNode){
            var arr=element.parentNode.childNodes;
            for(var i=0;i<arr.length;i++){
                if(arr[i]==siblingNode){
                    return(console.log('1'));
                }
            }
            return(console.log('2'));
        }

---

//获取element相对于浏览器窗口的位置，返回一个对象{x, y}
        function getPosition(element){
            var offsety=0;
            offsety+=element.offsetTop;
            var offsetx=0;
            offsetx+=element.offsetLeft;
            if(element.offsetParent!=null){
                getPosition(element.offsetParent);
            }
            return {Left:offsetx,Top:offsety};
        }