如何在 JavaScript 中格式化日期？

对于自定义分隔的日期格式，您必须拉出日期（或时间） 组件，然后手动创建一个字符串 使用您想要的分隔符。

为此，可以使用 DateTimeFormat#formatToParts。你可以 解构数组，但这并不理想，因为数组输出取决于 现场：

{ // example 1
   let formatter = new Intl.DateTimeFormat('en');
   let example = formatter.formatToParts();
   console.log(example);
}
{ // example 2
   let formatter = new Intl.DateTimeFormat('hi');
   let example = formatter.formatToParts();
   console.log(example);
}

更好的做法是将格式数组映射到生成的字符串：

function join(date, options, separator) {
   function format(option) {
      let formatter = new Intl.DateTimeFormat('en', option);
      return formatter.format(date);
   }
   return options.map(format).join(separator);
}

let options = [{day: 'numeric'}, {month: 'short'}, {year: 'numeric'}];
let joined = join(new Date, options, '-');
console.log(joined);

您还可以使用 DateTimeFormat#format 逐个提取各个部分，但请注意，使用此方法时，自 3 月起 2020 年，ECMAScript 实现中存在一个错误 在分钟和秒上引导零（该方法规避了此错误 同上）。DateTimeFormat

let date = new Date(2010, 7, 5);
let year = new Intl.DateTimeFormat('en', { year: 'numeric' }).format(date);
let month = new Intl.DateTimeFormat('en', { month: 'short' }).format(date);
let day = new Intl.DateTimeFormat('en', { day: '2-digit' }).format(date);
console.log(`${day}-${month}-${year}`);

在处理日期和时间时，通常值得使用库（例如。不建议将 luxon、date-fns、moment.js 用于新项目），因为该领域存在许多隐藏的复杂性。

请注意，上述解决方案中使用的 ECMAScript 国际化 API 在 IE10 中不受支持（2 月全球浏览器市场份额为 0.03%） 2020).

使用 date.format 库：

var dateFormat = require('dateformat');
var now = new Date();
dateFormat(now, "dddd, mmmm dS, yyyy, h:MM:ss TT");

返回：

Saturday, June 9th, 2007, 5:46:21 PM 

npm 上的 dateformat

http://jsfiddle.net/phZr7/1/

注意 （2022-10）：已被弃用一段时间，并从 Firefox 版本 58 开始删除。请参阅 toLocaleFormattoLocaleFormat

我认为你可以只使用非标准的 Date 方法toLocaleFormat(formatString)

formatString：格式字符串，其格式与 C 中的 strftime（） 函数所期望的格式相同。

var today = new Date();
today.toLocaleFormat('%d-%b-%Y'); // 30-Dec-2011

引用：

• toLocaleFormat
• strftime

好吧，我想要的是将今天的日期转换为MySQL友好的日期字符串，例如，并在我的一个查询中使用该字符串作为参数。我找到的简单解决方案是这样的：2012-06-23

var today = new Date().toISOString().slice(0, 10);

请记住，上述解决方案未考虑您的时区偏移量。

您可以考虑改用此函数：

function toJSONLocal (date) {
    var local = new Date(date);
    local.setMinutes(date.getMinutes() - date.getTimezoneOffset());
    return local.toJSON().slice(0, 10);
}

这将为您提供正确的日期，以防您在一天的开始/结束时执行此代码。

var date = new Date();

function toLocal(date) {
  var local = new Date(date);
  local.setMinutes(date.getMinutes() - date.getTimezoneOffset());
  return local.toJSON();
}

function toJSONLocal(date) {
  var local = new Date(date);
  local.setMinutes(date.getMinutes() - date.getTimezoneOffset());
  return local.toJSON().slice(0, 10);
}

// check out your devtools console
console.log(date.toJSON());
console.log(date.toISOString());
console.log(toLocal(date));

console.log(toJSONLocal(date));

• Date.toISOString
• 日期.toJSON
• 字符串.slice
• 外部示例

将 jQuery UI 插件添加到您的页面：

function DateFormate(dateFormate, datetime) {
    return $.datepicker.formatDate(dateFormate, datetime);
};

Sugar.js 对 Date 对象有很好的扩展，包括 Date.format 方法。

文档中的示例：

Date.create().format('{Weekday} {Month} {dd}, {yyyy}');

Date.create().format('{12hr}:{mm}{tt}')

这是我刚刚编写的一些代码，用于处理我正在处理的项目的日期格式。它模仿PHP日期格式化功能以满足我的需求。随意使用它，它只是扩展已经存在的 Date（） 对象。这可能不是最优雅的解决方案，但它可以满足我的需求。

var d = new Date(); 
d_string = d.format("m/d/Y h:i:s");

/**************************************
 * Date class extension
 * 
 */
    // Provide month names
    Date.prototype.getMonthName = function(){
        var month_names = [
                            'January',
                            'February',
                            'March',
                            'April',
                            'May',
                            'June',
                            'July',
                            'August',
                            'September',
                            'October',
                            'November',
                            'December'
                        ];

        return month_names[this.getMonth()];
    }

    // Provide month abbreviation
    Date.prototype.getMonthAbbr = function(){
        var month_abbrs = [
                            'Jan',
                            'Feb',
                            'Mar',
                            'Apr',
                            'May',
                            'Jun',
                            'Jul',
                            'Aug',
                            'Sep',
                            'Oct',
                            'Nov',
                            'Dec'
                        ];

        return month_abbrs[this.getMonth()];
    }

    // Provide full day of week name
    Date.prototype.getDayFull = function(){
        var days_full = [
                            'Sunday',
                            'Monday',
                            'Tuesday',
                            'Wednesday',
                            'Thursday',
                            'Friday',
                            'Saturday'
                        ];
        return days_full[this.getDay()];
    };

    // Provide full day of week name
    Date.prototype.getDayAbbr = function(){
        var days_abbr = [
                            'Sun',
                            'Mon',
                            'Tue',
                            'Wed',
                            'Thur',
                            'Fri',
                            'Sat'
                        ];
        return days_abbr[this.getDay()];
    };

    // Provide the day of year 1-365
    Date.prototype.getDayOfYear = function() {
        var onejan = new Date(this.getFullYear(),0,1);
        return Math.ceil((this - onejan) / 86400000);
    };

    // Provide the day suffix (st,nd,rd,th)
    Date.prototype.getDaySuffix = function() {
        var d = this.getDate();
        var sfx = ["th","st","nd","rd"];
        var val = d%100;

        return (sfx[(val-20)%10] || sfx[val] || sfx[0]);
    };

    // Provide Week of Year
    Date.prototype.getWeekOfYear = function() {
        var onejan = new Date(this.getFullYear(),0,1);
        return Math.ceil((((this - onejan) / 86400000) + onejan.getDay()+1)/7);
    } 

    // Provide if it is a leap year or not
    Date.prototype.isLeapYear = function(){
        var yr = this.getFullYear();

        if ((parseInt(yr)%4) == 0){
            if (parseInt(yr)%100 == 0){
                if (parseInt(yr)%400 != 0){
                    return false;
                }
                if (parseInt(yr)%400 == 0){
                    return true;
                }
            }
            if (parseInt(yr)%100 != 0){
                return true;
            }
        }
        if ((parseInt(yr)%4) != 0){
            return false;
        } 
    };

    // Provide Number of Days in a given month
    Date.prototype.getMonthDayCount = function() {
        var month_day_counts = [
                                    31,
                                    this.isLeapYear() ? 29 : 28,
                                    31,
                                    30,
                                    31,
                                    30,
                                    31,
                                    31,
                                    30,
                                    31,
                                    30,
                                    31
                                ];

        return month_day_counts[this.getMonth()];
    } 

    // format provided date into this.format format
    Date.prototype.format = function(dateFormat){
        // break apart format string into array of characters
        dateFormat = dateFormat.split("");

        var date = this.getDate(),
            month = this.getMonth(),
            hours = this.getHours(),
            minutes = this.getMinutes(),
            seconds = this.getSeconds();
        // get all date properties ( based on PHP date object functionality )
        var date_props = {
            d: date < 10 ? '0'+date : date,
            D: this.getDayAbbr(),
            j: this.getDate(),
            l: this.getDayFull(),
            S: this.getDaySuffix(),
            w: this.getDay(),
            z: this.getDayOfYear(),
            W: this.getWeekOfYear(),
            F: this.getMonthName(),
            m: month < 10 ? '0'+(month+1) : month+1,
            M: this.getMonthAbbr(),
            n: month+1,
            t: this.getMonthDayCount(),
            L: this.isLeapYear() ? '1' : '0',
            Y: this.getFullYear(),
            y: this.getFullYear()+''.substring(2,4),
            a: hours > 12 ? 'pm' : 'am',
            A: hours > 12 ? 'PM' : 'AM',
            g: hours % 12 > 0 ? hours % 12 : 12,
            G: hours > 0 ? hours : "12",
            h: hours % 12 > 0 ? hours % 12 : 12,
            H: hours,
            i: minutes < 10 ? '0' + minutes : minutes,
            s: seconds < 10 ? '0' + seconds : seconds           
        };

        // loop through format array of characters and add matching data else add the format character (:,/, etc.)
        var date_string = "";
        for(var i=0;i<dateFormat.length;i++){
            var f = dateFormat[i];
            if(f.match(/[a-zA-Z]/g)){
                date_string += date_props[f] ? date_props[f] : '';
            } else {
                date_string += f;
            }
        }

        return date_string;
    };
/*
 *
 * END - Date class extension
 * 
 ************************************/

如果你已经在项目中使用了jQuery UI，你可以这样做：

var formatted = $.datepicker.formatDate("M d, yy", new Date("2014-07-08T09:02:21.377"));

// formatted will be 'Jul 8, 2014'

此处提供了一些日期选择器日期格式选项。

下面是一个完全符合您要求的脚本

https://github.com/UziTech/js-date-format

var d = new Date("2010-8-10");
document.write(d.format("DD-MMM-YYYY"));

不使用任何外部库的 JavaScript 解决方案：

var now = new Date()
months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
var formattedDate = now.getDate() + "-" + months[now.getMonth()] + "-" + now.getFullYear()
alert(formattedDate)

@Sébastien -- 替代所有浏览器支持

new Date(parseInt(496407600)*1000).toLocaleDateString('de-DE', {
year: 'numeric',
month: '2-digit',
day: '2-digit'
}).replace(/\./g, '/');

文档：https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toLocaleDateString

基于 Date.toLocaleDateString 的高阶标记模板文本示例：

