js处理时间戳转成日期格式

获取指定的时间格式

function GformatTime(time,format){
let timeIsObject = false;
        // 如果两个参数都为空则，全部采用默认
        if(typeof _format === 'undefined' && typeof _time === 'undefined'){
            timeIsObject = true;
            _format = 'Y-m-d H:i:s';
            _time = new Date();
        }
        else if(!_format){
            _format = 'Y-m-d H:i:s';
        }
        else if(_format && typeof _time === 'undefined'){
            // // 判断下_str 是不是位于10至12位的纯阿拉伯数字，如果是转为毫秒时间戳
            // if(/^[1-9]\d{9,11}$/.test(_format)){
            //     _format*=1000;
            // }
            if(new Date(_format).toString() === 'Invalid Date'){
                timeIsObject = true;
               _time = new Date();
            }else{
                 _time = _format;
                _format = 'Y-m-d H:i:s';
            }
        }
        if(!timeIsObject){
            try{
                //  // 判断下_str 是不是位于10至12位的纯阿拉伯数字，如果是转为毫秒时间戳
                // if(/^[1-9]\d{9,11}$/.test(_time)){
                //     _time*=1000;
                // }
                _time = new Date(_time);
                if(_time.toString() === 'Invalid Date' || _time.toLocaleDateString() === '1970/1/1'){
                    _time = new Date(null);
                }
            } catch(error) {
                _time = new Date();
            }
        }
        // 得到"Wed Apr 07 2021" => ['Wed','Apr','07','2021']
        let dateString = _time.toDateString().split(' ');
        // 补位函数
        let strPad = function(v,len = 2){
            let vLen = v.toString().length;
            if(vLen < len){
                for(let i = len-vLen; i > 0; i--){
                    v = '0'+v;
                }
            }
            return v;
        }
        let result = [],temp;
        let len = _format.length;
        for(let ii = 0; ii < len; ii++){
            if(_format[ii] === '\\'){
                result.push(_format[++ii]);
                continue;
            }
            switch(_format[ii]){
                case 'd':
                    // 一个月中的第几天（从 01 到 31）
                    result.push(strPad(_time.getDate()));
                    break;
                case 'D':
                    // 星期几的文本表示（用三个字母表示）
                    result.push(dateString[0]);
                    break;
                case 'j':
                    // 一个月中的第几天，不带前导零（1 到 31）
                    result.push(_time.getDate());
                    break;
                // case 'l':
                //     // （'L' 的小写形式）- 星期几的完整的文本表示
                //     break;
                case 'N':
                    // 星期几的 ISO-8601 数字格式表示（1表示Monday[星期一]，7表示Sunday[星期日]）
                    result.push(_time.getDay()+1);
                    break;
                // case 'S':
                //     // 一个月中的第几天的英语序数后缀（2 个字符：st、nd、rd 或 th。与 j 搭配使用）
                //     break;
                case 'w':
                    // 星期几的数字表示（0 表示 Sunday[星期日]，6 表示 Saturday[星期六]）
                    result.push(_time.getDay());
                    break;
                case 'z':
                    // 一年中的第几天（从 0 到 365）
                    result.push(Math.ceil((new Date(_time.toDateString()) - new Date(_time.getFullYear().toString()))/(24*60*60*1000)));
                    break;
                case 'W':
                    // 用 ISO-8601 数字格式表示一年中的第几个星期（第几周）
                    result.push(Math.ceil(Math.ceil((new Date(_time.toDateString()) - new Date(_time.getFullYear().toString()))/(24*60*60*1000))/7));
                    break;
                // case 'F':
                //     // 月份的完整的文本表示（January[一月份] 到 December[十二月份]）
                //     break;
                case 'm':
                    // 月份的数字表示（从 01 到 12）
                    result.push(strPad(_time.getMonth()+1));
                    break;
                case 'M':
                    // 月份的短文本表示（用三个字母表示）
                    result.push(dateString[1]);
                    break;
                case 'n':
                    // 月份的数字表示，不带前导零（1 到 12）
                    result.push(strPad(_time.getMonth()+1));
                    break;
                case 't':
                    // 给定月份中包含的天数
                    temp = new Date(_time);// 防止改变原时间对象
                    temp.setMonth(_time.getMonth()+1);
                    temp.setDate(0);// 设置为0,date会自动切为上一个月的最后一天
                    result.push(temp.getDate());
                    break;
                case 'L':
                    // 是否是闰年（如果是闰年则为 1，否则为 0）
                    temp = _time.getFullYear();
                    if(temp%4 == 0 && temp%100 != 0 || temp%400 == 0){
                        result.push(1);
                    }else{
                        result.push(0);
                    }
                    break;
                case 'o':
                    // ISO-8601 标准下的年份数字
                case 'Y':
                    // 年份的四位数表示
                    result.push(_time.getFullYear());
                    break;
                case 'y':
                    // 年份的两位数表示
                    result.push(_time.getFullYear().toString().substr(2,2));
                    break;
                case 'a':
                    //小写形式表示：am 或 pm
                    temp = _time.getHours();
                    result.push(temp<12?'am':'pm');
                    break;
                case 'A':
                    // 大写形式表示：AM 或 PM
                    temp = _time.getHours();
                    result.push(temp<12?'AM':'PM');
                    break;
                // case 'B':
                //     // Swatch Internet Time（000 到 999）
                //     break;
                case 'g':
                    // 12 小时制，不带前导零（1 到 12）
                    temp = _time.getHours();
                    result.push(temp>12?temp-12:temp);
                    break;
                case 'G':
                    // 24 小时制，不带前导零（0 到 23）
                    temp = _time.getHours();
                    result.push(temp);
                    break;
                case 'h':
                    // 12 小时制，带前导零（01 到 12）
                    temp = _time.getHours();
                    temp = temp>12?temp-12:temp;
                    result.push(strPad(temp));
                    break;
                case 'H':
                    // 24 小时制，带前导零（00 到 23）
                    temp = _time.getHours();
                    result.push(strPad(temp));
                    break;
                case 'i':
                    // 分，带前导零（00 到 59）
                    result.push(strPad(_time.getMinutes()));
                    break;
                case 's':
                    // 秒，带前导零（00 到 59）
                    result.push(strPad(_time.getSeconds()));
                    break;
                default:
                    result.push(_format[ii]);
            }
        }
        return result.join('');
}

