javascript实用代码片段

持续积累中~

拓展原型

Function.prototype.method = function(name, extend) {
  if(!this.prototype[name]) {
    this.prototype[name] = extend;
  }
  return this;
}

实现继承·方法1

Function.method("inherits", function(Parent) {
  var _proptotype = Object.create(Parent.prototype);
  _proptotype.constructor = this.prototype.constructor;
  this.prototype = _proptotype;
  return this;
})

实现继承·方法2

function inherits(child, parent) {
    var _proptotype = Object.create(parent.prototype);
    _proptotype.constructor = child.prototype.constructor;
    child.prototype = _proptotype;
    return {
        "child": child,
        "parent": parent
    };
}

实现继承·方法3

//只创建临时构造函数一次
var inherit = (function () {
    var F = function () {};
    return function (C, P) {
        F.prototype = P.prototype;
        C.prototype = new F();
        C.uber = P.prototype;           // 存储超类
        C.prototype.constructor = C;     // 重置构造函数指针
   }
})();

浅拷贝

function simpleCopy() {
    var c = {};
    for(var i in p) {
        c[i] = p[i];
    }
    return c;
}

深拷贝

function deepCopy(p, c) {
    var c = c || {};
    for(var i in p) {
        if(typeof p[i] === 'object') {
            c[i] = (p[i].constructor === Array) ? [] : {};
            deepCopy(p[i], c[i]);
        } else {
            c[i] = p[i];
        }
    }
    return c;
}

带特性值的浅拷贝

function Composition(target, source){
    var desc = Object.getOwnPropertyDescriptor;
    var prop = Object.getOwnPropertyNames;
    var def_prop=Object.defineProperty;
    prop(source).forEach(function(key) {
        def_prop(target, key， desc(source, key))
    })
    return target;
}

mixin混合

function mix() {
    var arg, prop, child = {};
        for(arg = 0; arg < arguments.length; arg += 1) {
            for(prop in arguments[arg]) {
                if(arguments[arg].hasOwnProperty(prop)) {
                    child[prop] = arguments[arg][prop];
                }
            }
        }
        return child;
}

对象拓展

var MYAPP = MYAPP || {};
MYAPP.namespace = function(ns_string) {
    var parts = ns_string.split('.'),
        parent = MYAPP,
        i;
    //忽略第一个
    if(parts[0] === "MYAPP") {
        parts = parts.slice(1);
    }
    for(i = 0; i < parts.length; i += 1) {
        //如果属性不存在，就创建
        if(typeof parent[parts[i]] === "undefined") {
            parent[parts[i]] = {};
        }
        parent = parent[parts[i]];
    }
    return parent;
};
MYAPP.namespace('once.upon.a.time.there.was.this.long.nested.property');

函数柯里化(Currying)

function curry(fn){
    var args = Array.prototype.slice.call(arguments, 1);
    return function(){
         var innerArgs = Array.prototype.slice.call(arguments);
         var finalArgs = args.concat(innerArgs);
         return fn.apply(null, finalArgs);
    };
}
function add(num1, num2){
    return num1 + num2;
}
var curriedAdd = curry(add, 5);
alert(curriedAdd(3)); //8

函数节流

function throttle(fn, wait){
    var timer;
    return function(...args){
      if(!timer){
          timer = setTimeout(()=>timer=null, wait);
          return fn.apply(this, args);
      }
    }
}

函数防抖

function debounce(fn, delay){
    var timer = null;
    return function(...args){
        clearTimeout(timer);
        timer = setTimeout(() => fn.apply(this, args), delay);
    }
}

跨文件共享私有对象(模块互访)

var blogModule = (function(my) {
    var _private = my._private = my._private || {},
    _seal = my._seal = my._seal || function() {
        delete my._private;
        delete my._seal;
        delete my._unseal;
    },
    _unseal = my._unseal = my._unseal || function() {
        my._private = _private;
        my._seal = _seal;
        my._unseal = _unseal;
    };
    return my;
}(obj || {}));

类型判断