const date = new Date(Date.UTC(2020, 4, 2, 3, 23, 16, 738));
const fmt = (dt, lc = "en-US") => (str, ...expr) =>
    str.map((str, i) => str + (expr[i]?dt.toLocaleDateString(lc, expr[i]) :'')).join('')

console.log(fmt(date)`${{year: 'numeric'}}-${{month: '2-digit'}}-${{day: '2-digit'}}`);
// expected output: "2020-05-02"

如果您在代码中使用 jQuery UI，则有一个名为 的内置函数。我用这种方式来格式化今天的日期：formatDate()

var testdate = Date();
testdate = $.datepicker.formatDate( "d-M-yy",new Date(testdate));
alert(testdate);

您可以在 jQuery UI 文档中看到许多其他格式化日期的示例。

纯 JavaScript 是小型一次性用户的最佳选择。

另一方面，如果你需要更多的日期内容，MomentJS 是一个很好的解决方案。

例如：

moment().format('YYYY-MM-DD HH:m:s');     // now() -> 2015-03-24 14:32:20
moment("20111031", "YYYYMMDD").fromNow(); // 3 years ago
moment("20120620", "YYYYMMDD").fromNow(); // 3 years ago
moment().startOf('day').fromNow();        // 11 hours ago
moment().endOf('day').fromNow();          // in 13 hours

用：

thisDate = new Date(parseInt(jsonDateString.replace('/Date(', '')));
formattedDate = (thisDate.getMonth() + 1) + "/" + (thisDate.getDate()+1) + "/" + thisDate.getFullYear();

这将采用 JSON 日期“/Date（1429573751663）/”，并生成格式化字符串：

"4/21/2015"

如果您需要使用纯 JavaScript 快速设置日期格式，请使用 、、 和 ：getDategetMonth + 1getFullYeargetHoursgetMinutes

var d = new Date();

var datestring = d.getDate()  + "-" + (d.getMonth()+1) + "-" + d.getFullYear() + " " +
d.getHours() + ":" + d.getMinutes();

// 16-5-2015 9:50

或者，如果您需要用零填充它：

var datestring = ("0" + d.getDate()).slice(-2) + "-" + ("0"+(d.getMonth()+1)).slice(-2) + "-" +
    d.getFullYear() + " " + ("0" + d.getHours()).slice(-2) + ":" + ("0" + d.getMinutes()).slice(-2);

// 16-05-2015 09:50

一行中请求的格式 - 没有库，没有 Date 方法，只有正则表达式：

var d = (new Date()).toString().replace(/\S+\s(\S+)\s(\d+)\s(\d+)\s.*/,'$2-$1-$3');
// date will be formatted as "14-Oct-2015" (pass any date object in place of 'new Date()')

在我的测试中，这在主要浏览器（Chrome、Safari、Firefox 和 IE）中可靠运行。正如@RobG所指出的，Date.prototype.toString（） 的输出依赖于实现，因此对于国际或非浏览器实现，只需测试输出以确保它在 JavaScript 引擎中正常工作即可。您甚至可以添加一些代码来测试字符串输出，并确保它与您期望的内容匹配，然后再进行正则表达式替换。

如果你已经在项目中使用了 ExtJS，你可以使用 Ext.Date：

var date = new Date();
Ext.Date.format(date, "d-M-Y");

返回：

"11-Nov-2015"

我使用以下内容。它很简单，工作正常。

 var dtFormat = require('dtformat');
   var today = new Date();
   dtFormat(today, "dddd, mmmm dS, yyyy, h:MM:ss TT");

或者这个：

var now = new Date()
months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
var formattedDate = now.getDate()  + "-" + months[now.getMonth()] + "-" + now.getFullYear()
alert(formattedDate)

有一个新库 smarti.to.js，用于 JavaScript 数字、日期和 JSON 日期（Microsoft 或 ISO8601）的本地化格式。

例：

new Date('2015-1-1').to('dd.MM.yy')         // Outputs 01.01.2015
"2015-01-01T10:11:12.123Z".to('dd.MM.yy')   // Outputs 01.01.2015

本地化文件 （smarti.to.{文化}.js）。示例（smarti.to.et-EE.js）：

new Date('2015-1-1').to('d')                // Outputs 1.01.2015

以及多格式化功能：

smarti.format('{0:n2} + {1:n2} = {2:n2}', 1, 2, 3)   // Output: 1,00 + 2,00 = 3,00

如果对格式的控制比当前接受的答案略少，则可以使用 Date#toLocaleDateString 创建特定于区域设置的标准呈现。和参数允许应用程序指定应使用其格式约定的语言，并允许对呈现进行一些自定义。localeoptions

选项关键示例：

1. day：
   日期的表示形式。
   可能的值为“numeric”、“2-digit”。
2. weekday：
   工作日的表示形式。
   可能的值为“narrow”、“short”、“long”。
3. year：
   年份的表示形式。
   可能的值为“numeric”、“2-digit”。
4. month：
   月份的表示形式。
   可能的值为“numeric”、“2-digit”、“narrow”、“short”、“long”。
5. hour：
   小时的表示形式。
   可能的值为“numeric”、“2-digit”。
6. 分钟：分钟的表示形式。
   可能的值为“numeric”、“2-digit”。
7. second：
   第二个的表示。
   可能的值为“数字”，2 位”。
8. hour12：
   时间格式的表示形式。
   接受布尔值 true 或 false

所有这些键都是可选的。您可以根据需要更改选项值的数量，这也将反映每个日期时间术语的存在。

注意：如果您只想配置内容选项，但仍使用当前区域设置，则传递第一个参数将导致错误。请改用。nullundefined

对于不同的语言：

1. “en-US”：美式英语
2. “en-GB”：英式英语
3. “hi-IN”：对于印地语
4. “ja-JP”：对于日语

您可以使用更多语言选项。

例如

var options = { weekday: 'long', year: 'numeric', month: 'long', day: 'numeric' };
var today  = new Date();

console.log(today.toLocaleDateString("en-US")); // 9/17/2016
console.log(today.toLocaleDateString("en-US", options)); // Saturday, September 17, 2016
console.log(today.toLocaleDateString("hi-IN", options)); // शनिवार, 17 सितंबर 2016

您也可以将该方法用于相同的目的。唯一的区别是此函数提供您不传递任何选项的时间。toLocaleString()

// Example
9/17/2016, 1:21:34 PM

引用：

• toLocaleString()

• toLocaleDateString()

简短、广泛兼容的方法：

function formatDate(date) {
    date.toISOString()
    .replace(/^(\d+)-(\d+)-(\d+).*$/, // Only extract Y-M-D
        function (a,y,m,d) {
            return [
                d, // Day
                ['Jan','Feb','Mar','Apr','May','Jun',  // Month Names
                'Jul','Ago','Sep','Oct','Nov','Dec']
                [m-1], // Month
                y  // Year
            ].join('-') // Stitch together
        })
}

或者，作为一行：

date.toISOString().replace(/^(\d+)-(\d+)-(\d+)T(\d+):(\d+):(\d+).(\d+)Z$/, function (a,y,m,d) {return [d,['Jan','Feb','Mar','Apr','May','Jun','Jul','Ago','Sep','Oct','Nov','Dic'][m-1],y].join('-')})

试试这个：

function init(){
    var d = new Date();
    var day = d.getDate();
    var x = d.toDateString().substr(4, 3);
    var year = d.getFullYear();
    document.querySelector("#mydate").innerHTML = day + '-' + x + '-' + year;
}
window.onload = init;

<div id="mydate"></div>

在现代浏览器 （*） 中，您可以这样做：

var today = new Date().toLocaleDateString('en-GB', {
    day : 'numeric',
    month : 'short',
    year : 'numeric'
}).split(' ').join('-');

如果今天（2016 年 1 月 24 日）执行，则输出：

'24-Jan-2016'

(*) 根据 MDN 的说法，“现代浏览器”是指 Chrome 24+、Firefox 29+、Internet Explorer 11、Edge 12+、Opera 15+ 和 Safari 夜间构建。

var today = new Date();
var formattedToday = today.toLocaleDateString() + ' ' + today.toLocaleTimeString();

缩小了 2.39KB。一个文件。
https://github.com/rhroyston/clock-js
2010 年 8 月 10 日将是：

var str = clock.month
str.charAt(0).toUpperCase() + str.slice(1,3); //gets you "Aug"
console.log(clock.day + '-' + str + '-' + clock.year); //gets you 10-Aug-2010

这就是我为我的 npm 插件实现的方式

var monthNames = [
  "January", "February", "March",
  "April", "May", "June", "July",
  "August", "September", "October",
  "November", "December"
];

var Days = [
  "Sunday", "Monday", "Tuesday", "Wednesday",
  "Thursday", "Friday", "Saturday"
];

var formatDate = function(dt,format){
  format = format.replace('ss', pad(dt.getSeconds(),2));
  format = format.replace('s', dt.getSeconds());
  format = format.replace('dd', pad(dt.getDate(),2));
  format = format.replace('d', dt.getDate());
  format = format.replace('mm', pad(dt.getMinutes(),2));
  format = format.replace('m', dt.getMinutes());
  format = format.replace('MMMM', monthNames[dt.getMonth()]);
  format = format.replace('MMM', monthNames[dt.getMonth()].substring(0,3));
  format = format.replace('MM', pad(dt.getMonth()+1,2));
  format = format.replace(/M(?![ao])/, dt.getMonth()+1);
  format = format.replace('DD', Days[dt.getDay()]);
  format = format.replace(/D(?!e)/, Days[dt.getDay()].substring(0,3));
  format = format.replace('yyyy', dt.getFullYear());
  format = format.replace('YYYY', dt.getFullYear());
  format = format.replace('yy', (dt.getFullYear()+"").substring(2));
  format = format.replace('YY', (dt.getFullYear()+"").substring(2));
  format = format.replace('HH', pad(dt.getHours(),2));
  format = format.replace('H', dt.getHours());
  return format;
}

pad = function(n, width, z) {
  z = z || '0';
  n = n + '';
  return n.length >= width ? n : new Array(width - n.length + 1).join(z) + n;
}

如果您喜欢一个简短的、人类可读的功能 - 这很容易调整以适合您。

timeStamp 参数是 1970 年的毫秒 - 它由许多其他设备返回......new Date().getTime()

好吧，我改变了主意。我包含了一个用于零填充的额外功能。诅咒！

 function zeroPad(aNumber) {
     return ("0"+aNumber).slice(-2);
 }
 function humanTime(timeStamp) {
    var M = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
    var D = new Date(timeStamp); // 23 Aug 2016 16:45:59 <-- Desired format.
    return D.getDate() + " " + M[D.getMonth()] + " " + D.getFullYear() + " " + D.getHours() + ":" + zeroPad(d.getMinutes()) + ":" + zeroPad(D.getSeconds());
 }