获取指定时间戳（毫秒）

function strtotime(string, time, toms){
   let date, timestamp, msg = "参数格式错误，请参照 a b a b ……,a：正负数整型，b:单位year(y年),month(m月),week(w周),day(d日),hours(h时),minutes(i分),seconds(s秒)\r\n如: '2 day -1 hours'=》47小时后\r\n如: '-2 day 1 hours'=》47小时前";
   // 判断是否是时间参数
   let isDateParam = function(_str,_toms){
       let _date,_timestamp;
       if(typeof _str === 'undefined' || !_str || (typeof _str === 'object' && _str.length === 0)){
           return new Date().valueOf();
       }
       // 判断下_str 是不是位于10至12位的纯阿拉伯数字，如果是转为毫秒时间戳
       // if(/^[1-9]\d{9,11}$/.test(_str)){
       //     _str*=1000;
       // }
       if(_str === 'now'){
           _date = new Date();
       }else{
           // 直接转处理_str如果是时间格式
           _date = new Date(_str);
       }
       if(_date.toString() !== 'Invalid Date' && _date.toLocaleDateString() !== '1970/1/1'){
           // _str就是时间值，参数二变成是否转为时间戳秒单位
           // 判断第二个参数，如果为真则转为秒的单位
           _timestamp = _date.valueOf();
           if(_toms){
               _timestamp = parseInt(_timestamp/1000);
           }
           return _timestamp;
       }
       return false;
   }
   // 判断string是否是直接时间字符串或时间对象，如果是直接返回值
   date = isDateParam(string,time);
   if(date && !isNaN(date)){
       return date;
   }
   // 判断_time参数
   date = isDateParam(time, false);
   if(date && !isNaN(date)){
       timestamp = date;
       date = new Date(date);
   }else{
       date = new Date();
       timestamp = date.valueOf();
   }
   let values,unitNames;
   try {
       // 提取数值和单位
       values = string.replace(/[^\d-+.]+/g,'_#_').split('_#_').filter(function (s) {
          return s && parseInt(s);
       });
       // 单位名
       unitNames = string.replace(/[\d-+.]+/g,'_#_').split('_#_').filter(function (s) {
          return s && s.trim();
       });
   } catch(error) {
       throw msg;
   }
   let oneDayTamp = 86400000, uniqueUnit = {},temp;
   for(let ii = 0; ii < values.length; ii++){
       if(unitNames[ii] === 'minutes'){
           unitNames[ii] = 'i';
       }
       if(unitNames[ii] && !uniqueUnit.hasOwnProperty(unitNames[ii][0])){
           let val = parseInt(values[ii]);
           uniqueUnit[unitNames[ii][0]] = 1;// 取单位的首字母
           switch(unitNames[ii]){
               case 'y':
                   // no break;
               case 'year':
                   temp = new Date(timestamp);
                   temp.setFullYear(temp.getFullYear() + val);
                   timestamp = temp.valueOf();
                   break;
               case 'm':
                   // no break;
               case 'month':
                   temp = new Date(timestamp);
                   temp.setMonth(temp.getMonth() + val);
                   timestamp = temp.valueOf();
                   break;
               case 'w':
                   // no break;
               case 'week':
                   timestamp += val*604800000;
                   break;
               case 'd':
                   // no break;
               case 'day':
                   timestamp += val*86400000;
                   break;
               case 'h':
                   // no break;
               case 'hours':
                   timestamp += val*3600000;
                   break;
               case 'i':
                   // no break;
               case 'minutes':
                   timestamp += val*60000;
                   break;
               case 's':
                   // no break;
               case 'seconds':
                   timestamp += val*1000;
                   break;
           }
       }
   }
   if(toms){
       timestamp = parseInt(timestamp/1000);
   }
   return timestamp;
}