function isType(val, type) {
    val = Object.prototype.toString.call(val).toLowerCase();
    if(typeof(type) === "string") {
        return val === '[object ' + type.toLowerCase() + ']';
    }
    return val.replace(/(\[object\s)|(\])/g, "");
}

软绑定[默认绑定可设置]

    Function.prototype.softBind = function(obj) {
        var fn = this;
        // 捕获所有 curried 参数
        var curried = [].slice.call( arguments, 1 );
        var bound = function() {
              return fn.apply(
                    (!this || this === (window || global)) ?
                         obj : this
                    curried.concat.apply( curried, arguments )
              );
        };
        bound.prototype = Object.create( fn.prototype );
        return bound;
    };

js精度运算

var floatObj = function() {
    
    // 判断obj是否为一个整数
    function isInteger(obj) {
        return Math.floor(obj) === obj
    }
    
    /*
     * 将一个浮点数转成整数，返回整数和倍数。如 3.14 >> 314，倍数是 100
     * @param floatNum {number} 小数
     * @return {object}
     *   {times:100, num: 314}
     */
    function toInteger(floatNum) {
        var ret = {times: 1, num: 0}
        var isNegative = floatNum < 0
        if (isInteger(floatNum)) {
            ret.num = floatNum
            return ret
        }
        var strfi  = floatNum + ''
        var dotPos = strfi.indexOf('.')
        var len    = strfi.substr(dotPos+1).length
        var times  = Math.pow(10, len)
        var intNum = parseInt(Math.abs(floatNum) * times + 0.5, 10)
        ret.times  = times
        if (isNegative) {
            intNum = -intNum
        }
        ret.num = intNum
        return ret
    }
    
    /*
     * 核心方法，实现加减乘除运算，确保不丢失精度
     * 思路：把小数放大为整数（乘），进行算术运算，再缩小为小数（除）
     *
     * @param a {number} 运算数1
     * @param b {number} 运算数2
     * @param digits {number} 精度，保留的小数点数，比如 2, 即保留为两位小数
     * @param op {string} 运算类型，有加减乘除（add/subtract/multiply/divide）
     *
     */
    function operation(a, b, digits, op) {
        var o1 = toInteger(a)
        var o2 = toInteger(b)
        var n1 = o1.num
        var n2 = o2.num
        var t1 = o1.times
        var t2 = o2.times
        var max = t1 > t2 ? t1 : t2
        var result = null
        switch (op) {
            case 'add':
                if (t1 === t2) { // 两个小数位数相同
                    result = n1 + n2
                } else if (t1 > t2) { // o1 小数位 大于 o2
                    result = n1 + n2 * (t1 / t2)
                } else { // o1 小数位 小于 o2
                    result = n1 * (t2 / t1) + n2
                }
                return  digits ? (result / max).toFixed(digits) * 1 : Math.round(result / max)
            case 'subtract':
                if (t1 === t2) {
                    result = n1 - n2
                } else if (t1 > t2) {
                    result = n1 - n2 * (t1 / t2)
                } else {
                    result = n1 * (t2 / t1) - n2
                }
                return digits ? (result / max).toFixed(digits) * 1 : Math.round(result / max)
            case 'multiply':
                result = (n1 * n2) / (t1 * t2)
                return digits ? result.toFixed(digits) * 1 : Math.round(result)
            case 'divide':
                result = (n1 / n2) * (t2 / t1)
                return digits ? result.toFixed(digits) * 1 : Math.round(result)
        }
    }
    
    // 加
    function add(a, b, digits) {
        return operation(a, b, digits, 'add')
    }
    // 减
    function subtract(a, b, digits) {
        return operation(a, b, digits, 'subtract')
    }
    // 乘
    function multiply(a, b, digits) {
        return operation(a, b, digits, 'multiply')
    }
    // 除
    function divide(a, b, digits) {
        return operation(a, b, digits, 'divide')
    }
    
    return {
        add: add,
        subtract: subtract,
        multiply: multiply,
        divide: divide
    }
}();