时间函数

yyyy年mm月dd日

// padStart 的 polyfill，因为某些机型或情况，还无法支持es7的padStart，比如电脑版的微信小程序

// 所以这里做一个兼容polyfill的兼容处理

if (!String.prototype.padStart) {

    // 为了方便表示这里 fillString 用了ES6 的默认参数，不影响理解

    String.prototype.padStart = function(maxLength, fillString = ' ') {

        if (Object.prototype.toString.call(fillString) !== "[object String]") throw new TypeError(

            'fillString must be String')

        let str = this

        // 返回 String(str) 这里是为了使返回的值是字符串字面量，在控制台中更符合直觉

        if (str.length >= maxLength) return String(str)



        let fillLength = maxLength - str.length,

            times = Math.ceil(fillLength / fillString.length)

        while (times >>= 1) {

            fillString += fillString

            if (times === 1) {

                fillString += fillString

            }

        }

        return fillString.slice(0, fillLength) + str;

    }

}



// 其他更多是格式化有如下:

// yyyy:mm:dd|yyyy:mm|yyyy年mm月dd日|yyyy年mm月dd日 hh时MM分等,可自定义组合

function timeFormat(dateTime = null, fmt = 'yyyy-mm-dd') {

    // 如果为null,则格式化当前时间

    if (!dateTime) dateTime = Number(new Date());

    // 如果dateTime长度为10或者13，则为秒和毫秒的时间戳，如果超过13位，则为其他的时间格式

    if (dateTime.toString().length == 10) dateTime *= 1000;

    let date = new Date(dateTime);

    let ret;

    let opt = {

        "y+": date.getFullYear().toString(), // 年

        "m+": (date.getMonth() + 1).toString(), // 月

        "d+": date.getDate().toString(), // 日

        "h+": date.getHours().toString(), // 时

        "M+": date.getMinutes().toString(), // 分

        "s+": date.getSeconds().toString() // 秒

        // 有其他格式化字符需求可以继续添加，必须转化成字符串

    };

    for (let k in opt) {

        ret = new RegExp("(" + k + ")").exec(fmt);

        if (ret) {

            fmt = fmt.replace(ret[1], (ret[1].length == 1) ? (opt[k]) : (opt[k].padStart(ret[1].length, "0")))

        };

    };

    return fmt;

}



export default timeFormat

时间戳转为多久之前

/**

 * 时间戳转为多久之前

 * @param String timestamp 时间戳

 * @param String | Boolean format 如果为时间格式字符串，超出一定时间范围，返回固定的时间格式；

 * 如果为布尔值false，无论什么时间，都返回多久以前的格式

 */

function timeFrom(dateTime = null, format = 'yyyy-mm-dd') {

    // 如果为null,则格式化当前时间

    if (!dateTime) dateTime = Number(new Date());

    // 如果dateTime长度为10或者13，则为秒和毫秒的时间戳，如果超过13位，则为其他的时间格式

    if (dateTime.toString().length == 10) dateTime *= 1000;

    let timestamp = + new Date(Number(dateTime));



    let timer = (Number(new Date()) - timestamp) / 1000;

    // 如果小于5分钟,则返回"刚刚",其他以此类推

    let tips = '';

    switch (true) {

        case timer < 300:

            tips = '刚刚';

            break;

        case timer >= 300 && timer < 3600:

            tips = parseInt(timer / 60) + '分钟前';

            break;

        case timer >= 3600 && timer < 86400:

            tips = parseInt(timer / 3600) + '小时前';

            break;

        case timer >= 86400 && timer < 2592000:

            tips = parseInt(timer / 86400) + '天前';

            break;

        default:

            // 如果format为false，则无论什么时间戳，都显示xx之前

            if(format === false) {

                if(timer >= 2592000 && timer < 365 * 86400) {

                    tips = parseInt(timer / (86400 * 30)) + '个月前';

                } else {

                    tips = parseInt(timer / (86400 * 365)) + '年前';

                }

            } else {

                tips = timeFormat(timestamp, format);

            }

    }

    return tips;

}



