使用 JavaScript 比较两个日期

var date = new Date(); // will give you todays date.

// following calls, will let you set new dates.
setDate()   
setFullYear()   
setHours()  
setMilliseconds()   
setMinutes()    
setMonth()  
setSeconds()    
setTime()

var yesterday = new Date();
yesterday.setDate(...date info here);

if(date>yesterday)  // will compare dates

什么格式？

如果你构造一个 Javascript Date 对象，你可以只减去它们得到毫秒的差异（编辑：或只是比较它们）：

js>t1 = new Date()
Thu Jan 29 2009 14:19:28 GMT-0500 (Eastern Standard Time)
js>t2 = new Date()
Thu Jan 29 2009 14:19:31 GMT-0500 (Eastern Standard Time)
js>t2-t1
2672
js>t3 = new Date('2009 Jan 1')
Thu Jan 01 2009 00:00:00 GMT-0500 (Eastern Standard Time)
js>t1-t3
2470768442
js>t1>t3
true

Date 对象将执行您想要的操作 - 为每个日期构造一个，然后使用 、 或 进行比较。><<=>=

、 、 和 运算符要求您使用==!====!==date.getTime()

var d1 = new Date();
var d2 = new Date(d1);
var same = d1.getTime() === d2.getTime();
var notSame = d1.getTime() !== d2.getTime();

需要明确的是，仅直接使用日期对象检查相等性是行不通的

var d1 = new Date();
var d2 = new Date(d1);

console.log(d1 == d2);   // prints false (wrong!) 
console.log(d1 === d2);  // prints false (wrong!)
console.log(d1 != d2);   // prints true  (wrong!)
console.log(d1 !== d2);  // prints true  (wrong!)
console.log(d1.getTime() === d2.getTime()); // prints true (correct)

不过，我建议您使用下拉列表或一些类似的受约束形式的日期输入而不是文本框，以免您发现自己陷入了输入验证地狱。

出于好奇，date.getTime（） 文档：

返回指定日期的数值，作为自 1970 年 1 月 1 日 00：00：00 UTC 以来的毫秒数。（返回先前时间的负值。

为了在 JavaScript 中从自由文本创建日期，您需要将其解析到对象中。Date

您可以使用 which 获取自由文本并尝试将其转换为新日期，但如果您可以控制页面，我建议使用 HTML 选择框或日期选择器，例如 YUI 日历控件或 jQuery UI Datepicker。Date.parse()

正如其他人所指出的那样，一旦你有了日期，你就可以使用简单的算术来减去日期，并通过将数字（以秒为单位）除以一天中的秒数（60*60*24 = 86400）将其转换回天数。

在 javascript 中比较日期的最简单方法是首先将其转换为 Date 对象，然后比较这些日期对象。

在下面，您可以找到一个具有三个功能的对象：

• 日期.比较（a，b）

  返回一个数字：

  • -1 如果 a < b
  • 如果 a = b，则为 0
  • 1 如果 a > b
  • 如果 a 或 b 是非法日期，则为 NaN

• dates.inRange （d，开始，结束）

  返回布尔值或 NaN：

  • 如果 D 介于起点和终点之间（含），则为 true。
  • 如果 d 在开始之前或结束之后，则为 false。
  • NaN，如果一个或多个日期是非法的。

• 日期.convert

  由其他函数用于将其输入转换为日期对象。输入可以是

  • a date-object ：按原样返回输入。
  • 数组：解释为 [年，月，日]。注意月份是 0-11。
  • a 数字：解释为自 1970 年 1 月 1 日以来的毫秒数（时间戳）
  • 字符串：支持几种不同的格式，如“YYYY/MM/DD”、“MM/DD/YYYY”、“Jan 31 2009”等。
  • 对象：解释为具有年、月和日期属性的对象。注意月份是 0-11。

.