受到JD Smith奇妙的正则表达式解决方案的启发，我突然有了这个令人头晕目眩的想法：

var D = Date().toString().split(" ");
console.log(D[2] + "-" + D[1] + "-" + D[3]);

我们有很多解决方案，但我认为其中最好的是 Moment.js。所以我个人建议使用 Moment.js 进行日期和时间操作。

console.log(moment().format('DD-MMM-YYYY'));

<script src="//cdnjs.cloudflare.com/ajax/libs/moment.js/2.14.1/moment.min.js"></script>

自定义格式化功能：

对于固定格式，一个简单的函数就可以完成工作。以下示例生成国际格式 YYYY-MM-DD：

function dateToYMD(date) {
    var d = date.getDate();
    var m = date.getMonth() + 1; //Month from 0 to 11
    var y = date.getFullYear();
    return '' + y + '-' + (m<=9 ? '0' + m : m) + '-' + (d <= 9 ? '0' + d : d);
}

console.log(dateToYMD(new Date(2017,10,5))); // Nov 5

OP格式可以生成如下：

function dateToYMD(date) {
    var strArray=['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
    var d = date.getDate();
    var m = strArray[date.getMonth()];
    var y = date.getFullYear();
    return '' + (d <= 9 ? '0' + d : d) + '-' + m + '-' + y;
}
console.log(dateToYMD(new Date(2017,10,5))); // Nov 5

注意：但是，扩展 JavaScript 标准库通常不是一个好主意（例如，通过将此函数添加到 Date 的原型中）。

更高级的函数可以基于格式参数生成可配置的输出。

如果编写格式化函数太长，那么周围有很多库可以做到这一点。其他一些答案已经列举了它们。但增加依赖性也有相应的影响。

标准 ECMAScript 格式化函数：

从 ECMAScript 的最新版本开始，该类具有一些特定的格式化函数：Date

toDateString：与实现相关，仅显示日期。

https://262.ecma-international.org/#sec-date.prototype.todatestring

new Date().toDateString(); // e.g. "Fri Nov 11 2016"

toISOString：显示 ISO 8601 日期和时间。

https://262.ecma-international.org/#sec-date.prototype.toisostring

new Date().toISOString(); // e.g. "2016-11-21T08:00:00.000Z"

toJSON：JSON 的字符串化器。

https://262.ecma-international.org/#sec-date.prototype.tojson

new Date().toJSON(); // e.g. "2016-11-21T08:00:00.000Z"

toLocaleDateString：与实现相关，区域设置格式的日期。

https://262.ecma-international.org/#sec-date.prototype.tolocaledatestring

new Date().toLocaleDateString(); // e.g. "21/11/2016"

toLocaleString：依赖于实现，是区域设置格式的日期和时间。

https://262.ecma-international.org/#sec-date.prototype.tolocalestring

new Date().toLocaleString(); // e.g. "21/11/2016, 08:00:00 AM"

toLocaleTimeString：依赖于实现，区域设置格式的时间。

https://262.ecma-international.org/#sec-date.prototype.tolocaletimestring

new Date().toLocaleTimeString(); // e.g. "08:00:00 AM"

toString：日期的泛型 toString。

https://262.ecma-international.org/#sec-date.prototype.tostring

new Date().toString(); // e.g. "Fri Nov 21 2016 08:00:00 GMT+0100 (W. Europe Standard Time)"

注意：可以从这些格式>生成自定义输出

new Date().toISOString().slice(0,10); //return YYYY-MM-DD

示例片段：

console.log("1) "+  new Date().toDateString());
console.log("2) "+  new Date().toISOString());
console.log("3) "+  new Date().toJSON());
console.log("4) "+  new Date().toLocaleDateString());
console.log("5) "+  new Date().toLocaleString());
console.log("6) "+  new Date().toLocaleTimeString());
console.log("7) "+  new Date().toString());
console.log("8) "+  new Date().toISOString().slice(0,10));

指定标准函数的区域设置：

上面列出的一些标准函数取决于语言环境：

• toLocaleDateString()
• toLocaleTimeString()
• toLocalString()

这是因为不同的文化使用不同的格式，并以不同的方式表达他们的日期或时间。 默认情况下，该函数将返回在其运行的设备上配置的格式，但这可以通过设置参数 （ECMA-402） 来指定。

toLocaleDateString([locales[, options]])
toLocaleTimeString([locales[, options]])
toLocaleString([locales[, options]])
//e.g. toLocaleDateString('ko-KR');

第二个参数允许在所选区域设置中配置更具体的格式。例如，月份可以显示为全文或缩写。option

toLocaleString('en-GB', { month: 'short' })
toLocaleString('en-GB', { month: 'long' })

示例片段：

console.log("1) "+  new Date().toLocaleString('en-US'));
console.log("2) "+  new Date().toLocaleString('ko-KR'));
console.log("3) "+  new Date().toLocaleString('de-CH'));

console.log("4) "+  new Date().toLocaleString('en-GB', { hour12: false }));
console.log("5) "+  new Date().toLocaleString('en-GB', { hour12: true }));

关于语言环境的一些良好做法：

• 大多数人不喜欢他们的日期以外国人格式显示，因此，请尽可能保留默认区域设置（而不是在任何地方设置“en-US”）。
• 实现与 UTC 之间的转换可能具有挑战性（考虑到 DST、时区不是 1 小时的倍数等）。尽可能使用经过充分测试的库。
• 不要假设区域设置与一个国家/地区相关：多个国家/地区（加拿大、印度等）都有很多国家/地区。
• 避免通过非标准方式检测区域设置。在这里，您可以了解多个陷阱：检测键盘布局、按地理位置检测区域设置等。

好的，我们有一个叫做 Intl 的东西，它现在对于在 JavaScript 中格式化日期非常有用：

您的日期如下：

var date = '10/8/2010';

然后，您可以使用 new Date（） 更改为 Date，如下所示：

date = new Date(date);

现在，您可以使用以下区域设置列表以任何您喜欢的方式格式化它：

date = new Intl.DateTimeFormat('en-AU').format(date); // Australian date format: "8/10/2010" 

date = new Intl.DateTimeFormat('en-US').format(date); // USA date format: "10/8/2010" 

date = new Intl.DateTimeFormat('ar-EG').format(date);  // Arabic date format: "٨‏/١٠‏/٢٠١٠"

如果你真的想要上面提到的格式，你可以做：

date = new Date(Date.UTC(2010, 7, 10, 0, 0, 0));
var options = {year: "numeric", month: "short", day: "numeric"};
date = new Intl.DateTimeFormat("en-AU", options).format(date).replace(/\s/g, '-');

结果将是：

"10-Aug-2010"

有关详细信息，请参阅 Intl API 和 Intl.DateTimeFormat 文档。

使用 ECMAScript Edition 6 （ES6/ES2015） 字符串模板：

let d = new Date();
let formatted = `${d.getFullYear()}-${d.getMonth() + 1}-${d.getDate()}`;

如果需要更改分隔符：

const delimiter = '/';
let formatted = [d.getFullYear(), d.getMonth() + 1, d.getDate()].join(delimiter);

在 JavaScript 中格式化 DateTimes 的一种有用且灵活的方法是：Intl.DateTimeFormat

var date = new Date();
var options = { year: 'numeric', month: 'short', day: '2-digit'};
var _resultDate = new Intl.DateTimeFormat('en-GB', options).format(date);
// The _resultDate is: "12 Oct 2017"
// Replace all spaces with - and then log it.
console.log(_resultDate.replace(/ /g,'-'));

结果是："12-Oct-2017"

可以使用 options 参数自定义日期和时间格式。

该对象是启用区分语言的日期和时间格式的对象的构造函数。Intl.DateTimeFormat

语法

new Intl.DateTimeFormat([locales[, options]])
Intl.DateTimeFormat.call(this[, locales[, options]])

参数

地区

自选。具有 BCP 47 语言标记的字符串，或此类字符串的数组。有关 locales 参数的一般形式和解释，请参阅 Intl 页面。允许使用以下 Unicode 扩展密钥：

nu
Numbering system. Possible values include: "arab", "arabext", "bali", "beng", "deva", "fullwide", "gujr", "guru", "hanidec", "khmr", "knda", "laoo", "latn", "limb", "mlym", "mong", "mymr", "orya", "tamldec", "telu", "thai", "tibt".
ca
Calendar. Possible values include: "buddhist", "chinese", "coptic", "ethioaa", "ethiopic", "gregory", "hebrew", "indian", "islamic", "islamicc", "iso8601", "japanese", "persian", "roc".

选项

自选。具有以下部分或全部属性的对象：

localeMatcher

要使用的区域设置匹配算法。可能的值为 和 ;缺省值为 。有关此选项的信息，请参阅“国际”页面。"lookup""best fit""best fit"

时区

要使用的时区。实现必须识别的唯一值是 ;默认值为运行时的默认时区。实现还可以识别 IANA 时区数据库的时区名称，例如 、 、 。"UTC""Asia/Shanghai""Asia/Kolkata""America/New_York"

小时12

是否使用 12 小时制（而不是 24 小时制）。可能的值为 和 ;默认值为“取决于区域设置”。truefalse

formatMatcher

要使用的格式匹配算法。可能的值为 和 ;缺省值为 。有关使用此属性的信息，请参阅以下段落。"basic""best fit""best fit"

以下属性描述要在格式化输出中使用的日期时间组件及其所需的表示形式。实现至少需要支持以下子集：

weekday, year, month, day, hour, minute, second
weekday, year, month, day
year, month, day
year, month
month, day
hour, minute, second
hour, minute

实现可能支持其他子集，并且将针对所有可用的子集表示组合协商请求，以找到最佳匹配。有两种算法可用于此协商，并由 formatMatcher 属性选择：完全指定的算法和依赖于实现的“最佳拟合”算法。"basic"

工作日

工作日的表示形式。可能的值为 、 、 。"narrow""short""long"

时代

时代的代表。可能的值为 、 、 。"narrow""short""long"

年

年份的代表。可能的值为 、 。"numeric""2-digit"

月

月份的表示形式。可能的值为 、 、 、 、 。"numeric""2-digit""narrow""short""long"

日

当天的表示形式。可能的值为 、 。"numeric""2-digit"

小时

小时的表示形式。可能的值为 、 。"numeric""2-digit"

分钟

分钟的表示形式。可能的值为 、 。"numeric""2-digit"

第二

第二个的表示形式。可能的值为 、 。"numeric""2-digit"

timeZoneName

时区名称的表示形式。可能的值为 、 。 每个日期时间组件属性的默认值为 undefined，但如果所有组件属性均未定义，则假定年、月和日 为 。"short""long""numeric"

在线查询

更多详情

以下代码允许您将日期格式设置为 （27-12-2017） 或 （27 Dec 2017）：DD-MM-YYYYDD MMM YYYY

/** Pad number to fit into nearest power of 10 */
function padNumber(number, prependChar, count) {
  var out = '' + number; var i;
  if (number < Math.pow(10, count))
    while (out.length < ('' + Math.pow(10, count)).length) out = prependChar + out;
  
  return out;
}

/* Format the date to 'DD-MM-YYYY' or 'DD MMM YYYY' */
function dateToDMY(date, useNumbersOnly) {
  var months = [
    'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 
    'Nov', 'Dec'
  ];

  return '' + padNumber(date.getDate(), '0', 1) + 
   (useNumbersOnly? '-' + padNumber(date.getMonth() + 1, '0', 1) + '-' : ' ' + months[date.getMonth()] + ' ')
    + date.getFullYear();
}

更改 和 的顺序以创建函数。date.getFullYear()padNumber(date.getDate(), '0', 1)dateToYMD()

有关详细信息 repl.it 请参阅示例。

DateFormatter.formatDate(new Date(2010,7,10), 'DD-MMM-YYYY')

=>10-Aug-2010

DateFormatter.formatDate(new Date(), 'YYYY-MM-DD HH:mm:ss')

=>2017-11-22 19:52:37

DateFormatter.formatDate(new Date(2005, 1, 2, 3, 4, 5), 'D DD DDD DDDD, M MM MMM MMMM, YY YYYY, h hh H HH, m mm, s ss, a A')

=>2 02 Wed Wednesday, 2 02 Feb February, 05 2005, 3 03 3 03, 4 04, 5 05, am AM

var DateFormatter = {
  monthNames: [
    "January", "February", "March", "April", "May", "June",
    "July", "August", "September", "October", "November", "December"
  ],
  dayNames: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"],
  formatDate: function (date, format) {
    var self = this;
    format = self.getProperDigits(format, /d+/gi, date.getDate());
    format = self.getProperDigits(format, /M+/g, date.getMonth() + 1);
    format = format.replace(/y+/gi, function (y) {
      var len = y.length;
      var year = date.getFullYear();
      if (len == 2)
        return (year + "").slice(-2);
      else if (len == 4)
        return year;
      return y;
    })
    format = self.getProperDigits(format, /H+/g, date.getHours());
    format = self.getProperDigits(format, /h+/g, self.getHours12(date.getHours()));
    format = self.getProperDigits(format, /m+/g, date.getMinutes());
    format = self.getProperDigits(format, /s+/gi, date.getSeconds());
    format = format.replace(/a/ig, function (a) {
      var amPm = self.getAmPm(date.getHours())
      if (a === 'A')
        return amPm.toUpperCase();
      return amPm;
    })
    format = self.getFullOr3Letters(format, /d+/gi, self.dayNames, date.getDay())
    format = self.getFullOr3Letters(format, /M+/g, self.monthNames, date.getMonth())
    return format;
  },
  getProperDigits: function (format, regex, value) {
    return format.replace(regex, function (m) {
      var length = m.length;
      if (length == 1)
        return value;
      else if (length == 2)
        return ('0' + value).slice(-2);
      return m;
    })
  },
  getHours12: function (hours) {
    // https://stackoverflow.com/questions/10556879/changing-the-1-24-hour-to-1-12-hour-for-the-gethours-method
    return (hours + 24) % 12 || 12;
  },
  getAmPm: function (hours) {
    // https://stackoverflow.com/questions/8888491/how-do-you-display-javascript-datetime-in-12-hour-am-pm-format
    return hours >= 12 ? 'pm' : 'am';
  },
  getFullOr3Letters: function (format, regex, nameArray, value) {
    return format.replace(regex, function (s) {
      var len = s.length;
      if (len == 3)
        return nameArray[value].substr(0, 3);
      else if (len == 4)
        return nameArray[value];
      return s;
    })
  }
}

console.log(DateFormatter.formatDate(new Date(), 'YYYY-MM-DD HH:mm:ss'));
console.log(DateFormatter.formatDate(new Date(), 'D DD DDD DDDD, M MM MMM MMMM, YY YYYY, h hh H HH, m mm, s ss, a A'));
console.log(DateFormatter.formatDate(new Date(2005, 1, 2, 3, 4, 5), 'D DD DDD DDDD, M MM MMM MMMM, YY YYYY, h hh H HH, m mm, s ss, a A'));

格式说明取自 Ionic Framework（它不支持 ， UTC 时区偏移）Z

未经全面测试

我知道有人可能会说这是愚蠢的解决方案，但它确实通过从日期字符串中删除不必要的信息来解决问题。

yourDateObject生产：

2017 年 12 月 13 日星期三 20：40：40 GMT+0200 （EET）

yourDateObject.toString().slice(0, 15);生产：

周三， 12月 13， 2017

这可能有助于解决问题：

var d = new Date();

var options = {   
    day: 'numeric',
    month: 'long', 
    year: 'numeric'
};

console.log(d.toLocaleDateString('en-ZA', options));

new Date().toLocaleDateString()

// "3/21/2018"

更多文档见 developer.mozilla.org

这是修改为具有 3 个字符的月份和 2 位数年份的主要答案：

function formatDate(date) {
    var monthNames = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
    var day = date.getDate(), monthIndex = date.getMonth(), year = date.getFullYear().toString().substr(-2);
    return day + ' ' + monthNames[monthIndex] + ' ' + year;
}

document.write(formatDate(new Date()));

对于任何寻找真正简单的 ES6 解决方案来复制、粘贴和采用的人：

const dateToString = d => `${d.getFullYear()}-${('00' + (d.getMonth() + 1)).slice(-2)}-${('00' + d.getDate()).slice(-2)}` 

// how to use:
const myDate = new Date(Date.parse('04 Dec 1995 00:12:00 GMT'))
console.log(dateToString(myDate)) // 1995-12-04

设置日期格式的其他方法：

function formatDate(dDate,sMode){
    var today = dDate;
    var dd = today.getDate();
    var mm = today.getMonth()+1; //January is 0!
    var yyyy = today.getFullYear();
    if(dd<10) {
        dd = '0'+dd
    }
    if(mm<10) {
        mm = '0'+mm
    }
    if (sMode+""==""){
        sMode = "dd/mm/yyyy";
    }
    if (sMode == "yyyy-mm-dd"){
        return  yyyy + "-" + mm + "-" + dd + "";
    }
    if (sMode == "dd/mm/yyyy"){
        return  dd + "/" + mm + "/" + yyyy;
    }
}

yy= 2 位数年份; = 全年yyyy

M= 数字月份; = 2 位数的月份; = 短月份名称; = 完整月份名称MMMMMMMMM

EEEE= 完整的工作日名称; = 短工作日名称EEE

d= 数字日; = 2 位数的日期dd

h= 小时; = 2 位数小时hh

m= 分钟; = 2 位分钟mm

s= 秒; = 2 位秒ss

S= 毫秒

使用与 Class SimpleDateFormat （Java） 类似的格式

var monthNames = [
  "January", "February", "March", "April", "May", "June", "July",
  "August", "September", "October", "November", "December"
];
var dayOfWeekNames = [
  "Sunday", "Monday", "Tuesday",
  "Wednesday", "Thursday", "Friday", "Saturday"
];
function formatDate(date, formatStr){
    if (!formatStr) {
      formatStr = 'dd/mm/yyyy';
    }
    var day = date.getDate(),
        month = date.getMonth(),
        year = date.getFullYear(),
        hour = date.getHours(),
        minute = date.getMinutes(),
        second = date.getSeconds(),
        miliseconds = date.getMilliseconds(),
        hh = twoDigitPad(hour),
        mm = twoDigitPad(minute),
        ss = twoDigitPad(second),
        EEEE = dayOfWeekNames[date.getDay()],
        EEE = EEEE.substr(0, 3),
        dd = twoDigitPad(day),
        M = month + 1,
        MM = twoDigitPad(M),
        MMMM = monthNames[month],
        MMM = MMMM.substr(0, 3),
        yyyy = year + "",
        yy = yyyy.substr(2, 2)
    ;
    return formatStr
      .replace('hh', hh).replace('h', hour)
      .replace('mm', mm).replace('m', minute)
      .replace('ss', ss).replace('s', second)
      .replace('S', miliseconds)
      .replace('dd', dd).replace('d', day)
      .replace('MMMM', MMMM).replace('MMM', MMM).replace('MM', MM).replace('M', M)
      .replace('EEEE', EEEE).replace('EEE', EEE)
      .replace('yyyy', yyyy)
      .replace('yy', yy)
    ;
}
function twoDigitPad(num) {
    return num < 10 ? "0" + num : num;
}
console.log(formatDate(new Date()));
console.log(formatDate(new Date(), 'EEEE, MMMM d, yyyy hh:mm:ss:S'));
console.log(formatDate(new Date(), 'EEE, MMM d, yyyy hh:mm'));
console.log(formatDate(new Date(), 'yyyy-MM-dd hh:mm:ss:S'));
console.log(formatDate(new Date(), 'yy-MM-dd hh:mm'));

打包解决方案：Luxon 或 date-fns

如果你想使用一个解决方案来满足所有需求，我建议使用 date-fns 或 Luxon。

Luxon托管在Moment.js网站上，由Moment.js开发人员开发，因为Moment.js具有开发人员想要解决但无法解决的限制。

要安装：

npm install luxon或（访问链接了解其他安装方法）yarn add luxon

例：

luxon.DateTime.fromISO('2010-08-10').toFormat('yyyy-LLL-dd');

收益 率：

2010 年 8 月 10 日

手动解决方案

使用与 Moment.js、Class DateTimeFormatter （Java） 和 Class SimpleDateFormat （Java） 类似的格式，我实现了一个全面的解决方案，其中代码易于阅读和修改。您可以显示日期、时间、上午/下午等。有关更多示例，请参阅代码。formatDate(date, patternStr)

例：

formatDate(new Date(), 'EEEE, MMMM d, yyyy HH:mm:ss:S')

(formatDate在下面的代码片段中实现）

收益 率：

2018 年 10 月 12 日星期五 18：11：23：445

通过单击“运行代码片段”来试用代码。

日期和时间模式

yy= 2 位数年份; = 全年yyyy

M= 数字月份; = 2 位数的月份; = 短月份名称; = 完整月份名称MMMMMMMMM

EEEE= 完整的工作日名称; = 短工作日名称EEE

d= 数字日; = 2 位数的日期dd

h= 上午/下午小时; = 2 位数小时上午 / 下午; = 小时; = 2 位数小时hhHHH

m= 分钟; = 2 位数分钟; = 上午/下午mmaaa

s= 秒; = 2 位秒ss

S= 毫秒

var monthNames = [
  "January", "February", "March", "April", "May", "June", "July",
  "August", "September", "October", "November", "December"
];
var dayOfWeekNames = [
  "Sunday", "Monday", "Tuesday",
  "Wednesday", "Thursday", "Friday", "Saturday"
];
function formatDate(date, patternStr){
    if (!patternStr) {
        patternStr = 'M/d/yyyy';
    }
    var day = date.getDate(),
        month = date.getMonth(),
        year = date.getFullYear(),
        hour = date.getHours(),
        minute = date.getMinutes(),
        second = date.getSeconds(),
        miliseconds = date.getMilliseconds(),
        h = hour % 12,
        hh = twoDigitPad(h),
        HH = twoDigitPad(hour),
        mm = twoDigitPad(minute),
        ss = twoDigitPad(second),
        aaa = hour < 12 ? 'AM' : 'PM',
        EEEE = dayOfWeekNames[date.getDay()],
        EEE = EEEE.substr(0, 3),
        dd = twoDigitPad(day),
        M = month + 1,
        MM = twoDigitPad(M),
        MMMM = monthNames[month],
        MMM = MMMM.substr(0, 3),
        yyyy = year + "",
        yy = yyyy.substr(2, 2)
    ;
    // checks to see if month name will be used
    patternStr = patternStr
      .replace('hh', hh).replace('h', h)
      .replace('HH', HH).replace('H', hour)
      .replace('mm', mm).replace('m', minute)
      .replace('ss', ss).replace('s', second)
      .replace('S', miliseconds)
      .replace('dd', dd).replace('d', day)
      
      .replace('EEEE', EEEE).replace('EEE', EEE)
      .replace('yyyy', yyyy)
      .replace('yy', yy)
      .replace('aaa', aaa);
    if (patternStr.indexOf('MMM') > -1) {
        patternStr = patternStr
          .replace('MMMM', MMMM)
          .replace('MMM', MMM);
    }
    else {
        patternStr = patternStr
          .replace('MM', MM)
          .replace('M', M);
    }
    return patternStr;
}
function twoDigitPad(num) {
    return num < 10 ? "0" + num : num;
}
console.log(formatDate(new Date()));
console.log(formatDate(new Date(), 'dd-MMM-yyyy')); //OP's request
console.log(formatDate(new Date(), 'EEEE, MMMM d, yyyy HH:mm:ss.S aaa'));
console.log(formatDate(new Date(), 'EEE, MMM d, yyyy HH:mm'));
console.log(formatDate(new Date(), 'yyyy-MM-dd HH:mm:ss.S'));
console.log(formatDate(new Date(), 'M/dd/yyyy h:mmaaa'));

谢谢你@Gerry提出Luxon。

您不需要任何库。只需提取日期组件并构造字符串即可。以下是获取格式的方法。另请注意月份索引“1 月为 0,2 月为 1，依此类推”。YYYY-MM-DD

// @flow

type Components = {
  day: number,
  month: number,
  year: number
}

export default class DateFormatter {
  // YYYY-MM-DD
  static YYYY_MM_DD = (date: Date): string => {
    const components = DateFormatter.format(DateFormatter.components(date))
    return `${components.year}-${components.month}-${components.day}`
  }

  static format = (components: Components) => {
    return {
      day: `${components.day}`.padStart(2, '0'),
      month: `${components.month}`.padStart(2, '0'),
      year: components.year
    }
  }

  static components = (date: Date) => {
    return {
      day: date.getDate(),
      month: date.getMonth() + 1,
      year: date.getFullYear()
    }
  }
}

一个简单的函数，可以返回日期、日期 + 时间或仅返回时间：

var myDate = dateFormatter("2019-01-24 11:33:24", "date-time");
// >> RETURNS "January 24, 2019 11:33:24"

var myDate2 = dateFormatter("2019-01-24 11:33:24", "date");
// >> RETURNS "January 24, 2019"

var myDate3 = dateFormatter("2019-01-24 11:33:24", "time");
// >> RETURNS "11:33:24"


function dateFormatter(strDate, format){
    var theDate = new Date(strDate);
    if (format=="time")
       return getTimeFromDate(theDate);
    else{
       var dateOptions = {year:'numeric', month:'long', day:'numeric'};
       var formattedDate = theDate.toLocaleDateString("en-US", + dateOptions);
       if (format=="date")
           return formattedDate;
       return formattedDate + " " + getTimeFromDate(theDate);
    }
}

function getTimeFromDate(theDate){
    var sec = theDate.getSeconds();
    if (sec<10)
        sec = "0" + sec;
    var min = theDate.getMinutes();
    if (min<10)
        min = "0" + min;
    return theDate.getHours() + ':'+ min + ':' + sec;
}

若要获取“2010 年 8 月 10 日”，请尝试：

var date = new Date('2010-08-10 00:00:00');
date = date.toLocaleDateString(undefined, {day:'2-digit'}) + '-' + date.toLocaleDateString(undefined, {month:'short'}) + '-' + date.toLocaleDateString(undefined, {year:'numeric'})

有关浏览器支持，请参阅 toLocaleDateString。

该模块可以轻松处理几乎所有情况。 它是 Locutus 更大的 npm 包的一部分，其中包含各种功能，但它可以完全独立于包本身使用，如果不使用 npm，只需复制粘贴/调整一点（从模块更改为函数）。

作为第二个参数，它接受时间戳，时间戳可以来自任何地方，例如 Date.getTime（）。

此外，Locutus 维护了一个更大的 datetime 模块，也在 locutus 包中，这将提供一种更面向对象的使用方式。

在这里，您可以看到其他日期时间函数，作为模块，它们也被证明非常有用。

你可以在这里找到关于参数和格式字符串的文档（请注意，文档站点是一个PHP站点，但locutus实现遵循完全相同的规范）。

日期模块示例

date('H:m:s \\m \\i\\s \\m\\o\\n\\t\\h', 1062402400)//'07:09:40 m is month'

date('F j, Y, g:i a', 1062462400)//'September 2, 2003, 12:26 am'

date('Y W o', 1062462400)//'2003 36 2003'

var $x = date('Y m d', (new Date()).getTime() / 1000) $x = $x + '' var $result = $x.length // 2009 01 09    10

date('W', 1104534000)    //'52'

date('B t', 1104534000)    //'999 31'

date('W U', 1293750000.82); // 2010-12-31    '52 1293750000'

date('W', 1293836400); // 2011-01-01    '52'

date('W Y-m-d', 1293974054); // 2011-01-02    '52 2011-01-02'

这里有一些现成的粘贴时间/日期格式代码，它们不依赖于任何外部模块/库，也不使用 jQuery 或 ES7 或任何东西。与其他一些答案中的代码不同，此代码提供了以下功能组合：

• 它采用 JavaScript Date 对象作为输入
• 它可以将日期显示为本地时区或 UTC
• 它使用一个简单的格式系统“{year4} {month02} {second}”，即使在你写代码后也很容易阅读和理解，不像典型的“%D %m %-”总是迫使你回到文档
• 格式化系统没有任何奇怪的自碰撞，例如一些临时的“DD MM YYYY”系统
• 您可以在此处运行测试并尝试一下

// format_date(date, pattern, utc)
// - date
//   - a JavaScript Date object
//   - use "new Date()" for current time
// - pattern
//   - a string with embedded {codes} like
//     "{year4}-{month02}-{day02}: {dayname3}"
//     see format_date_funcs below for complete list
//   - any other letters go through unchanged
// - utc
//   - if true, shows date in UTC time "zone"
//   - if false/omitted, shows date in local time zone
//
var month_names =
[
  "January", "February", "March", "April", "May", "June", "July",
  "August", "September", "October", "November", "December"
];
var day_of_week_names =
[
  "Sunday", "Monday", "Tuesday",
  "Wednesday", "Thursday", "Friday", "Saturday"
];

function space_pad2(num)
{
    return num < 10 ? " " + num : num;
}

function zero_pad2(num)
{
    return num < 10 ? "0" + num : num;
}

function space_pad3(num)
{
    if (num < 10)
        return "  " + num;
    else if (num < 100)
        return " " + num;
    else
        return num;
}

function zero_pad3(num)
{
    if (num < 10)
        return "00" + num;
    else if (num < 100)
        return "0" + num;
    else
        return num;
}

var format_date_funcs =
{
    // {year4}  = '1902'
    // {year02} =   '02'
    //
    'year4': function(date, utc)
    {
        var year = utc ? date.getUTCFullYear() : date.getFullYear();
        return year;
    },
    'year02': function(date, utc)
    {
        var year = utc ? date.getUTCFullYear() : date.getFullYear();
        return year.toString().substr(2,2);
    },
    // {month}   =  '1' - '12'
    // {month2}  = ' 1' - '12' (space padded)
    // {month02} = '01' - '12'
    //
    'month': function(date, utc)
    {
        var month = utc ? date.getUTCMonth() : date.getMonth(); // [0,11]
        return            month + 1;
    },
    'month2': function(date, utc)
    {
        var month = utc ? date.getUTCMonth() : date.getMonth(); // [0,11]
        return space_pad2(month + 1);
    },
    'month02': function(date, utc)
    {
        var month = utc ? date.getUTCMonth() : date.getMonth(); // [0,11]
        return zero_pad2(month + 1);
    },
    // {monthname}  = 'January'
    // {monthname3} = 'Jan'
    //
    'monthname': function(date, utc)
    {
        var month = utc ? date.getUTCMonth() : date.getMonth(); // [0,11]
        return month_names[month];
    },
    'monthname3': function(date, utc)
    {
        var month = utc ? date.getUTCMonth() : date.getMonth(); // [0,11]
        return month_names[month].substr(0, 3);
    },
    // {day}   =  '1' - '31'
    // {day2}  = ' 1' - '31' (space padded)
    // {day02} = '01' - '31'
    //
    'day': function(date, utc)
    {
        var date = utc ? date.getUTCDate() : date.getDate(); // [1,31]
        return date;
    },
    'day2': function(date, utc)
    {
        var date = utc ? date.getUTCDate() : date.getDate(); // [1,31]
        return space_pad2(date);
    },
    'day02': function(date, utc)
    {
        var date = utc ? date.getUTCDate() : date.getDate(); // [1,31]
        return zero_pad2(date);
    },
    // {dayname}  = 'Tuesday'
    // {dayname3} = 'Tue'
    //
    'dayname': function(date, utc)
    {
        var day = utc ? date.getUTCDay() : date.getDay(); // [0,6]
        return day_of_week_names[day];
    },
    'dayname3': function(date, utc)
    {
        var day = utc ? date.getUTCDay() : date.getDay(); // [0,6]
        return day_of_week_names[day].substr(0,3);
    },
    // {24hour}   =  '0' - '23'
    // {24hour2}  = ' 0' - '23' (space padded)
    // {24hour02} = '00' - '23'
    //
    '24hour': function(date, utc)
    {
        var hour = utc ? date.getUTCHours() : date.getHours(); // [0,23]
        return hour;
    },
    '24hour2': function(date, utc)
    {
        var hour = utc ? date.getUTCHours() : date.getHours(); // [0,23]
        return space_pad2(hour);
    },
    '24hour02': function(date, utc)
    {
        var hour = utc ? date.getUTCHours() : date.getHours(); // [0,23]
        return zero_pad2(hour);
    },
    // {12hour}   =  '1' - '12'
    // {12hour2}  = ' 1' - '12' (space padded)
    // {12hour02} = '01' - '12'
    // {ampm}     = 'am' or 'pm'
    // {AMPM}     = 'AM' or 'PM'
    //
    '12hour': function(date, utc)
    {
        var hour = utc ? date.getUTCHours() : date.getHours(); // [0,23]
        hour = hour % 12; // [0,11]
        if (0 === hour) hour = 12;
        return hour;
    },
    '12hour2': function(date, utc)
    {
        var hour = utc ? date.getUTCHours() : date.getHours(); // [0,23]
        hour = hour % 12; // [0,11]
        if (0 === hour) hour = 12;
        return space_pad2(hour);
    },
    '12hour02': function(date, utc)
    {
        var hour = utc ? date.getUTCHours() : date.getHours(); // [0,23]
        hour = hour % 12; // [0,11]
        if (0 === hour) hour = 12;
        return zero_pad2(hour);
    },
    'ampm': function(date, utc)
    {
        var hour = utc ? date.getUTCHours() : date.getHours(); // [0,23]
        return (hour < 12 ? 'am' : 'pm');
    },
    'AMPM': function(date, utc)
    {
        var hour = utc ? date.getUTCHours() : date.getHours(); // [0,23]
        return (hour < 12 ? 'AM' : 'PM');
    },
    // {minute}   =  '0' - '59'
    // {minute2}  = ' 0' - '59' (space padded)
    // {minute02} = '00' - '59'
    //
    'minute': function(date, utc)
    {
        var minute = utc ? date.getUTCMinutes() : date.getMinutes(); // [0,59]
        return minute;
    },
    'minute2': function(date, utc)
    {
        var minute = utc ? date.getUTCMinutes() : date.getMinutes(); // [0,59]
        return space_pad2(minute);
    },
    'minute02': function(date, utc)
    {
        var minute = utc ? date.getUTCMinutes() : date.getMinutes(); // [0,59]
        return zero_pad2(minute);
    },
    // {second}   =  '0' - '59'
    // {second2}  = ' 0' - '59' (space padded)
    // {second02} = '00' - '59'
    //
    'second': function(date, utc)
    {
        var second = utc ? date.getUTCSeconds() : date.getSeconds(); // [0,59]
        return second;
    },
    'second2': function(date, utc)
    {
        var second = utc ? date.getUTCSeconds() : date.getSeconds(); // [0,59]
        return space_pad2(second);
    },
    'second02': function(date, utc)
    {
        var second = utc ? date.getUTCSeconds() : date.getSeconds(); // [0,59]
        return zero_pad2(second);
    },
    // {msec}   =   '0' - '999'
    // {msec3}  = '  0' - '999' (space padded)
    // {msec03} = '000' - '999'
    //
    'msec': function(date, utc)
    {
        var msec =
            utc ? date.getUTCMilliseconds() : date.getMilliseconds(); // [0,999]
        return msec;
    },
    'msec3': function(date, utc)
    {
        var msec =
            utc ? date.getUTCMilliseconds() : date.getMilliseconds(); // [0,999]
        return space_pad3(msec);
    },
    'msec03': function(date, utc)
    {
        var msec =
            utc ? date.getUTCMilliseconds() : date.getMilliseconds(); // [0,999]
        return zero_pad3(msec);
    },
    // {open} = '{' (in case you actually want '{' in the output)
    //
    'open': function(date, utc)
    {
        return '{';
    },
    // {close} = '}' (in case you actually want '}' in the output)
    //
    'close': function(date, utc)
    {
        return '}';
    },
};

function format_date(date, pattern, utc)
{
    if (!pattern)
    {
        pattern = '{month}/{day}/{year4}';
    }

    var ret = '';

    while (pattern.length > 0)
    {
        var s = pattern.indexOf('{');
        var e = pattern.indexOf('}');
        //console.log('s ' + s + ' e ' + e);
        if (-1 !== s && -1 !== e && s < e)
        {
            // - there is a well-formed {foo} in range [s,e]
            // - first we emit range [0,s) as literal
        }
        else
        {
            // - rest of string has no {} or has malformed }{ or { or }
            // - just emit the rest of the string as literal and be done
            s = pattern.length;
        }
        // emit range [0,s) as literal
        if (s > 0)
        {
            ret += pattern.substr(0, s);
            pattern = pattern.substr(s);
            e -= s;
            s = 0;
        }

        if (0 === pattern.length) break;

        // emit range [s=0,e] by evaluating code
        console.assert(0 === s); // position of {
        console.assert(e > 0);  // position of }
        console.assert('{' === pattern.substr(s, 1));
        console.assert('}' === pattern.substr(e, 1));
        var code = pattern.substr(1,e-1);
        var func = format_date_funcs[code];
        console.assert(func);
        ret += func(date, utc);

        pattern = pattern.substr(e+1);
    }

    return ret;
}

if (1) // test format_date
{
    var fmt = '[';
    for (var func in format_date_funcs)
    {
        if (!format_date_funcs.hasOwnProperty(func)) continue;
        fmt += '{' + func + '}/';
    }
    fmt += ']';
    var now = new Date();
    console.log(fmt);
    console.log(format_date(now, fmt, false /* utc */));
    console.log(format_date(now, fmt, true /* utc */));
}

你应该看看 DayJs，它是 momentJs 的重制版，但面向模块化架构，所以更轻量级。

Moment.js 的快速 2kB 替代方案，具有相同的现代 API

Day.js 是一个极简的 JavaScript 库，它使用与 Moment.js 兼容的 API 解析、验证、操作和显示现代浏览器的日期和时间。如果您使用 Moment.js，您已经知道如何使用 Day.js。

var date = Date.now();
const formatedDate = dayjs(date).format("YYYY-MM-DD")
console.log(formatedDate);

<script src="https://cdnjs.cloudflare.com/ajax/libs/dayjs/1.8.16/dayjs.min.js" crossorigin="anonymous"></script>

截至 2019 年，看起来您可以获取 toLocaleDateString 以仅返回某些部分，然后您可以根据需要加入它们：

var date = new Date();

console.log(date.toLocaleDateString("en-US", { day: 'numeric' }) 
            + "-"+ date.toLocaleDateString("en-US", { month: 'short' })
            + "-" + date.toLocaleDateString("en-US", { year: 'numeric' }) );

> 16-Nov-2019

console.log(date.toLocaleDateString("en-US", { month: 'long' }) 
            + " " + date.toLocaleDateString("en-US", { day: 'numeric' }) 
            + ", " + date.toLocaleDateString("en-US", { year: 'numeric' }) );

> November 16, 2019

为了将日期格式化为 例如，您可能需要使用 和 ES6 数组解构。10-Aug-2010.toDateString()

const formattedDate = new Date().toDateString()
// The above yields e.g. 'Mon Jan 06 2020'

const [, month, day, year] = formattedDate.split(' ')

const ddMmmYyyy = `${day}-${month}-${year}`
// or
const ddMmmYyyy = [day, month, year].join('-')

这个函数的灵感来自于 Java 的 SimpleDateFormat 提供了各种格式，例如：

dd-MMM-yyyy → 17-Jul-2018
yyyyMMdd'T'HHmmssXX → 20180717T120856+0900
yyyy-MM-dd'T'HH:mm:ssXXX → 2018-07-17T12:08:56+09:00
E, dd MMM yyyy HH:mm:ss Z → Tue, 17 Jul 2018 12:08:56 +0900
yyyy.MM.dd 'at' hh:mm:ss Z → 2018.07.17 at 12:08:56 +0900
EEE, MMM d, ''yy → Tue, Jul 17, '18
h:mm a → 12:08 PM
hh 'o''''clock' a, X → 12 o'clock PM, +09

代码示例：

function formatWith(formatStr, date, opts) {

    if (!date) {
        date = new Date();
    }

    opts = opts || {};

    let _days = opts.days;

    if (!_days) {
        _days = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
    }

    let _months = opts.months;

    if (!_months) {
        _months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
    }

    const pad = (number, strDigits, isUnpad) => {
        const strNum = number.toString();
        if (!isUnpad && strNum.length > strDigits.length) {
            return strNum;
        } else {
            return ('0000' + strNum).slice(-strDigits.length);
        }
    };

    const timezone = (date, letter) => {
        const chunk = [];
        const offset = -date.getTimezoneOffset();
        chunk.push(offset === 0 ? 'Z' : offset > 0 ? '+' : '-');//add Z or +,-
        if (offset === 0) return chunk;
        chunk.push(pad(Math.floor(offset / 60), '00'));//hour
        if (letter === 'X') return chunk.join('');
        if (letter === 'XXX') chunk.push(':');
        chunk.push(pad((offset % 60), '00'));//min
        return chunk.join('');
    };

    const ESCAPE_DELIM = '\0';
    const escapeStack = [];

    const escapedFmtStr = formatStr.replace(/'.*?'/g, m => {
        escapeStack.push(m.replace(/'/g, ''));
        return ESCAPE_DELIM + (escapeStack.length - 1) + ESCAPE_DELIM;
    });

    const formattedStr = escapedFmtStr
        .replace(/y{4}|y{2}/g, m => pad(date.getFullYear(), m, true))
        .replace(/M{3}/g, m => _months[date.getMonth()])
        .replace(/M{1,2}/g, m => pad(date.getMonth() + 1, m))
        .replace(/M{1,2}/g, m => pad(date.getMonth() + 1, m))
        .replace(/d{1,2}/g, m => pad(date.getDate(), m))
        .replace(/H{1,2}/g, m => pad(date.getHours(), m))
        .replace(/h{1,2}/g, m => {
            const hours = date.getHours();
            return pad(hours === 0 ? 12 : hours > 12 ? hours - 12 : hours, m);
        })
        .replace(/a{1,2}/g, m => date.getHours() >= 12 ? 'PM' : 'AM')
        .replace(/m{1,2}/g, m => pad(date.getMinutes(), m))
        .replace(/s{1,2}/g, m => pad(date.getSeconds(), m))
        .replace(/S{3}/g, m => pad(date.getMilliseconds(), m))
        .replace(/[E]+/g, m => _days[date.getDay()])
        .replace(/[Z]+/g, m => timezone(date, m))
        .replace(/X{1,3}/g, m => timezone(date, m))
    ;

    const unescapedStr = formattedStr.replace(/\0\d+\0/g, m => {
        const unescaped = escapeStack.shift();
        return unescaped.length > 0 ? unescaped : '\'';
    });

    return unescapedStr;
}

// Let's format with above function
const dateStr = '2018/07/17 12:08:56';
const date = new Date(dateStr);
const patterns = [
    "dd-MMM-yyyy",
    "yyyyMMdd'T'HHmmssXX",//ISO8601
    "yyyy-MM-dd'T'HH:mm:ssXXX",//ISO8601EX
    "E, dd MMM yyyy HH:mm:ss Z",//RFC1123(RFC822) like email
    "yyyy.MM.dd 'at' hh:mm:ss Z",//hh shows 1-12
    "EEE, MMM d, ''yy",
    "h:mm a",
    "hh 'o''''clock' a, X",
];

for (let pattern of patterns) {
    console.log(`${pattern} → ${formatWith(pattern, date)}`);
}

你可以把它作为一个库

它也作为 NPM 模块发布。您可以在 Node.js 上使用它，也可以在浏览器的 CDN 中使用它。

节点.js

const {SimpleDateFormat} = require('@riversun/simple-date-format');

在浏览器中

<script src="https://cdn.jsdelivr.net/npm/@riversun/simple-date-f[email protected]/dist/simple-date-format.js"></script>

按如下方式编写代码。

const date = new Date('2018/07/17 12:08:56');
const sdf = new SimpleDateFormat();
console.log(sdf.formatWith("yyyy-MM-dd'T'HH:mm:ssXXX", date));//to be "2018-07-17T12:08:56+09:00"

GitHub 上的源代码：

https://github.com/riversun/simple-date-format

两个纯 JavaScript 单行代码

在这个答案中，我发展了JD Smith的想法。我能够缩短 JD Smith 正则表达式。

let format= d=> d.toString().replace(/\w+ (\w+) (\d+) (\d+).*/,'$2-$1-$3');

console.log( format(Date()) );

Dave's 也基于 JD Smith 的想法，但他避免了正则表达式并给出了一个非常好的解决方案 - 我稍微缩短了他的解决方案（通过更改 split 参数）并在包装器中将其不透明。

let format= (d,a=d.toString().split` `)=> a[2]+"-"+a[1]+"-"+a[3];

console.log( format(Date()) );

它在 Internet Explorer 11、Firefox 和 Chrome 中的工作方式相同（选择 en-UK 时，Chrome 80.x 显示 12 小时格式）。

const d = new Date('2010/08/05 23:45') // 26.3.2020
const dtfUK = new Intl.DateTimeFormat('UK', { year: 'numeric', month: '2-digit', day: '2-digit',
        hour: '2-digit',minute: '2-digit', second: '2-digit' }); //
const dtfUS = new Intl.DateTimeFormat('en', { year: 'numeric', month: '2-digit', day: '2-digit',
        hour: '2-digit',minute: '2-digit', second: '2-digit' }); //
console.log(dtfUS.format(d)); // 08/05/2010 11:45:00 PM
console.log(dtfUK.format(d)); // 05.08.2010 23:45:00
/* node.js:
08/05/2010, 11:45:00 PM
2010-08-05 23:45:00
*/

更一般的东西呢？

var d = new Date('2010-08-10T10:34:56.789Z');
var str = d.toDateString() + // Tue Aug 10 2010
    ' ' + d.toTimeString().split(' ')[0] + // 12:34:56, GMT+0x00 (GMT+0x:00)
    ' ' + (d.getMonth() + 101) + // 108
    ' ' + d.getMilliseconds(); // 789
console.log(str); // Tue Aug 10 2010 12:34:56 108 789
console.log(//   $1 Tue  $2 Aug  $3 11     $4 2020 $5 12   $6 34   $7 56    $8 108  $9 789
    str.replace(/(\S{3}) (\S{3}) (\d{1,2}) (\d{4}) (\d{2}):(\d{2}):(\d{2}) 1(\d{2}) (\d{1,3})/, '$3-$2-$4 $5:$6.$9 ($1)')
); // 10-Aug-2010 12:34.789 (Tue)
/*
$1: Tue  Week Day string
$2: Aug  Month short text
$3: 11   Day
$4: 2010 Year
$5: 12   Hour
$6: 34   Minute
$7: 56   Seconds
$8: 08   Month
$9: 789  Milliseconds
*/

或者，例如，1 行 IIFE“库” ;-)