export default timeFrom;

年月日时分秒

function formatTime(){
    let date = new Date();
    // 年
    const year = date.getFullYear();
    // 月
    const month = date.getMonth() + 1;
    // 日
    const day = date.getDate();
    // 时
    const hour = date.getHours();
    // 分
    const minute = date.getMinutes();
    // 秒
    const second = date.getSeconds();

    return `${[year, month, day].map(formatNumber).join('/')} ${[hour, minute, second].map(formatNumber).join(':')}`;
}


// 补零
function formatNumber(n) {
    n = n.toString();
    return n[1] ? n : `0${n}`;
}

时间戳转换为想要的时间格式

Date.prototype.format = function (fmt = 'yyyy-MM-dd hh:mm:ss') { //author: meizz 
	var o = {
		"M+": this.getMonth() + 1, //月份 
		"d+": this.getDate(), //日 
		"h+": this.getHours(), //小时 
		"m+": this.getMinutes(), //分 
		"s+": this.getSeconds(), //秒 
		"q+": Math.floor((this.getMonth() + 3) / 3), //季度 
		"S": this.getMilliseconds() //毫秒 
	};
	if (/(y+)/.test(fmt)) fmt = fmt.replace(RegExp.$1, (this.getFullYear() + "").substr(4 - RegExp.$1.length));
	for (var k in o)
		if (new RegExp("(" + k + ")").test(fmt)) fmt = fmt.replace(RegExp.$1, (RegExp.$1.length == 1) ? (o[k]) : (("00" + o[
			k]).substr(("" + o[k]).length)));
	return fmt;
}

刚刚 || 3分钟前 || 1小时前

// time1  1593790157203  TO>>>  刚刚 || 3分钟前 || 1小时前 || 1天前 || 1周前 || 2月前 || 2019年11月11日
const time1 = (timer) => {
	var arrTimestamp = (timer + '').split('');
	for (var start = 0; start < 13; start++) {
		if (!arrTimestamp[start]) {
			arrTimestamp[start] = '0';
		}
	}
	timer = arrTimestamp.join('') * 1;

	var minute = 1000 * 60;
	var hour = minute * 60;
	var day = hour * 24;
	var halfamonth = day * 15;
	var month = day * 30;
	var now = new Date().getTime();
	var diffValue = now - timer;

	// 如果本地时间反而小于变量时间
	if (diffValue < 0) {
		return '不久前';
	}

	// 计算差异时间的量级
	var monthC = diffValue / month;
	var weekC = diffValue / (7 * day);
	var dayC = diffValue / day;
	var hourC = diffValue / hour;
	var minC = diffValue / minute;

	// 数值补0方法
	var zero = function(value) {
		if (value < 10) {
			return '0' + value;
		}
		return value;
	};

	// 使用
	if (monthC > 12) {
		// 超过1年，直接显示年月日
		return (function() {
			var date = new Date(timer);
			return date.getFullYear() + '年' + zero(date.getMonth() + 1) + '月' + zero(date.getDate()) + '日';
		})();
	} else if (monthC >= 1) {
		return parseInt(monthC) + "月前";
	} else if (weekC >= 1) {
		return parseInt(weekC) + "周前";
	} else if (dayC >= 1) {
		return parseInt(dayC) + "天前";
	} else if (hourC >= 1) {
		return parseInt(hourC) + "小时前";
	} else if (minC >= 1) {
		return parseInt(minC) + "分钟前";
	}
	return '刚刚';
}

上午12:01 || 昨天 || 星期日