// Source: http://stackoverflow.com/questions/497790
var dates = {
    convert:function(d) {
        // Converts the date in d to a date-object. The input can be:
        //   a date object: returned without modification
        //  an array      : Interpreted as [year,month,day]. NOTE: month is 0-11.
        //   a number     : Interpreted as number of milliseconds
        //                  since 1 Jan 1970 (a timestamp) 
        //   a string     : Any format supported by the javascript engine, like
        //                  "YYYY/MM/DD", "MM/DD/YYYY", "Jan 31 2009" etc.
        //  an object     : Interpreted as an object with year, month and date
        //                  attributes.  **NOTE** month is 0-11.
        return (
            d.constructor === Date ? d :
            d.constructor === Array ? new Date(d[0],d[1],d[2]) :
            d.constructor === Number ? new Date(d) :
            d.constructor === String ? new Date(d) :
            typeof d === "object" ? new Date(d.year,d.month,d.date) :
            NaN
        );
    },
    compare:function(a,b) {
        // Compare two dates (could be of any type supported by the convert
        // function above) and returns:
        //  -1 : if a < b
        //   0 : if a = b
        //   1 : if a > b
        // NaN : if a or b is an illegal date
        // NOTE: The code inside isFinite does an assignment (=).
        return (
            isFinite(a=this.convert(a).valueOf()) &&
            isFinite(b=this.convert(b).valueOf()) ?
            (a>b)-(a<b) :
            NaN
        );
    },
    inRange:function(d,start,end) {
        // Checks if date in d is between dates in start and end.
        // Returns a boolean or NaN:
        //    true  : if d is between start and end (inclusive)
        //    false : if d is before start or after end
        //    NaN   : if one or more of the dates is illegal.
        // NOTE: The code inside isFinite does an assignment (=).
       return (
            isFinite(d=this.convert(d).valueOf()) &&
            isFinite(start=this.convert(start).valueOf()) &&
            isFinite(end=this.convert(end).valueOf()) ?
            start <= d && d <= end :
            NaN
        );
    }
}

function datesEqual(a, b)
{
   return (!(a>b || b>a))
}

假设您得到了日期对象 A 和 B，得到它们的 EPOC 时间值，然后减去得到以毫秒为单位的差值。

var diff = +A - +B;

就这样。

“some”发布的代码的改进版本

/* Compare the current date against another date.
 *
 * @param b  {Date} the other date
 * @returns   -1 : if this < b
 *             0 : if this === b
 *             1 : if this > b
 *            NaN : if a or b is an illegal date
*/ 
Date.prototype.compare = function(b) {
  if (b.constructor !== Date) {
    throw "invalid_date";
  }

 return (isFinite(this.valueOf()) && isFinite(b.valueOf()) ? 
          (this>b)-(this<b) : NaN 
        );
};

用法：

  var a = new Date(2011, 1-1, 1);
  var b = new Date(2011, 1-1, 1);
  var c = new Date(2011, 1-1, 31);
  var d = new Date(2011, 1-1, 31);

  assertEquals( 0, a.compare(b));
  assertEquals( 0, b.compare(a));
  assertEquals(-1, a.compare(c));
  assertEquals( 1, c.compare(a));

到目前为止，最简单的方法是从一个日期中减去另一个日期并比较结果。

var oDateOne = new Date();
var oDateTwo = new Date();

console.log(oDateOne - oDateTwo === 0);
console.log(oDateOne - oDateTwo < 0);
console.log(oDateOne - oDateTwo > 0);

如果以下是您的日期格式，则可以使用此代码：

var first = '2012-11-21';
var second = '2012-11-03';
if(parseInt(first.replace(/-/g,""),10) > parseInt(second.replace(/-/g,""),10)){
   //...
}

它将检查数字是否大于。2012112120121103

您可以使用以下代码：