console.log(
    (function (frm, d) { return [d.toDateString(), d.toTimeString().split(' ')[0], (d.getMonth() + 101), d.getMilliseconds()].join(' ').replace(/(\S{3}) (\S{3}) (\d{1,2}) (\d{4}) (\d{2}):(\d{2}):(\d{2}) 1(\d{2}) (\d{1,3})/, frm); })
    ('$4/$8/$3 $5:$6 ($1)', new Date())
);

如果不需要，您可以删除无用的部件和/或更改索引。

也许这有助于一些有意或无意地一个接一个地寻找多种日期格式的人。请找到代码： 我在当前日期使用 Moment.js 格式函数（今天是 29-06-2020）： 结果：06/28/20var startDate = moment(new Date()).format('MM/DD/YY');

它只保留年份部分：20 作为“06/28/20”，如果我运行语句，结果是“Mon Jun 28 1920 00：00：00 GMT+0530（印度标准时间）”。new Date(startDate)

然后，当我在“06/28/20”上使用另一种格式时： startDate = moment（startDate ）.format（'MM-DD-YYYY'）;结果：06-28-1920，在Google Chrome和Firefox浏览器中，第二次尝试的正确日期为：06-28-2020。

但是在Internet Explorer中，它有问题。由此我了解到我们可以在给定日期应用一种日期格式。如果我们想要第二个日期格式，它应该应用于新日期，而不是第一个日期格式的结果。还要注意，第一次应用“MM-DD-YYYY”，下一次应用“MM-DD-YY”在Internet Explorer中工作。为了清楚理解，请在链接中找到我的问题：在 Internet Explorer 11 中使用 Moment.js 日期格式时日期出错。

