function isValidDate(dateObject){
    return new Date(dateObject).toString() !== 'Invalid Date';
}
console.log(isValidDate('WTH')); // -> false
console.log(isValidDate(new Date('WTH'))); // -> false
console.log(isValidDate(new Date())); // -> true

Antwoord 10, autoriteit 2%

Ik vond de aanpak van Christoph erg goed (maar had niet genoeg reputatie om het te bevestigen).
Voor mijn gebruik weet ik dat ik altijd een Date-object zal hebben, dus ik heb de datum gewoon verlengd met een valid()-methode.

Date.prototype.valid = function() {
  return isFinite(this);
}

Nu kan ik dit gewoon schrijven en het is veel beschrijvender dan alleen isFinite in code controleren…

d = new Date(userDate);
if (d.valid()) { /* do stuff */ }

Antwoord 11

Ik gebruik de volgende code om waarden voor jaar, maand en datum te valideren.

function createDate(year, month, _date) {
  var d = new Date(year, month, _date);
  if (d.getFullYear() != year 
    || d.getMonth() != month
    || d.getDate() != _date) {
    throw "invalid date";
  }
  return d;
}

Raadpleeg voor details Controleer de datum in javascript

Antwoord 12

u kunt het geldige formaat van txDate.value controleren met deze scirpt. als het in een onjuist formaat was, is de datum obejct niet geïnventariseerd en retourneert null naar dt .

var dt = new Date(txtDate.value)
 if (isNaN(dt))

En zoals @MiF’s in het kort suggereerde

if(isNaN(new Date(...)))

Antwoord 13

Er zijn hier al te veel ingewikkelde antwoorden, maar een simpele regel is voldoende (ES5):

Date.prototype.isValid = function (d) { return !isNaN(Date.parse(d)) } ;

of zelfs in ES6 :

Date.prototype.isValid = d => !isNaN(Date.parse(d));

Antwoord 14

Dit werkte gewoon voor mij

new Date('foo') == 'Invalid Date'; //is true

Dit werkte echter niet

new Date('foo') === 'Invalid Date'; //is false

Antwoord 15

Voor Angular.js-projecten kunt u het volgende gebruiken:

angular.isDate(myDate);

Antwoord 16

Ik heb de volgende oplossing geschreven op basis van Borgar’s oplossing. Inbegrepen in mijn bibliotheek met hulpfuncties, ziet er nu zo uit:

Object.isDate = function(obj) {
/// <summary>
/// Determines if the passed object is an instance of Date.
/// </summary>
/// <param name="obj">The object to test.</param>
    return Object.prototype.toString.call(obj) === '[object Date]';
}
Object.isValidDate = function(obj) {
/// <summary>
/// Determines if the passed object is a Date object, containing an actual date.
/// </summary>
/// <param name="obj">The object to test.</param>
    return Object.isDate(obj) && !isNaN(obj.getTime());
}

Antwoord 17

Geen van deze antwoorden werkte voor mij (getest in Safari 6.0) bij het valideren van een datum zoals 31-2-2012, maar ze werken prima bij het proberen van een datum groter dan 31.

Dus ik moest een beetje bruut geweld gebruiken. Ervan uitgaande dat de datum in het formaat mm/dd/yyyyis. Ik gebruik @broox antwoord:

Date.prototype.valid = function() {
    return isFinite(this);
}    
function validStringDate(value){
    var d = new Date(value);
    return d.valid() && value.split('/')[0] == (d.getMonth()+1);
}
validStringDate("2/29/2012"); // true (leap year)
validStringDate("2/29/2013"); // false
validStringDate("2/30/2012"); // false

Antwoord 18

IsValidDate: function(date) {
        var regex = /\d{1,2}\/\d{1,2}\/\d{4}/;
        if (!regex.test(date)) return false;
        var day = Number(date.split("/")[1]);
        date = new Date(date);
        if (date && date.getDate() != day) return false;
        return true;
}

Antwoord 19

Ik heb deze functie geschreven. Geef het een stringparameter door en het zal bepalen of het een geldige datum is of niet op basis van dit formaat “dd/MM/jjjj”.

hier is een test

invoer: “hahaha”, uitvoer: onwaar.

invoer: “29/2/2000”, uitvoer: waar.

invoer: “29/2/2001”, uitvoer: onwaar.

function isValidDate(str) {
    var parts = str.split('/');
    if (parts.length < 3)
        return false;
    else {
        var day = parseInt(parts[0]);
        var month = parseInt(parts[1]);
        var year = parseInt(parts[2]);
        if (isNaN(day) || isNaN(month) || isNaN(year)) {
            return false;
        }
        if (day < 1 || year < 1)
            return false;
        if(month>12||month<1)
            return false;
        if ((month == 1 || month == 3 || month == 5 || month == 7 || month == 8 || month == 10 || month == 12) && day > 31)
            return false;
        if ((month == 4 || month == 6 || month == 9 || month == 11 ) && day > 30)
            return false;
        if (month == 2) {
            if (((year % 4) == 0 && (year % 100) != 0) || ((year % 400) == 0 && (year % 100) == 0)) {
                if (day > 29)
                    return false;
            } else {
                if (day > 28)
                    return false;
            }      
        }
        return true;
    }
}