var firstValue = "2012-05-12".split('-');
var secondValue = "2014-07-12".split('-');

 var firstDate=new Date();
 firstDate.setFullYear(firstValue[0],(firstValue[1] - 1 ),firstValue[2]);

 var secondDate=new Date();
 secondDate.setFullYear(secondValue[0],(secondValue[1] - 1 ),secondValue[2]);     

  if (firstDate > secondDate)
  {
   alert("First Date  is greater than Second Date");
  }
 else
  {
    alert("Second Date  is greater than First Date");
  }

还要查看 MDN 文章中的 Date 类。

我通常像在数据库中一样存储。Datestimestamps(Number)

当我需要比较时，我只是在这些时间戳或

将其转换为 Date 对象，然后在必要时进行比较。> <

请注意，除非您的变量是同一 Date 对象的引用，否则 == 或 === 无法正常工作。

首先将这些 Date 对象转换为 timestamp（number），然后比较它们的相等性。

日期到时间戳

var timestamp_1970 = new Date(0).getTime(); // 1970-01-01 00:00:00
var timestamp = new Date().getTime(); // Current Timestamp

时间戳到日期

var timestamp = 0; // 1970-01-01 00:00:00
var DateObject = new Date(timestamp);

减去两个日期得到以毫秒为单位的差值，如果得到的日期相同0

function areSameDate(d1, d2){
    return d1 - d2 === 0
}

关系运算符可用于比较 JavaScript 日期：<<=>>=

var d1 = new Date(2013, 0, 1);
var d2 = new Date(2013, 0, 2);
d1 <  d2; // true
d1 <= d2; // true
d1 >  d2; // false
d1 >= d2; // false

但是，相等运算符不能用于比较日期（值），因为：==!====!==

• 对于严格或抽象的比较，两个不同的对象永远不会相等。
• 仅当操作数引用同一 Object 时，比较 Objects 的表达式才为 true。

您可以使用以下任一方法比较相等日期的值：

var d1 = new Date(2013, 0, 1);
var d2 = new Date(2013, 0, 1);
/*
 * note: d1 == d2 returns false as described above
 */
d1.getTime() == d2.getTime(); // true
d1.valueOf() == d2.valueOf(); // true
Number(d1)   == Number(d2);   // true
+d1          == +d2;          // true

Date.getTime（） 并返回自 1970 年 1 月 1 日 00：00 UTC 以来的毫秒数。函数和一元运算符都在后台调用方法。Date.valueOf()Number+valueOf()

比较，像往常一样，但任何涉及或应该使用前缀的内容。这样：<>=====+

const x = new Date('2013-05-23');
const y = new Date('2013-05-23');

// less than, greater than is fine:
console.log('x < y', x < y); // false
console.log('x > y', x > y); // false
console.log('x <= y', x <= y); // true
console.log('x >= y', x >= y); // true
console.log('x === y', x === y); // false, oops!

// anything involving '==' or '===' should use the '+' prefix
// it will then compare the dates' millisecond values

console.log('+x === +y', +x === +y); // true

简答题

下面是一个函数，如果 from dateTime > 到 dateTime 演示在运行中，则返回 {boolean}

var from = '08/19/2013 00:00'
var to = '08/12/2013 00:00 '

function isFromBiggerThanTo(dtmfrom, dtmto){
   return new Date(dtmfrom).getTime() >=  new Date(dtmto).getTime() ;
}
console.log(isFromBiggerThanTo(from, to)); //true

解释

jsFiddle

var date_one = '2013-07-29 01:50:00',
date_two = '2013-07-29 02:50:00';
//getTime() returns the number of milliseconds since 01.01.1970.
var timeStamp_date_one = new Date(date_one).getTime() ; //1375077000000 
console.log(typeof timeStamp_date_one);//number 
var timeStamp_date_two = new Date(date_two).getTime() ;//1375080600000 
console.log(typeof timeStamp_date_two);//number 

由于您现在在数字类型中同时拥有两个日期时间 您可以将它们与任何 Comparison 操作进行比较