function convert_month(i = 0, option = "num") { // i = index

  var object_months = [
    { num: 01, short: "Jan", long: "January" },
    { num: 02, short: "Feb", long: "Februari" }, 
    { num: 03, short: "Mar", long: "March" },          
    { num: 04, short: "Apr", long: "April" },
    { num: 05, short: "May", long: "May" },
    { num: 06, short: "Jun", long: "Juni" },
    { num: 07, short: "Jul", long: "July" },
    { num: 08, short: "Aug", long: "August" },
    { num: 09, short: "Sep", long: "September" },
    { num: 10, short: "Oct", long: "October" },
    { num: 11, short: "Nov", long: "November" },
    { num: 12, short: "Dec", long: "December" }
  ];
        
  return object_months[i][option];

}
      
var d = new Date();
      
// https://stackoverflow.com/questions/1408289/how-can-i-do-string-interpolation-in-javascript
var num   = `${d.getDate()}-${convert_month(d.getMonth())}-${d.getFullYear()}`;
var short = `${d.getDate()}-${convert_month(d.getMonth(), "short")}-${d.getFullYear()}`;
var long  = `${d.getDate()}-${convert_month(d.getMonth(), "long")}-${d.getFullYear()}`;

document.querySelector("#num").innerHTML = num;
document.querySelector("#short").innerHTML = short;
document.querySelector("#long").innerHTML = long;