// time2  1593790157203  TO>>>  上午12:01 || 昨天 || 星期日 || 2019-11-11
const time2 = (timer) => {
	var arrTimestamp = (timer + '').split('');
	for (var start = 0; start < 13; start++) {
		if (!arrTimestamp[start]) {
			arrTimestamp[start] = '0';
		}
	}
	var Etime = arrTimestamp.join('') * 1; //参数时间
	var Etimer = new Date(Etime)

	var Ntime = new Date().getTime() //现在时间
	var Ntimer = new Date()

	var Eyear = Etimer.getFullYear(); //取得4位数的年份
	var Emonth = Etimer.getMonth() + 1 < 10 ? '0' + (Etimer.getMonth() + 1) : Etimer.getMonth() + 1; //取得日期中的月份，其中0表示1月，11表示12月
	var Edate = Etimer.getDate()< 10 ? '0' + Etimer.getDate() : Etimer.getDate(); //返回日期月份中的天数（1到31）
	var Eweek = Etimer.getDay() //返回日期月份中的周
	var Ehour = Etimer.getHours() < 10 ? '0' + Etimer.getHours() : Etimer.getHours(); //返回日期中的小时数（0到23）
	var Eminute = Etimer.getMinutes() < 10 ? '0' + Etimer.getMinutes() : Etimer.getMinutes(); //返回日期中的分钟数（0到59）

	var today = new Date(new Date().setHours(0, 0, 0, 0)) / 1000 * 1000 //今天0点时间戳
	var yesterday = today - 24 * 60 * 60 * 1000 //昨天0点时间戳
	var beforeWeek = today - 7 * 24 * 60 * 60 * 1000 //一周前0点时间戳

	// 今天的时间
	if (today < Etime) {

		if (Ehour < 12) {
			return '上午' + Ehour + ':' + Eminute
		} else {
			return '下午' + Ehour + ':' + Eminute
		}
	}
	// 昨天的时间
	if (yesterday < Etime && Etime < today) {
		return '昨天'
	}
	// 一周内的时间
	if (beforeWeek < Etime) {
		if (Eweek == 0) {
			return "星期日"
		} else if (Eweek == 1) {
			return "星期一"
		} else if (Eweek == 2) {
			return "星期二"
		} else if (Eweek == 3) {
			return "星期三"
		} else if (Eweek == 4) {
			return "星期四"
		} else if (Eweek == 5) {
			return "星期五"
		} else if (Eweek == 6) {
			return "星期六"
		}
	}
	// 更早的时间
	return Eyear + '-' + Emonth + '-' + Edate
}

日期转为时间戳

// time4  2019/11/11 || 2019/11/11 12:03 TO>>> 1593790157203
const time4 = (timer) => {
	var date = timer.replace(/\//g, '-')
	date = timer.replace(/：/g, ':')
	var Etimer = new Date(date)
	var Etime = Etimer.getTime()

	return Etime
}

开始与结束时间戳

// time5  (1593790157203,1593790157205) （开始与结束时间戳）  TO>>> 00:40 || 01:25 || 01:20:11 （时长）
const time5 = (sTime,eTime) => {
	
	if(sTime.length==13) sTime = (sTime-0)/1000
	if(eTime.length==13) eTime = (eTime-0)/1000

	var lang = 0
	
	var interval = Math.ceil((eTime-sTime)/1000)
	
	// 一分钟以内
	if(interval<60){
		
		if(interval<10){
			lang = '0' + interval
		}else{
			lang = interval
		}
		return '00:'+lang
	}
	
	// 一小时以内
	if(60 < interval && interval < 3600){
		var langM = Math.floor(interval/60)
		var langS = Math.floor(interval-(langM*60))
		
		if(langM<10) langM = '0'+langM
		if(langS<10) langS = '0'+langS
		
		return langM+':'+langS
	}
	
	// 一小时以上
	if(3600 < interval){
		var langH = Math.floor(interval/3600)
		var langM = Math.floor((interval/60)-(langH*60))
		var langS = Math.floor(interval-(langH*3600)-(langM*60))
		
		if(langH<10) langH = '0'+langH
		if(langM<10) langM = '0'+langM
		if(langS<10) langS = '0'+langS
		
		return langH+':'+langM+':'+langS
	}
	
}