在 JavaScript 中将字符串解析为日期

Question

如何在 JavaScript 中将字符串转换为 Date 对象？

var st = "date in some format"
var dt = new Date();

var dt_st = // st in Date format, same as dt.

Answer 1

字符串解析的最佳字符串格式是日期 ISO 格式以及 JavaScript Date 对象构造函数。

ISO 格式示例：YYYY-MM-DD 或 YYYY-MM-DDTHH:MM:SS。

但是等等！仅使用“ISO 格式”本身并不能可靠地工作。字符串有时被解析为 UTC，有时被解析为本地时间（基于浏览器供应商和版本）。最佳实践应始终是将日期存储为 UTC 并按 UTC 进行计算。

要将日期解析为 UTC，请附加 Z - 例如：new Date('2011-04-11T10:20:30Z')。

要显示 UTC 日期，请使用 .toUTCString(),
要显示用户当地时间的日期，请使用 .toString()。

有关 MDN | 的更多信息日期和此答案。

为了兼容旧版 Internet Explorer（小于 9 的 IE 版本不支持日期构造函数中的 ISO 格式），您应该将日期时间字符串表示形式拆分为其各个部分，然后您可以使用日期时间部分来使用构造函数，例如： new Date('2011 '、'04' - 1、'11'、'11'、'51'、'00'）。请注意，月份数必须少 1。

---

替代方法 - 使用适当的库：

您还可以利用库 Moment.js允许解析具有指定时区的日期。

Answer 2

不幸的是我发现

var mydate = new Date('2014-04-03');
console.log(mydate.toDateString());

返回“2014 年 4 月 2 日星期三”。我知道这听起来很疯狂，但它发生在某些用户身上。

防弹解决方案如下：

var parts ='2014-04-03'.split('-');
// Please pay attention to the month (parts[1]); JavaScript counts months from 0:
// January - 0, February - 1, etc.
var mydate = new Date(parts[0], parts[1] - 1, parts[2]); 
console.log(mydate.toDateString());

Answer 3

var st = "26.04.2013";
var pattern = /(\d{2})\.(\d{2})\.(\d{4})/;
var dt = new Date(st.replace(pattern,'$3-$2-$1'));

输出将是：

dt => Date {Fri Apr 26 2013}

Answer 4

function stringToDate(_date,_format,_delimiter)
{
            var formatLowerCase=_format.toLowerCase();
            var formatItems=formatLowerCase.split(_delimiter);
            var dateItems=_date.split(_delimiter);
            var monthIndex=formatItems.indexOf("mm");
            var dayIndex=formatItems.indexOf("dd");
            var yearIndex=formatItems.indexOf("yyyy");
            var month=parseInt(dateItems[monthIndex]);
            month-=1;
            var formatedDate = new Date(dateItems[yearIndex],month,dateItems[dayIndex]);
            return formatedDate;
}

stringToDate("17/9/2014","dd/MM/yyyy","/");
stringToDate("9/17/2014","mm/dd/yyyy","/")
stringToDate("9-17-2014","mm-dd-yyyy","-")

Answer 5

建议：我建议使用包含很多格式的日期包，因为时区和格式时间管理确实是一个大问题，moment js解决了很多格式。您可以轻松地从简单的字符串解析日期到日期，但我认为支持所有格式和日期变体是一项艰巨的工作。

更新：Moment 现已弃用，一个不错的替代方案目前是 datefns https://date-fns.org/

---

moment.js (http://momentjs.com/) 是一个完整且良好的包，用于使用日期和支持 ISO 8601 字符串。

您可以添加字符串日期和格式。

moment("12-25-1995", "MM-DD-YYYY");

您可以检查日期是否有效。

moment("not a real date").isValid(); //Returns false

一些显示示例

let dt = moment("02-01-2019", "MM-DD-YYYY");
console.log(dt.fromNow()+' |'+dt.format('LL')) 
// output: "3 months ago | February 1, 2019"

请参阅文档
http://momentjs.com/docs/#/parsing/string-format/

Answer 6

将其作为参数传递给 Date()：

var st = "date in some format"
var dt = new Date(st);

您可以使用以下方式访问日期、月份、年份：dt.getMonth()。

Answer 7

只需 new Date(st);

假设它是正确的格式。

Answer 8

如果您可以使用很棒的 luxon 库，您可以使用例如轻松解析您的日期

var luxonDate = DateTime.fromISO("2014-09-15T09:00:00");

并可以访问JS 日期对象通过

luxonDate().toJSDate();

---

旧答案使用 MomentJS

var momentDate = moment("2014-09-15 09:00:00");
momentDate ().toDate();

Answer 9

对于那些正在寻找小型智能解决方案的人：

String.prototype.toDate = function(format)
{
  var normalized      = this.replace(/[^a-zA-Z0-9]/g, '-');
  var normalizedFormat= format.toLowerCase().replace(/[^a-zA-Z0-9]/g, '-');
  var formatItems     = normalizedFormat.split('-');
  var dateItems       = normalized.split('-');

  var monthIndex  = formatItems.indexOf("mm");
  var dayIndex    = formatItems.indexOf("dd");
  var yearIndex   = formatItems.indexOf("yyyy");
  var hourIndex     = formatItems.indexOf("hh");
  var minutesIndex  = formatItems.indexOf("ii");
  var secondsIndex  = formatItems.indexOf("ss");

  var today = new Date();

  var year  = yearIndex>-1  ? dateItems[yearIndex]    : today.getFullYear();
  var month = monthIndex>-1 ? dateItems[monthIndex]-1 : today.getMonth()-1;
  var day   = dayIndex>-1   ? dateItems[dayIndex]     : today.getDate();

  var hour    = hourIndex>-1      ? dateItems[hourIndex]    : today.getHours();
  var minute  = minutesIndex>-1   ? dateItems[minutesIndex] : today.getMinutes();
  var second  = secondsIndex>-1   ? dateItems[secondsIndex] : today.getSeconds();

  return new Date(year,month,day,hour,minute,second);
};

示例：

"22/03/2016 14:03:01".toDate("dd/mm/yyyy hh:ii:ss");
"2016-03-29 18:30:00".toDate("yyyy-mm-dd hh:ii:ss");

Answer 10

new Date(2000, 10, 1) 将为您提供“Wed Nov 01 2000 00:00:00 GMT+0100 (CET)”

请注意，月份 0 为您提供一月

Answer 11

在我看来，这是最好、更简单的解决方案：

只需将日期字符串（使用 ISO 格式）与最后输入“T00:00:00”并使用 JavaScript Date() 构造函数，如下例所示。

const dateString = '2014-04-03'
var mydate = new Date(dateString + "T00:00:00");
console.log(mydate.toDateString());

关于上述解决方案的一些细节（但可选阅读）：

在 ISO 格式中，如果您提供时间并且 Z 不存在于末尾
字符串，日期将改为本地时区UTC 时间
区。这意味着，当以这种方式设置日期时，无需
指定时区，JavaScript 将使用本地浏览器的时间
区。当获取日期时，不指定时区
同样，结果也会转换为浏览器的时区。和，
默认，几乎每个日期JavaScript 中的方法（除了一个）
还为您提供本地时区的日期/时间（只有在以下情况下您才能获得 UTC）：
您指定 UTC）。因此，在本地/浏览器时区中使用您可能
不会得到不需要的结果，因为你的
本地/浏览时区和 UTC 时区，这是主要的时区之一
对日期字符串转换的抱怨。但如果你会用这个
解决方案，了解您的背景并意识到您在做什么。
还要注意日期时间字符串中省略 T 或 Z
在不同的浏览器中可以给出不同的结果。

重要的是要注意，上面的示例将为您提供与下面的示例完全相同的返回值，这是该问题中投票第二多的答案：

var parts ='2014-04-03'.split('-');
// Please pay attention to the month (parts[1]); JavaScript counts months from 0:
// January - 0, February - 1, etc.
var mydate = new Date(parts[0], parts[1] - 1, parts[2]); 
console.log(mydate.toDateString());

主要区别在于，此处提供的第一个示例比第二个示例更简单，甚至更防错一个（至少在我看来，如下所述）。

因为如果您调用 JavaScript Date() 构造函数< /a> date 只有一个 ISO 格式的日期字符串参数（第一个示例），它不接受高于其逻辑限制的值（因此，如果您将 13 作为月份或 32 作为日期，则会得到无效日期）。

但是，当您使用具有多个日期参数的相同构造函数（第二个示例）时，高于逻辑限制的参数将调整为相邻值 并且您不会收到无效日期错误（因此，如果您给出 13 作为月份，它将调整为 1，而不是给出您的日期无效）。

或者替代（和第三）解决方案将两者混合，使用第一个示例只是为了验证日期字符串，如果它有效，则使用第二个示例（这样您就可以避免第一个示例的浏览器可能不一致，同时避免高于第二个示例的逻辑限制的参数的权限）。

像这样（也接受部分日期）：

function covertStringToDate(dateString) {
    //dateString should be in ISO format: "yyyy-mm-dd", "yyyy-mm" or "yyyy"
    if(new Date(dateString).toString() === "Invalid Date") {
        return false
    } else {
        const onlyNumbers = dateString.replace(/\D/g, ""); 
        const year = onlyNumbers.slice(0,4) 
        const month = onlyNumbers.slice(4,6)
        const day = onlyNumbers.slice(6,8)
        if(!month){
            return(new Date(year))
        } else if (!day) {
            return(new Date(year, month - 1))
        } else {
            return(new Date(year, month - 1, day))
        }        
    }
}

第四个替代方案（也是最后一个建议）是使用适当的第三个库（例如 moment 或 date-fns）

参考文献：

• https://www.w3schools.com/js/js_date_formats.asp
• https://css-tricks.com/everything-you-need-to-know-about-date-in-javascript /
• https://developer. mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Date#parameters

Answer 12

如果你想从格式“dd/MM/yyyy”转换。这是一个示例：

var pattern = /^(\d{1,2})\/(\d{1,2})\/(\d{4})$/;
var arrayDate = stringDate.match(pattern);
var dt = new Date(arrayDate[3], arrayDate[2] - 1, arrayDate[1]);

此解决方案适用于 IE 版本低于 9 的情况。

Answer 13

时间戳应该转换为数字

var ts = '1471793029764';
ts = Number(ts); // cast it to a Number
var date = new Date(ts); // works

var invalidDate = new Date('1471793029764'); // does not work. Invalid Date

Answer 14

Date.parse 几乎可以满足您的需求。它在 am/pm 部分卡住了，但是通过一些黑客攻击，你可以让它工作：

var str = 'Sun Apr 25, 2010 3:30pm',
    timestamp;

timestamp = Date.parse(str.replace(/[ap]m$/i, ''));

if(str.match(/pm$/i) >= 0) {
    timestamp += 12 * 60 * 60 * 1000;
}

Answer 15

今天的性能

（2020.05.08）我对所选解决方案进行了测试 - 两种情况：输入日期为 ISO8601 字符串（Ad、Bd、Cd、Dd、Ed），输入日期为 时间戳（At、Ct、Dt）。解决方案 Bd、Cd、Ct 不会返回 js Date 对象作为结果，但我添加它们是因为它们可能有用，但我没有将它们与有效的解决方案进行比较。此结果对于大规模日期解析非常有用。

结论

• 对于所有浏览器的 ISO 日期和时间戳，解决方案 new Date (Ad) 比 moment.js (Dd) 快 50-100 倍
• 解决方案 new Date (Ad) 大约是 10 倍比 parseDate 更快 (Ed)
• 如果我们需要在所有浏览器上从 ISO 日期获取时间戳，解决方案 Date.parse(Bd) 是最快的

详细信息

I在 Chrome 81.0、Safari 13.1、Firefox 75.0 上的 MacOs High Sierra 10.13.6 上执行测试。解决方案 parseDate（编辑）使用 new Date(0) 并手动设置 UTC 日期组件。

let ds = '2020-05-14T00:00Z'; // Valid ISO8601 UTC date
let ts = +'1589328000000';    // timestamp

let Ad = new Date(ds);
let Bd = Date.parse(ds);
let Cd = moment(ds);
let Dd = moment(ds).toDate();
let Ed = parseDate(ds);

let At = new Date(ts);
let Ct = moment(ts);
let Dt = moment(ts).toDate();

log = (n,d) => console.log(`${n}: ${+d} ${d}`);

console.log('from date string:', ds)
log('Ad', Ad);
log('Bd', Bd);
log('Cd', Cd);
log('Dd', Dd);
log('Ed', Ed);
console.log('from timestamp:', ts)
log('At', At);
log('Ct', Ct);
log('Dt', Dt);



function parseDate(dateStr) {
  let [year,month,day] = dateStr.split(' ')[0].split('-');
  let d=new Date(0);
  d.setUTCFullYear(year);
  d.setUTCMonth(month-1);
  d.setUTCDate(day)
  return d;
}

<script src="https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.19.1/moment-with-locales.min.js"></script>

This snippet only presents used soultions  

chrome 的结果

Answer 16

转换为格式 pt-BR：

    var dateString = "13/10/2014";
    var dataSplit = dateString.split('/');
    var dateConverted;

    if (dataSplit[2].split(" ").length > 1) {

        var hora = dataSplit[2].split(" ")[1].split(':');
        dataSplit[2] = dataSplit[2].split(" ")[0];
        dateConverted = new Date(dataSplit[2], dataSplit[1]-1, dataSplit[0], hora[0], hora[1]);

    } else {
        dateConverted = new Date(dataSplit[2], dataSplit[1] - 1, dataSplit[0]);
    }

我希望能帮助别人！

Answer 17

我为此创建了一个小提琴，您可以在任何日期字符串上使用 toDate() 函数并提供日期格式。这将返回一个 Date 对象。
https://jsfiddle.net/Sus​​hil231088/q56yd0rp/

"17/9/2014".toDate("dd/MM/yyyy", "/")

Answer 18

为了在 js 中将字符串转换为日期，我使用 http://momentjs.com/

moment().format('MMMM Do YYYY, h:mm:ss a'); // August 16th 2015, 4:17:24 pm
moment().format('dddd');                    // Sunday
moment().format("MMM Do YY");               // Aug 16th 15
moment().format('YYYY [escaped] YYYY');     // 2015 escaped 2015
moment("20111031", "YYYYMMDD").fromNow(); // 4 years ago
moment("20120620", "YYYYMMDD").fromNow(); // 3 years ago
moment().startOf('day').fromNow();        // 16 hours ago
moment().endOf('day').fromNow();          // in 8 hours

Answer 19

我创建了这个函数来将任何 Date 对象转换为 UTC Date 对象。

function dateToUTC(date) {
    return new Date(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate(), date.getUTCHours(), date.getUTCMinutes(), date.getUTCSeconds());
}


dateToUTC(new Date());

Answer 20

您可以使用正则表达式解析字符串以详细说明时间，然后创建日期或任何返回格式，例如：

//example : let dateString = "2018-08-17 01:02:03.4"

function strToDate(dateString){
    let reggie = /(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2}).(\d{1})/
  , [,year, month, day, hours, minutes, seconds, miliseconds] = reggie.exec(dateString)
  , dateObject = new Date(year, month-1, day, hours, minutes, seconds, miliseconds);
  return dateObject;
}
alert(strToDate(dateString));

Answer 21

你可以试试这个：

function formatDate(userDOB) {
  const dob = new Date(userDOB);

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

  const day = dob.getDate();
  const monthIndex = dob.getMonth();
  const year = dob.getFullYear();

  // return day + ' ' + monthNames[monthIndex] + ' ' + year;
  return `${day} ${monthNames[monthIndex]} ${year}`;
}

console.log(formatDate('1982-08-10'));

Answer 22

这个答案基于 Kassem 的答案，但它也处理两位数的年份。我提交了对卡西姆答案的编辑，但如果未获得批准，我也会将其作为单独的答案提交。

function stringToDate(_date,_format,_delimiter) {
        var formatLowerCase=_format.toLowerCase();
        var formatItems=formatLowerCase.split(_delimiter);
        var dateItems=_date.split(_delimiter);
        var monthIndex=formatItems.indexOf("mm");
        var dayIndex=formatItems.indexOf("dd");
        var yearIndex=formatItems.indexOf("yyyy");
        var year = parseInt(dateItems[yearIndex]); 
        // adjust for 2 digit year
        if (year < 100) { year += 2000; }
        var month=parseInt(dateItems[monthIndex]);
        month-=1;
        var formatedDate = new Date(year,month,dateItems[dayIndex]);
        return formatedDate;
}

stringToDate("17/9/14","dd/MM/yyyy","/");
stringToDate("17/9/2014","dd/MM/yyyy","/");
stringToDate("9/17/2014","mm/dd/yyyy","/")
stringToDate("9-17-2014","mm-dd-yyyy","-")

Answer 23

var date = new Date(year, month, day);

或者

var date = new Date('01/01/1970');

“01-01-1970”格式的日期字符串在 FireFox 中不起作用，因此最好在日期格式字符串中使用“/”而不是“-”。

Answer 24

还有另一种方法可以做到这一点：

String.prototype.toDate = function(format) {
    format = format || "dmy";
    var separator = this.match(/[^0-9]/)[0];
    var components = this.split(separator);
    var day, month, year;
    for (var key in format) {
        var fmt_value = format[key];
        var value = components[key];
        switch (fmt_value) {
            case "d":
                day = parseInt(value);
                break;
            case "m":
                month = parseInt(value)-1;
                break;
            case "y":
                year = parseInt(value);
        }
    }
    return new Date(year, month, day);
};
a = "3/2/2017";
console.log(a.toDate("dmy"));
// Date 2017-02-03T00:00:00.000Z

Answer 25

如果您需要在转换为日期格式之前检查字符串的内容：

// Convert 'M/D/YY' to Date()
mdyToDate = function(mdy) {
  var d = mdy.split(/[\/\-\.]/, 3);

  if (d.length != 3) return null;

  // Check if date is valid
  var mon = parseInt(d[0]), 
      day = parseInt(d[1]),
      year= parseInt(d[2]);
  if (d[2].length == 2) year += 2000;
  if (day <= 31 && mon <= 12 && year >= 2015)
    return new Date(year, mon - 1, day);

  return null; 
}

Answer 26

我创建了 parseDateTime 函数来将字符串转换为日期对象，它在所有浏览器（包括 IE 浏览器）中工作，检查是否有人需要，参考
https://github.com/Umesh-Markande/在所有浏览器中解析字符串到日期

    function parseDateTime(datetime) {
            var monthNames = [
                "January", "February", "March",
                "April", "May", "June", "July",
                "August", "September", "October",
                "November", "December"
              ];
            if(datetime.split(' ').length == 3){
                var date = datetime.split(' ')[0];
                var time = datetime.split(' ')[1].replace('.00','');
                var timearray = time.split(':');
                var hours = parseInt(time.split(':')[0]);
                var format = datetime.split(' ')[2];
                var bits = date.split(/\D/);
                date = new Date(bits[0], --bits[1], bits[2]); /* if you change format of datetime which is passed to this function, you need to change bits e.x ( bits[0], bits[1], bits[2 ]) position as per date, months and year it represent bits array.*/
                var day = date.getDate();
                var monthIndex = date.getMonth();
                var year = date.getFullYear();
                if ((format === 'PM' || format === 'pm') && hours !== 12) {
                    hours += 12;
                    try{  time = hours+':'+timearray[1]+':'+timearray[2] }catch(e){ time = hours+':'+timearray[1] }
                } 
                var formateddatetime = new Date(monthNames[monthIndex] + ' ' + day + '  ' + year + ' ' + time);
                return formateddatetime;
            }else if(datetime.split(' ').length == 2){
                var date = datetime.split(' ')[0];
                var time = datetime.split(' ')[1];
                var bits = date.split(/\D/);
                var datetimevalue = new Date(bits[0], --bits[1], bits[2]); /* if you change format of datetime which is passed to this function, you need to change bits e.x ( bits[0], bits[1], bits[2 ]) position as per date, months and year it represent bits array.*/
                var day = datetimevalue.getDate();
                var monthIndex = datetimevalue.getMonth();
                var year = datetimevalue.getFullYear();
                var formateddatetime = new Date(monthNames[monthIndex] + ' ' + day + '  ' + year + ' ' + time);
                return formateddatetime;
            }else if(datetime != ''){
                var bits = datetime.split(/\D/);
                var date = new Date(bits[0], --bits[1], bits[2]); /* if you change format of datetime which is passed to this function, you need to change bits e.x ( bits[0], bits[1], bits[2 ]) position as per date, months and year it represent bits array.*/
                return date;
            }
            return datetime;
        }

    var date1 = '2018-05-14 05:04:22 AM';   // yyyy-mm-dd hh:mm:ss A
    var date2 = '2018/05/14 05:04:22 AM';   // yyyy/mm/dd hh:mm:ss A
    var date3 = '2018/05/04';   // yyyy/mm/dd
    var date4 = '2018-05-04';   // yyyy-mm-dd
    var date5 = '2018-05-14 15:04:22';   // yyyy-mm-dd HH:mm:ss
    var date6 = '2018/05/14 14:04:22';   // yyyy/mm/dd HH:mm:ss

    console.log(parseDateTime(date1))
    console.log(parseDateTime(date2))
    console.log(parseDateTime(date3))
    console.log(parseDateTime(date4))
    console.log(parseDateTime(date5))
    console.log(parseDateTime(date6))

**Output---**
Mon May 14 2018 05:04:22 GMT+0530 (India Standard Time)
Mon May 14 2018 05:04:22 GMT+0530 (India Standard Time)
Fri May 04 2018 00:00:00 GMT+0530 (India Standard Time)
Fri May 04 2018 00:00:00 GMT+0530 (India Standard Time)
Mon May 14 2018 15:04:22 GMT+0530 (India Standard Time)
Mon May 14 2018 14:04:22 GMT+0530 (India Standard Time)

Answer 27

ISO 8601 式的日期字符串虽然非常优秀，但仍未得到广泛支持。

这是一个很好的资源，可以帮助您确定应该使用哪种日期字符串格式：

http://dygraphs.com/date- format.html

是的，这意味着您的日期字符串可以像

"2014/10/13 23:57:52" 一样简单
而不是
“2014-10-13 23:57:52”

Answer 28

作为此处解释内容的插件，您可以使用 new Date() 创建日期，并使用非常有用的 toLocaleDateString() 函数

示例：

console.log(new Date('1970-01- 01').toLocaleDateString('es-ES')) // -->这将输出“1/1/1970”

Answer 29

                //little bit of code for Converting dates 

                var dat1 = document.getElementById('inputDate').value;
                var date1 = new Date(dat1)//converts string to date object
                alert(date1);
                var dat2 = document.getElementById('inputFinishDate').value;
                var date2 = new Date(dat2)
                alert(date2);

Answer 30

使用这段代码：（我的问题已经用这段代码解决了）

function dateDiff(date1, date2){
var diff = {}                           // Initialisation du retour
var tmp = date2 - date1;

tmp = Math.floor(tmp/1000);             // Nombre de secondes entre les 2 dates
diff.sec = tmp % 60;                    // Extraction du nombre de secondes

tmp = Math.floor((tmp-diff.sec)/60);    // Nombre de minutes (partie entière)
diff.min = tmp % 60;                    // Extraction du nombre de minutes

tmp = Math.floor((tmp-diff.min)/60);    // Nombre d'heures (entières)
diff.hour = tmp % 24;                   // Extraction du nombre d'heures

tmp = Math.floor((tmp-diff.hour)/24);   // Nombre de jours restants
diff.day = tmp;

return diff;

}