<p>Numeric  : <span id="num"></span> (default)</p>
<p>Short    : <span id="short"></span></p>
<p>Long     : <span id="long"></span></p>

这可以帮助：

export const formatDateToString = date => {
    if (!date) {
        return date;
    }
    try {
        return format(parse(date, 'yyyy-MM-dd', new Date()), 'dd/MM/yyyy');
    } catch (error) {
        return 'invalid date';
    }
};

构造函数 （和 ） 在构造日期时只接受一种格式作为参数，即 ISO 8601：DateDate.parse()

// new Date('YYYY-MM-DDTHH:mm:ss.sssZ')
const date = new Date('2017-08-15')

但是由于浏览器的差异和不一致，强烈建议不要从字符串中解析 a（MDN 建议不要使用日期字符串创建日期）。

建议的替代方法是直接从数值数据生成 Date 实例，如下所示：

new Date(2017, 7, 15) // Month is zero-indexed

那就是解析。现在，要将日期格式化为您想要的字符串，您有几个选项是 Date 对象的原生选项（尽管我相信没有一个选项符合您所需的格式）：

date.toString()       // 'Wed Jan 23 2019 17:23:42 GMT+0800 (Singapore Standard Time)'
date.toDateString()   // 'Wed Jan 23 2019'
date.toLocaleString() // '23/01/2019, 17:23:42'
date.toGMTString()    // 'Wed, 23 Jan 2019 09:23:42 GMT'
date.toUTCString()    // 'Wed, 23 Jan 2019 09:23:42 GMT'
date.toISOString()    // '2019-01-23T09:23:42.079Z'