Antwoord 20

Date.prototype.toISOStringgooit RangeError(tenminste in Chromium en Firefox) op ongeldige datums. U kunt het gebruiken als een validatiemiddel en u hoeft isValidDateals zodanig niet (EAFP) te hebben. Anders is het:

function isValidDate(d)
{
  try
  {
    d.toISOString();
    return true;
  }
  catch(ex)
  {
    return false;    
  }    
}

Antwoord 21

Geen van de bovenstaande oplossingen werkte voor mij, wat wel werkte is

function validDate (d) {
    var date = new Date(d);
    var day = "" + date.getDate();
    if ( day.length == 1 ) day = "0" + day;
    var month = "" + (date.getMonth() + 1);
    if ( month.length == 1 ) month = "0" + month;
    var year = "" + date.getFullYear();
    return (( month + "/" + day + "/" + year ) == d );
}

de bovenstaande code zal zien dat wanneer JS 31/02/2012 in 03/02/2012 maakt, deze niet geldig is

Antwoord 22

Geïnspireerd door Borgar’s aanpakheb ik ervoor gezorgd dat de code niet alleen de datum valideert, maar er ook voor zorgt dat de datum echt is datum, wat betekent dat datums zoals 31/09/2011 en 29/02/2011 niet zijn toegestaan.

function(dateStr) {
  s = dateStr.split('/');
  d = new Date(+s[2], s[1] - 1, +s[0]);
  if (Object.prototype.toString.call(d) === "[object Date]") {
    if (!isNaN(d.getTime()) && d.getDate() == s[0] &&
      d.getMonth() == (s[1] - 1)) {
      return true;
    }
  }
  return "Invalid date!";
}

Antwoord 23

Ik raad bibliotheken zelden aan als je zonder kan. Maar gezien de overvloed aan antwoorden tot nu toe, lijkt het de moeite waard om erop te wijzen dat de populaire bibliotheek “date-fns” een functie isValidheeft. De volgende documentatie is afkomstig van hun website:

function isValidDate(input) {
  if(!(input && input.getTimezoneOffset && input.setUTCFullYear))
    return false;
  var time = input.getTime();
  return time === time;
};

Symbol.for(new Date("Peter")) === Symbol.for("Invalid Date") // true
Symbol.for(new Date()) === Symbol.for("Invalid Date") // false

console.log('Symbol.for(new Date("Peter")) === Symbol.for("Invalid Date")', Symbol.for(new Date("Peter")) === Symbol.for("Invalid Date")) // true
console.log('Symbol.for(new Date()) === Symbol.for("Invalid Date")', Symbol.for(new Date()) === Symbol.for("Invalid Date")) // false

isNaN(date)

!isNaN(date)

jQuery.validator.addMethod("greaterThan", 
    function(value, element, params) {
        var startDate = new Date($(params).val());
        var endDate = new Date(value);
        if(startDate.toString() === 'Invalid Date' || endDate.toString() === 'Invalid Date') {
            return false;
        } else {
            return endDate > startDate;
        }
    },'Must be greater than {0}.');

var is_valid_date = function(year, month, day) {
    var d = new Date(year, month - 1, day);
    return d.getFullYear() === year && (d.getMonth() + 1) === month && d.getDate() === day
};

   is_valid_date(2013, 02, 28)
&&  is_valid_date(2016, 02, 29)
&& !is_valid_date(2013, 02, 29)
&& !is_valid_date(0000, 00, 00)
&& !is_valid_date(2013, 14, 01)

if(!isNaN(new Date("2012/25/255").getTime()))
  return 'valid date time';
  return 'Not a valid date time';

QUnit.test( "valid date test", function( assert ) {
  //The following are counter-examples showing how the Date object will 
  //wrangle several 'bad' dates into a valid date anyway
  assert.equal(isValidDate(new Date(1980, 12, 15)), true);
  d = new Date();
  d.setFullYear(1980);
  d.setMonth(1);
  d.setDate(33);
  assert.equal(isValidDate(d), true);
  assert.equal(isValidDate(new Date(1980, 100, 150)), true);
  //If you go to this exterme, then the checker will fail
  assert.equal(isValidDate(new Date("This is junk")), false);
  //This is a valid date string
  assert.equal(isValidDate(new Date("November 17, 1989")), true);
  //but is this?
  assert.equal(isValidDate(new Date("November 35, 1989")), false);  
  //Ha!  It's not.  So, the secret to working with this version of 
  //isValidDate is to pass in dates as text strings... Hooboy
  //alert(d.toString());
});