封装一些常用的方法——持续更新

/* 检测数据类型 */
let class2type = {};
let toString = class2type.toString;
"Boolean Number String Function Array Date RegExp Object Error Symbol".split(" ").forEach(item => {
    class2type["[object " + item + "]"] = item.toLowerCase();
});

function toType(obj) {
    if (obj == null) {
        return obj + "";
    }
    return typeof obj === "object" || typeof obj === "function" ?
        class2type[toString.call(obj)] || "object" :
        typeof obj;
}
/* 深克隆 */
function _cloneDeep(obj) {
    if (obj === null) return null;
    if (typeof obj !== "object") return obj;
    if (obj instanceof RegExp) return new RegExp(obj);
    if (obj instanceof Date) return new Date(obj);
    let cloneObj = new obj.constructor;
    for (let key in obj) {
        if (!obj.hasOwnProperty(key)) break;
        cloneObj[key] = _cloneDeep(obj[key]);
    }
    return cloneObj;
}
/* 深度替换 */
function _assignDeep(obj1, obj2) {
    let obj = _cloneDeep(obj1);
    for (let key in obj2) {
        if (!obj2.hasOwnProperty(key)) break;
        let v2 = obj2[key],
            v1 = obj[key];
        if (typeof v1 === "object" && typeof v2 === "object") {
            obj[key] = _assignDeep(v1, v2);
            continue;
        }
        obj[key] = v2;
    }
    return obj;
}
/** 
 * 检测是否是数组和类数组
*/
function isArrayLike(obj) {
    let length = !!obj && ("length" in obj) && obj.length;
    return Array.isArray(obj) || length === 0 || (typeof length === "number" && length > 0 && (length - 1) in obj)
}

/*
 *方法名：_EACH([VALUE],[CALLBACK],[CONTEXT])
 *功能：
 *1.可以遍历数组、类数组、对象，每一次遍历都可以把[CALLBACK]执行
 *2.每一次执行回调函数，都会把当前遍历的结果（当前项\索引）传递给回调函数
 *3.支持第三个参数，用来改变回调函数中的THIS指向(不传递，默认是WINDOW)
 *4.支持回调函数返回值，每一次返回的值会把当前集合中的这一项的值替换掉；如果回调函数返回的是FALSE（一定是FALSE），则结束遍历；
 *
 *   @params
 *      obj:要迭代的数组、类数组、对象
 *      callback:每一次迭代触发执行的回调函数
 *      context:要改变的回调函数的THIS
 *   @return 
 *      返回处理后的新数组/对象
 */
function _each(obj, callback, context) {
    obj = _cloneDeep(obj);
    if (obj === null) throw new TypeError('obj必须是一个对象/数组/类数组');
    if (typeof obj !== "object") throw new TypeError('obj必须是一个对象/数组/类数组');
    if (typeof callback !== "function") throw new TypeError('callback必须是一个函数');

    if (isArrayLike(obj)) {
        for (let i = 0; i < obj.length; i++) {
            let res = callback.call(context, obj[i], i);
            if (res === false) { break; }
            if (res !== undefined) { obj[i] = res };
        }
    } else {
        for (let key in obj) {
            if (!obj.hasOwnProperty(key)) break;
            let res = callback.call(context, obj[key], key);
            if (res === false) break;
            if (res !== undefined) obj[key] = res;
        }
    }
    return obj;
    
}
/*获取当前元素到body的偏移量*/
  function offset(ele){
    let l = ele.offsetLeft,
        t = ele.offsetTop;// 获取当前元素到父级参照物的偏移量
    let parent = ele.offsetParent;// 获取父级参照物 
    while(parent){
      // 若父级参照物存在；
      l += (parent.clientLeft||0) + parent.offsetLeft;
      t += (parent.clientTop||0) + parent.offsetTop;
      parent = parent.offsetParent;
    }  
    return {
      l,t
    }
  }
``