对于其他格式选项，恐怕您将不得不求助于诸如Moment.js，day.js等库。

感谢本文中的 Zell Liew 提供的日期格式设置提示。

使用此过程

const MONTHS = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sept', 'Oct', 'Nov', 'Dec']

const date = new Date()

const dateString = `${date.getDate()}-${MONTHS[date.getMonth()]}-${date.getFullYear()}`

console.log(dateString)

字符串转换

// date 
const dateConvert = {
  dasher: dt => {
    let m = (dt.getMonth() + 1) === 13 ? 1 : (dt.getMonth() + 1);
    m = m < 10 ? `0${m}` : m.toString();
    let d = dt.getDate();
    d = d < 10 ? `0${d}` : d.toString();
    return `${dt.getFullYear()}-${m}-${d}`;
  }, 
  slasher: dt => {
    return dateConvert.slash(dateConvert.dasher(dt));
  }, 
  dash: str => {
    // 03/11/2022 -> 2022-03-11
    let [d, m, y] = str.split('/');
    return `${y}-${m}-${d}`;
  }, 
  slash: str => {
    // 2022-03-11 -> 03/11/2022
    let [y, m, d] = str.split('-');
    return `${d}/${m}/${y}`
  }
}

// console.log(dateConvert.dasher(new Date('01/31/2001')));