（ >， < ，= ，！= ，== ，！== ，>= 和 <=）

然后

如果您熟悉自定义日期和时间格式字符串，则此库应执行完全相同的操作，并帮助您格式化日期和时间 dtmFRM，无论您是以日期、时间字符串还是 unix 格式传递C#

用法

var myDateTime = new dtmFRM();

alert(myDateTime.ToString(1375077000000, "MM/dd/yyyy hh:mm:ss ampm"));
//07/29/2013 01:50:00 AM

alert(myDateTime.ToString(1375077000000,"the year is yyyy and the day is dddd"));
//this year is 2013 and the day is Monday

alert(myDateTime.ToString('1/21/2014', "this month is MMMM and the day is dd"));
//this month is january and the day is 21

演示

您所要做的就是在库文件中传递这些格式中的任何一种js

仅比较日期（忽略时间组件）：

Date.prototype.sameDay = function(d) {
  return this.getFullYear() === d.getFullYear()
    && this.getDate() === d.getDate()
    && this.getMonth() === d.getMonth();
}

用法：

if(date1.sameDay(date2)) {
    // highlight day on calendar or something else clever
}

我不再建议修改内置对象。请尝试以下操作：prototype

function isSameDay(d1, d2) {
  return d1.getFullYear() === d2.getFullYear() &&
    d1.getDate() === d2.getDate() &&
    d1.getMonth() === d2.getMonth();
}


console.log(isSameDay(new Date('Jan 15 2021 02:39:53 GMT-0800'), new Date('Jan 15 2021 23:39:53 GMT-0800')));
console.log(isSameDay(new Date('Jan 15 2021 10:39:53 GMT-0800'), new Date('Jan 16 2021 10:39:53 GMT-0800')));

注意：将返回您所在时区的年/月/日;如果您想检查两个日期是否在同一天，在不同的时区，我建议使用时区感知库。

例如：

> (new Date('Jan 15 2021 01:39:53 Z')).getDate()  // Jan 15 in UTC
14  // Returns "14" because I'm in GMT-08

在比较对象之前，请尝试将它们的两个毫秒数设置为零，例如 。DatesDate.setMilliseconds(0);

在某些情况下，对象是在 javascript 中动态创建的，如果继续打印 ，您将看到毫秒数发生变化，这将阻止两个日期相等。DateDate.getTime()

为了在许多现有选项中增加另一种可能性，您可以尝试：

if (date1.valueOf()==date2.valueOf()) .....

...这似乎对我有用。当然，您必须确保两个日期都不是未定义的......

