YSL.extend.js

YSL.data.js

/**
 * 活动持续时间
 * 计算两个时间差
 * @param  {string} start 时间 格式:2015-09-07 15:53:00
 * @param  {string} end   时间 格式:2015-09-07 15:53:00
 * @return {string}       相差的时间戳
 */
function countContinuTime(start, end) {
    var startStamp = Math.floor(new Date(start).getTime() / 1000);
    var endStamp = Math.floor(new Date(end).getTime() / 1000);
    var now = Math.floor(new Date().getTime() / 1000);

    if (startStamp > endStamp) return false;
    //if (startStamp < now) return -1;

    var diff = endStamp - startStamp;
    return diffTime(diff);
}

/** 时间戳转时间 */
function diffTime(timestamp) {
    var days = Math.floor(timestamp / (60 * 60 * 24));
    timestamp = timestamp - (60 * 60 * 24) * days;
    var hours = Math.floor(timestamp / (60 * 60));
    timestamp = timestamp - (60 * 60) * hours;
    var minutes = Math.floor(timestamp / 60);
    timestamp = timestamp - 60 * minutes;
    var seconds = Math.floor(timestamp);
    return days + '天' + hours + '小时' + minutes + '分';
}

/**
 * LocalDateString convert to Datestring
 * 2015年9月7日 => 2015-09-07
 * @param  {string} dateString datestring
 * @param  {string} separator  分隔符 例如:'-'
 * @return {string}            转换后的时间
 */
function convDate(dateString, separator) {
    var reg = /(\d*)(年|月|日)/g;
    dateString = dateString.replace(reg, function(matched, p1, p2) {
        var ele = '';
        if (p1.length == 1) {
            p1 = '0' + p1;
        }
        if (p2 == '年' || p2 == '月') {
            ele = p1 + separator;
            return ele;
        } else {
            return p1;
        }
    });
    return dateString;
}

/** 格式化时间 */
function timeFormat(format, date)
{
    var strTime = '';
    if (! format) format = 'Y-m-d H:i:s';
    if (! date) date = new Date();
    strTime = format.replace(/Y|m|d|H|i|s/g, function(matched, index, stack){
        if (matched == 'Y') return date.getYear() + 1900;
        if (matched == 'y') return date.getYear();
        if (matched == 'm') return zeroPrefix(date.getMonth() + 1);
        if (matched == 'd') return zeroPrefix(date.getDate());
        if (matched == 'H') return zeroPrefix(date.getHours());
        if (matched == 'i') return zeroPrefix(date.getMinutes());
        if (matched == 's') return zeroPrefix(date.getSeconds());

        if (matched == 'h') // 返回12小时制  有前缀0
            return date.getHours() > 12 ? date.getHours() - 12 : date.getHours();
    });
    return strTime;
}
/** 延时 */
function timeDelay(delay, datetime)
{
    var reg = /^(\+|-) ?(\d+) ?(day|month|year|hours|minutes|seconds)$/;
    var method = [];
    // 获取时间
    if (typeof datetime != 'undefined') {
        try {
            datetime = new Date(datetime);
        } catch (e) {
            console.error(e);
            return false;
        }
    } else {
        datetime = new Date();
    }
    // 得到真实日期
    var dateMaps = timeGet(datetime);
    // 匹配词设置方法映射
    var funcMaps = {
        day: 'setDate',
        month: 'setMonth',
        year: 'setYear',
        hours: 'setHours',
        minutes: 'setMinutes',
        seconds: 'setSeconds'
    }

    var old = 0,
        add = 0,
        newTime = 0;
    if (delay) {
        method = delay.match(reg);
        add = parseInt(method[2]);
        newTime = method[1] == '+' ? dateMaps[method[3]] + add : dateMaps[method[3]] - add;
        datetime[funcMaps[method[3]]](newTime);
    }
    return datetime;
}
/** 获取真实时间属性映射 */
function timeGet(datetime)
{
    // 获取时间
    if (typeof datetime != 'undefined') {
        try {
            datetime = new Date(datetime);
        } catch (e) {
            console.error(e);
            return false;
        }
    } else {
        datetime = new Date();
    }
    return {
        day: datetime.getDate(),
        month: datetime.getMonth() + 1,
        year: datetime.getYear() + 1900,
        hours: datetime.getHours(),
        minutes: datetime.getMinutes(),
        seconds: datetime.getSeconds()
    };
}
/** 2位数0前缀补足 */
function zeroPrefix(val){
    val = val.toString().length == 1 ? '0' + val : val;
    return val;
}
/**
 * 格式化返回 延时时间
 *
 * 格式: Y-m-d H:i:s
 */
function timeString(delay, datetime)
{
    var delayTime = timeDelay(delay, datetime);
    return timeFormat('Y-m-d H:i:s', delayTime);
}

YSL.extend.js

/**
 * 合并扩展对象方法
 * @param  {Object|Array} object   要被合并的对象或对象数组
 * @param  {Boolean} override 相同对象的属性是否要重写
 * @param  {Boolean|Number} R     对象是否递归 如果为 true 则一直递归，为number则表明递归的深度
 * @return {null}          没有返回值
 */
Object.prototype.extend = function (object, override, R) {
    var that = this;
    if (typeof R != 'Number' || R !== true) R = 0;
    function ext(main, sub, override){
        // 判断是否为对象
        if (sub instanceof Object
            && sub.toString() == '[object Object]') {

            for (key in sub) {   // 迭代对象属性
                if (sub.hasOwnProperty(key)  // 为对象自身属性
                    && ((! main.hasOwnProperty(key))    // 主对象不存在此属性
                        || override)) {    //  或者 此对象可以被重写

                    if (main.hasOwnProperty(key)    // 如果主函数属性为对象 则递归合并
                        && main[key].toString() == '[object Object]'
                        && R) {
                        if (! R === true) R--; // 递归层数递减
                        ext(main[key], sub[key], override);
                    } else {
                        main[key] = sub[key];
                    }
                }
            }
        }
    }

    if (object instanceof Array) {
        object.map(function(val){
            ext(that, val, override);
        });
    } else {
        ext(that, object, override);
    }
}

// test
var a = {
    comm: {
        x: 'x',
        y: 'y',
        z: {
            aa: 'aa',
            bb: 'bb'
        }
    },

    b: 'b'
}

var b = {
    comm: {
        v: 'v',
        z: {
            bb: 'bb3333',
            cc: 'cc'
        }
    },

    b: 'b1',
    c: 'c'
}

// 不覆盖
a.extend(b);
// 覆盖
a.extend(b, true);
// 覆盖且递归
a.extend(b, true, true)