Javascript 方法提供了一种方便的日期格式设置方法。Intl.DateTimeFormat

以下是如何构建所需的格式：

const date = new Date("2010-08-10");

let d=new Intl.DateTimeFormat('en-GB',{year:"numeric", month:"short",day:"2-digit"}).format(date).split(" ").join("-");

console.log(d);

简单地说，你可以这样做：-

 let date = new Date().toLocaleDateString('en-us',{day: 'numeric'})
 let month = new Date().toLocaleDateString('en-us',{month: 'long'})
 let year = new Date().toLocaleDateString('en-us',{year: 'numeric'})
 const FormattedDate = `${date}-${month}-${year}`
 console.log(FormattedDate) // 26-March-2022

就我而言，我已将日期形式“01/07/2022”格式化为“2022-07-01”

const formatDate = date => {
const d = new Date(date)
let month = (d.getMonth() + 1).toString()
let day = d.getDate().toString()
const year = d.getFullYear()
if (month.length < 2) {
    month = '0' + month
}
if (day.length < 2) {
    day = '0' + day
}
return [ year, month, day ].join('-')
}

console.log(formatDate('01/07/2022'))

嗨，大家好，我有这个代码，用于向日期添加日期和格式。

 const FechaMaxima = new Date();
 FechaMaxima.setDate(FechaMaxima.getDate() + 6);
 FechaMaxima.toISOString().substring(0, 10);

虽然new Date（）.toISOString（）.slice（0， 10）; 很时髦，适合我的正常用例，但我不喜欢前几个答案中的任何一个，以获得更定制的字符串，并给自己几分钟的时间尽可能地时髦的高尔夫和单线。

我不太明白我想出的解决方案，所以这里是......

((d,x)=>`${d.getFullYear()}-${x(d.getMonth()+1)}-${x(d.getDate())}`)
    (new Date(), (x)=>x.toString().padStart(2,"0"))

// today that produces
// '2022-09-28'
// the same as new Date().toISOString().slice(0, 10)
// but provides a good framework for other orders or values

Pseudo-IIFE 获胜。

当然，这里解决的问题是......

1. 您可能需要使用前导零设置小于 10 的天和月的格式。
   • 因此，传入一个转换为字符串的函数。padStart
2. 你需要在那里得到相同的日期，而不是一遍又一遍地。new Date()
   • 获取 “now” （） 并作为参数传入以重用。new Date()
3. 你必须将 1 加到 .getMonth
   • 这样做。

即使你需要映射到月份缩写或其他东西，你也可以做类似的技巧，并不是说它会很可爱。

((d,x,y)=>`${x(d.getDate())} ${y(d.getMonth())} ${d.getFullYear()}`)
    (
     new Date(), 
     (x)=>x.toString().padStart(2,"0"), 
     (m)=>"jan,feb,mar,apr,may,jun,jul,aug,sep,oct,nov,dec".split(',')[m]
    )

// As of this writing, that yields...
// '28 sep 2022'

（显然，为了增加高尔夫感，从两者中删除了空格;不希望代码块滚动）

...尽管出于某种奇怪的原因，除了从控制台创建测试值之外，我很难推荐它。真的很奇怪，没有，而且这是我能排成一排的。toString('yyyy-mm-dd')

简单的格式化程序：

function fmt(date, format = 'YYYY-MM-DDThh:mm:ss') {
  const pad2 = (n) => n.toString().padStart(2, '0');

  const map = {
    YYYY: date.getFullYear(),
    MM: pad2(date.getMonth() + 1),
    DD: pad2(date.getDate()),
    hh: pad2(date.getHours()),
    mm: pad2(date.getMinutes()),
    ss: pad2(date.getSeconds()),
  };

  return Object.entries(map).reduce((prev, entry) => prev.replace(...entry), format);
}

// Usage
console.log(
  fmt(new Date(), 'YYYY-MM-DDThh:mm:ss') // '2023-03-04T10:30:24'
);
console.log(
  fmt(new Date(), 'MM/DD/YYYY, hh:mm:ss') // '03/04/2023, 10:30:24'
);

打字稿版本

可以轻松增强以支持所需的任何格式字符串。当像这样的通用解决方案非常容易创建，并且日期格式在应用程序中经常出现时，我不建议在整个应用程序中对日期格式代码进行硬编码。它更难阅读并隐藏你的意图。格式字符串清楚地显示了您的意图。

原型函数

interface Date {
    format(formatString: string): string;
}

Date.prototype.format = function (formatString: string): string {
  return Object.entries({
    YYYY: this.getFullYear(),
    YY: this.getFullYear().toString().substring(2),
    yyyy: this.getFullYear(),
    yy: this.getFullYear().toString().substring(2),
    MMMM: this.toLocaleString('default', { month: 'long' }),
    MMM: this.toLocaleString('default', { month: 'short' }),
    MM: (this.getMonth() + 1).toString().padStart(2, '0'),
    M: this.getMonth() + 1,
    DDDD: this.toLocaleDateString('default', { weekday: 'long' }),
    DDD: this.toLocaleDateString('default', { weekday: 'short' }),
    DD: this.getDate().toString().padStart(2, '0'),
    D: this.getDate(),
    dddd: this.toLocaleDateString('default', { weekday: 'long' }),
    ddd: this.toLocaleDateString('default', { weekday: 'short' }),
    dd: this.getDate().toString().padStart(2, '0'),
    d: this.getDate(),
    HH: this.getHours().toString().padStart(2, '0'), // military
    H: this.getHours().toString(), // military
    hh: (this.getHours() % 12).toString().padStart(2, '0'),
    h: (this.getHours() % 12).toString(),
    mm: this.getMinutes().toString().padStart(2, '0'),
    m: this.getMinutes(),
    SS: this.getSeconds().toString().padStart(2, '0'),
    S: this.getSeconds(),
    ss: this.getSeconds().toString().padStart(2, '0'),
    s: this.getSeconds(),
    TTT: this.getMilliseconds().toString().padStart(3, '0'),
    ttt: this.getMilliseconds().toString().padStart(3, '0'),
    AMPM: this.getHours() < 13 ? 'AM' : 'PM',
    ampm: this.getHours() < 13 ? 'am' : 'pm',
  }).reduce((acc, entry) => {
    return acc.replace(entry[0], entry[1].toString())
  }, formatString)
}

演示

function unitTest() {
    var d: Date = new Date()
    console.log(d.format('MM/dd/yyyy hh:mm:ss')) // 12/14/2022 03:38:31
    console.log(d.format('yyyy-MM-dd HH:mm:ss')) // 2022-12-14 15:38:31
}

unitTest()

Javascript 版本

是一样的，只是删除接口，以及冒号后面的类型名称及其关联的冒号。

片段

Date.prototype.format = function(formatString) {
  return Object.entries({
    YYYY: this.getFullYear(),
    YY: this.getFullYear().toString().substring(2),
    yyyy: this.getFullYear(),
    yy: this.getFullYear().toString().substring(2),
    MMMM: this.toLocaleString('default', { month: 'long'  }),
    MMM: this.toLocaleString('default',  { month: 'short' }),
    MM: (this.getMonth() + 1).toString().padStart(2, '0'),
    M: this.getMonth() + 1,
    DDDD: this.toLocaleDateString('default', { weekday: 'long'  }),
    DDD: this.toLocaleDateString('default',  { weekday: 'short' }),
    DD: this.getDate().toString().padStart(2, '0'),
    D: this.getDate(),
    dddd: this.toLocaleDateString('default', { weekday: 'long'  }),
    ddd: this.toLocaleDateString('default',  { weekday: 'short' }),
    dd: this.getDate().toString().padStart(2, '0'),
    d: this.getDate(),
    HH: this.getHours().toString().padStart(2, '0'), // military
    H: this.getHours().toString(), // military
    hh: (this.getHours() % 12).toString().padStart(2, '0'),
    h: (this.getHours() % 12).toString(),
    mm: this.getMinutes().toString().padStart(2, '0'),
    m: this.getMinutes(),
    SS: this.getSeconds().toString().padStart(2, '0'),
    S: this.getSeconds(),
    ss: this.getSeconds().toString().padStart(2, '0'),
    s: this.getSeconds(),
    TTT: this.getMilliseconds().toString().padStart(3, '0'),
    ttt: this.getMilliseconds().toString().padStart(3, '0'),
    AMPM: this.getHours() < 13 ? 'AM' : 'PM',
    ampm: this.getHours() < 13 ? 'am' : 'pm',
  }).reduce((acc, entry) => {
    return acc.replace(entry[0], entry[1].toString())
  }, formatString)
}



function unitTest() {
  var d = new Date()
  console.log(d.format('MM/dd/yyyy hh:mm:ss')) // 12/14/2022 03:38:31
  console.log(d.format('yyyy-MM-dd HH:mm:ss')) // 2022-12-14 15:38:31
}

unitTest()

将日期格式化为不同的格式

let objectDate = new Date();



let day = objectDate.getDate();
console.log(day); // 12


let currentmo = objectDate.getMonth();
month = currentmo + 1;
console.log(month + 1); // 1


let year = objectDate.getFullYear();
console.log(year); // 2023



// Now you can set it accordingly


// dd/mm/yyyy
console.log(day + '/' + month + '/' + year);


// mm/dd/yyyy
console.log(month + '/' + day + '/' + year);

试试这个代码 - https://bbbootstrap.com/code/format-date-javascript-49065802

例： "2023-04-25 00:01:23"

var currentdate = new Date();
var startedAt = currentdate.getFullYear() + "-" +
    (currentdate.getMonth() + 1).toString().padStart(2, '0') + "-" +
    currentdate.getDate().toString().padStart(2, '0') + " " +
    currentdate.getHours().toString().padStart(2, '0') + ":" +
    currentdate.getMinutes().toString().padStart(2, '0') + ":" +
    currentdate.getSeconds().toString().padStart(2, '0');

我只是用“T”拆分它

  date = "2023-11-15T00:00:00.000+00:00"
  myDate = date.split('T')[0]