if ((date1?date1.valueOf():0)==(date2?date2.valueOf():0) .....

这样，如果两者都未定义，我们可以确保进行积极的比较，或者......

if ((date1?date1.valueOf():0)==(date2?date2.valueOf():-1) .....

...如果你希望他们不相等。

假设您处理此或此日期格式，则可以按此方式比较日期2014[:-/.]06[:-/.]0606[:-/.]06[:-/.]2014

var a = '2014.06/07', b = '2014-06.07', c = '07-06/2014', d = '07/06.2014';

parseInt(a.replace(/[:\s\/\.-]/g, '')) == parseInt(b.replace(/[:\s\/\.-]/g, '')); // true
parseInt(c.replace(/[:\s\/\.-]/g, '')) == parseInt(d.replace(/[:\s\/\.-]/g, '')); // true
parseInt(a.replace(/[:\s\/\.-]/g, '')) < parseInt(b.replace(/[:\s\/\.-]/g, '')); // false
parseInt(c.replace(/[:\s\/\.-]/g, '')) > parseInt(d.replace(/[:\s\/\.-]/g, '')); // false

正如你所看到的，我们去掉分隔符，然后比较整数。

var date_today=new Date();
var formated_date = formatDate(date_today);//Calling formatDate Function

var input_date="2015/04/22 11:12 AM";

var currentDateTime = new Date(Date.parse(formated_date));
var inputDateTime   = new Date(Date.parse(input_date));

if (inputDateTime <= currentDateTime){
    //Do something...
}

function formatDate(date) {
    var hours = date.getHours();
    var minutes = date.getMinutes();
    var ampm = hours >= 12 ? 'PM' : 'AM';

    hours = hours % 12;
    hours = hours ? hours : 12; // the hour '0' should be '12'
    hours   = hours < 10 ? '0'+hours : hours ;

    minutes = minutes < 10 ? '0'+minutes : minutes;

    var strTime = hours+":"+minutes+ ' ' + ampm;
    return  date.getFullYear()+ "/" + ((date.getMonth()+1) < 10 ? "0"+(date.getMonth()+1) :
    (date.getMonth()+1) ) + "/" + (date.getDate() < 10 ? "0"+date.getDate() :
    date.getDate()) + " " + strTime;
}

通过 Moment.js

Jsfiddle：http://jsfiddle.net/guhokemk/1/

function compare(dateTimeA, dateTimeB) {
    var momentA = moment(dateTimeA,"DD/MM/YYYY");
    var momentB = moment(dateTimeB,"DD/MM/YYYY");
    if (momentA > momentB) return 1;
    else if (momentA < momentB) return -1;
    else return 0;
}

alert(compare("11/07/2015", "10/07/2015"));

如果大于dateTimeAdateTimeB

如果等于，则该方法返回 0dateTimeAdateTimeB

如果小于dateTimeAdateTimeB

比较两个日期的一种方法是使用 dates.js 库。

返回一个数字的方法，该数字表示以下结果之一：Date.compare(Date date1, Date date2)

• -1 = date1小于 。date2
• 0= 值相等。
• 1 = date1大于 。date2

注意 - 仅比较日期部分：

当我们比较 javascript 中的两个日期时。它还需要考虑小时、分钟和秒。因此，如果我们只需要比较日期，则采用以下方法：

var date1= new Date("01/01/2014").setHours(0,0,0,0);

var date2= new Date("01/01/2014").setHours(0,0,0,0);

现在：将像魅力一样工作。if date1.valueOf()> date2.valueOf()

在 JavaScript 中比较日期非常容易......JavaScript 内置了日期比较系统，这使得进行比较变得非常容易......

只需按照以下步骤比较 2 个日期值，例如，您有 2 个输入，每个输入都有一个日期值，您可以比较它们......String

1. 您从输入中获取了 2 个字符串值，您想比较它们，它们如下：

var date1 = '01/12/2018';
var date2 = '12/12/2018';

2.它们需要作为日期值进行比较，因此只需将它们转换为日期，使用，为了简单解释，我只是重新分配它们，但您可以随心所欲地进行：Date Objectnew Date()

date1 = new Date(date1);
date2 = new Date(date2);

3. 现在简单地比较它们，使用> < >= <=

date1 > date2;  //false
date1 < date2;  //true
date1 >= date2; //false
date1 <= date2; //true

注意时区

javascript 日期没有时区的概念。这是一个时间点（自纪元以来的刻度），具有方便的函数，用于在“本地”时区中与字符串之间转换。如果要像在座的每个人都在做的那样，使用日期对象处理日期，则希望日期在相关日期的开头表示 UTC 午夜。这是一个常见且必要的约定，它允许您使用日期，而不管日期的创建季节或时区如何。因此，您需要非常警惕地管理时区的概念，尤其是在创建午夜 UTC 日期对象时。

大多数情况下，您希望日期反映用户的时区。单击今天是否是您的生日。新西兰和美国的用户同时点击并获得不同的日期。在这种情况下，请执行此操作...

// create a date (utc midnight) reflecting the value of myDate and the environment's timezone offset.
new Date(Date.UTC(myDate.getFullYear(),myDate.getMonth(), myDate.getDate()));

有时，国际可比性胜过当地的准确性。在这种情况下，请执行此操作...

// the date in London of a moment in time. Device timezone is ignored.
new Date(Date.UTC(myDate.getUTCYear(), myDate.getyUTCMonth(), myDate.getUTCDate()));

现在，您可以按照其他答案的建议直接比较日期对象。

在创建时注意管理时区后，还需要确保在转换回字符串表示形式时将时区排除在外。因此，您可以安全地使用...

• toISOString()
• getUTCxxx()
• getTime() //returns a number with no time or timezone.
• .toLocaleDateString("fr",{timezone:"UTC"}) // whatever locale you want, but ALWAYS UTC.

并且完全避免其他一切，尤其是......

• getYear(),,getMonth()getDate()

简单的方法是，

var first = '2012-11-21';
var second = '2012-11-03';

if (new Date(first) > new Date(second) {
    .....
}

性能

今天 2020.02.27 我在 MacOs High Sierra v10.13.6 上的 Chrome v80.0、Safari v13.0.5 和 Firefox 73.0.1 上对所选解决方案进行测试

结论

• 解决方案 （D） 和 （E） 对于所有浏览器来说是最快的d1==d2d1===d2
• 溶液（A）比（B）快（两者都是中等速度）getTimevalueOf
• 解决方案 F、L、N 是所有浏览器中最慢的

详

在下面的代码片段中，介绍了性能测试中使用的解决方案。您可以在您的机器中执行测试 这里

function A(d1,d2) {
	return d1.getTime() == d2.getTime();
}

function B(d1,d2) {
	return d1.valueOf() == d2.valueOf();
}

function C(d1,d2) {
	return Number(d1)   == Number(d2);
}

function D(d1,d2) {
	return d1 == d2;
}

function E(d1,d2) {
	return d1 === d2;
}

function F(d1,d2) {
	return (!(d1>d2 || d2>d1));
}

function G(d1,d2) {
	return d1*1 == d2*1;
}

function H(d1,d2) {
	return +d1 == +d2;
}

function I(d1,d2) {
	return !(+d1 - +d2);
}

function J(d1,d2) {
	return !(d1 - d2);
}

function K(d1,d2) {
	return d1 - d2 == 0;
}

function L(d1,d2) {
	return !((d1>d2)-(d1<d2));
}

function M(d1,d2) {
  return d1.getFullYear() === d2.getFullYear()
    && d1.getDate() === d2.getDate()
    && d1.getMonth() === d2.getMonth();
}

function N(d1,d2) {
	return (isFinite(d1.valueOf()) && isFinite(d2.valueOf()) ? !((d1>d2)-(d1<d2)) : false );
}


// TEST

let past= new Date('2002-12-24'); // past
let now= new Date('2020-02-26');  // now

console.log('Code  d1>d2  d1<d2  d1=d2')
var log = (l,f) => console.log(`${l}     ${f(now,past)}  ${f(past,now)}  ${f(now,now)}`);

log('A',A);
log('B',B);
log('C',C);
log('D',D);
log('E',E);
log('G',G);
log('H',H);
log('I',I);
log('J',J);
log('K',K);
log('L',L);
log('M',M);
log('N',N);

p {color: red}

<p>This snippet only presents tested solutions (it not perform tests itself)</p>

chrome 的搜索结果

我对这个问题的简单回答

checkDisabled(date) {
    const today = new Date()
    const newDate = new Date(date._d)
    if (today.getTime() > newDate.getTime()) {
        return true
    }
    return false
}
       

如果两个日期的格式都是“YYYY-MM-DD”，则可以跳过 Date 对象并直接比较字符串。

这是由于字符串在 JS 中的比较方式

let date1 = '2022-12-13';
let date2 = '2022-02-13';

console.log(`${date1} > ${date2}`, date1 > date2);
console.log(`${date1} < ${date2}`, date1 < date2);
console.log(`${date1} == ${date2}`, date1 == date2);