Vorrei dire la differenza tra oggetti data validi e non validi in JS, ma non sono riuscito a capire come:

var d = new Date("foo");
console.log(d.toString()); // shows 'Invalid Date'
console.log(typeof d); // shows 'object'
console.log(d instanceof Date); // shows 'true'

Qualche idea per scrivere una isValidDatefunzione?

• Ash ha raccomandato Date.parsedi analizzare le stringhe di date, il che fornisce un modo autorevole per verificare se la stringa di date è valida.
• Ciò che preferirei, se possibile, è che la mia API accetti un'istanza Date e che sia in grado di verificare / affermare se è valida o meno. La soluzione di Borgar lo fa, ma devo provarlo su tutti i browser. Mi chiedo anche se esiste un modo più elegante.
• Ash mi ha fatto considerare di non far accettare le Dateistanze alle mie API , questo sarebbe più facile da convalidare.
• Borgar ha suggerito di provare per Dateun'istanza, e quindi di testare il Datevalore temporale. Se la data non è valida, il valore dell'ora è NaN. Ho verificato con ECMA-262 e questo comportamento è nello standard, che è esattamente quello che sto cercando.

Ecco come lo farei:

if (Object.prototype.toString.call(d) === "[object Date]") {
  // it is a date
  if (isNaN(d.getTime())) {  // d.valueOf() could also work
    // date is not valid
  } else {
    // date is valid
  }
} else {
  // not a date
}

Aggiornamento [2018-05-31] : se non si è interessati agli oggetti Date di altri contesti JS (finestre esterne, frame o iframe), è possibile preferire questo modulo più semplice:

function isValidDate(d) {
  return d instanceof Date && !isNaN(d);
}

Invece di usare new Date()dovresti usare:

var timestamp = Date.parse('foo');

if (isNaN(timestamp) == false) {
  var d = new Date(timestamp);
}

Date.parse()restituisce un timestamp, un numero intero che rappresenta il numero di millisecondi dall'01 / gen / 1970. Restituirà NaNse non è in grado di analizzare la stringa della data fornita.

È possibile verificare la validità di un Dateoggetto dtramite

d instanceof Date && isFinite(d)

Per evitare problemi tra frame, è possibile sostituire il instanceofcontrollo con

Object.prototype.toString.call(d) === '[object Date]'

Una chiamata a getTime()come nella risposta di Borgar è superflua, in quanto isNaN()e isFinite()sia implicitamente convertire in numero.

La mia soluzione è semplicemente verificare se si ottiene un oggetto data valido:

Implementazione

Date.prototype.isValid = function () {
    // An invalid date object returns NaN for getTime() and NaN is the only
    // object not strictly equal to itself.
    return this.getTime() === this.getTime();
};  

uso

var d = new Date("lol");

console.log(d.isValid()); // false

d = new Date("2012/09/11");

console.log(d.isValid()); // true

risposta più breve per verificare la data valida

if(!isNaN(date.getTime()))

Puoi semplicemente usare moment.js

Ecco un esempio:

var m = moment('2015-11-32', 'YYYY-MM-DD');
m.isValid(); // false

La sezione di validazione nella documentazione è abbastanza chiara.

Inoltre, i seguenti flag di analisi generano una data non valida:

• overflow: Un overflow di un campo data, ad esempio un 13 ° mese, un 32 ° giorno del mese (o un 29 febbraio negli anni non bisestili), un 367 ° giorno dell'anno, ecc. Overflow contiene l'indice dell'unità non valida per abbinare #invalidAt (vedi sotto); -1 significa nessun overflow.
• invalidMonth: Un nome di mese non valido, ad esempio momento ('Mar febbraio', 'MMMM') ;. Contiene la stringa del mese non valida stessa, oppure null.
• empty: Una stringa di input che non contiene nulla di analizzabile, ad esempio moment ('this isssens') ;. Booleano.
• Eccetera.

Fonte: http://momentjs.com/docs/

Vorrei menzionare che il widget DatePicker dell'interfaccia utente jQuery ha un ottimo metodo di utilità per la convalida della data che controlla il formato e la validità (ad esempio, non sono consentite date del 01/01/2013).

Anche se non vuoi usare il widget datepicker sulla tua pagina come elemento UI, puoi sempre aggiungere la sua libreria .js alla tua pagina e quindi chiamare il metodo validator, passando il valore che vuoi validare in essa. Per rendere la vita ancora più semplice, ci vuole una stringa come input, non un oggetto Date JavaScript.

Vedi: http://api.jqueryui.com/datepicker/

Non è elencato come metodo, ma è lì, come funzione di utilità. Cerca "parsedate" nella pagina e troverai:

$ .datepicker.parseDate (formato, valore, impostazioni) - Estrai una data da un valore di stringa con un formato specificato.

Esempio di utilizzo:

var stringval = '01/03/2012';
var testdate;

try {
  testdate = $.datepicker.parseDate('mm/dd/yy', stringval);
             // Notice 'yy' indicates a 4-digit year value
} catch (e)
{
 alert(stringval + ' is not valid.  Format must be MM/DD/YYYY ' +
       'and the date value must be valid for the calendar.';
}

(Ulteriori informazioni sulla specifica dei formati di data sono disponibili all'indirizzo http://api.jqueryui.com/datepicker/#utility-parseDate )

Nell'esempio sopra, non visualizzerai il messaggio di avviso poiché "01/03/2012" è una data valida per il calendario nel formato specificato. Tuttavia, se si imposta 'stringval' uguale a '13 / 04/2013 ', ad esempio, si otterrà il messaggio di avviso, poiché il valore '13 / 04/2013' non è valido per il calendario.

Se un valore di stringa passato viene analizzato correttamente, il valore di 'testdate' sarebbe un oggetto Date Javascript che rappresenta il valore di stringa passato. Altrimenti, sarebbe indefinito.

Mi è piaciuto molto l'approccio di Christoph (ma non avevo abbastanza reputazione per votarlo). Per il mio uso, so che avrò sempre un oggetto Date, quindi ho appena esteso la data con un metodo valid ().

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

Ora posso solo scrivere questo ed è molto più descrittivo del semplice controllo di isFinite nel codice ...

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

// check whether date is valid
var t = new Date('2011-07-07T11:20:00.000+00:00x');
valid = !isNaN(t.valueOf());

puoi controllare il formato valido di txDate.value con questo scirpt. se era in formato errato, l'oggetto Data non è stato istanziato e restituisce null a dt.

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

E come ha suggerito @ MiF in breve

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

Uso il seguente codice per convalidare i valori per anno, mese e data.

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;
}

Per i dettagli, consultare Controlla data in javascript

Sono già presenti troppe risposte complicate, ma è sufficiente una semplice riga (ES5):

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

o anche in ES6:

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

Ho visto alcune risposte che si sono avvicinate molto a questo piccolo frammento.

Modo JavaScript:

function isValidDate(dateObject){ return new Date(dateObject).toString() !== 'Invalid Date'; }
isValidDate(new Date('WTH'));

Modo TypeScript:

const isValidDate = dateObject => new Date(dateObject ).toString() !== 'Invalid Date';
isValidDate(new Date('WTH'));

Bella soluzione! Incluso nella mia libreria di funzioni ausiliarie, ora appare così:

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());
}

Questo ha funzionato per me

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

Tuttavia questo non ha funzionato

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

Per i progetti Angular.js è possibile utilizzare:

angular.isDate(myDate);

Nessuna di queste risposte ha funzionato per me (testato in Safari 6.0) quando si tenta di convalidare una data come 31/02/2012, tuttavia, funzionano bene quando si tenta una data superiore a 31.

Quindi ho dovuto forzare un po 'la forza. Supponendo che la data sia nel formato mm/dd/yyyy. Sto usando la risposta di @broox:

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

Nessuna delle soluzioni di cui sopra ha funzionato per me ciò che ha funzionato comunque è

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);
    }

il codice sopra vedrà quando JS rende il 31/02/2012 il 03/02/2012 che non è valido

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;
}

Ho scritto questa funzione. Passa un parametro stringa e determinerà se è una data valida o meno in base a questo formato "gg / MM / aaaa".

ecco un test

input: "hahaha", output: falso.

input: "29/2/2000", output: vero.

input: "29/2/2001", output: falso.

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;
    }
}

Date.prototype.toISOStringgenera RangeError(almeno in Chromium e Firefox) in date non valide. Puoi usarlo come mezzo di convalida e potrebbe non essere necessario in isValidDatequanto tale (EAFP). Altrimenti è:

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

Ispirato all'approccio di Borgar, mi sono assicurato che il codice non solo convalida la data, ma in realtà si assicura che la data sia una data reale, il che significa che date come il 31/09/2011 e il 29/02/2011 non sono consentite.

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!";
}

Ho combinato i migliori risultati prestazionali che ho trovato in giro per verificare se un determinato oggetto:

• è un'istanza di Date ( benchmark qui )
• ha una data valida ( benchmark qui )

Il risultato è il seguente:

function isValidDate(input) {
  if(!(input && input.getTimezoneOffset && input.setUTCFullYear))
    return false;

  var time = input.getTime();
  return time === time;
};

L'oggetto Date su stringa è un modo più semplice e affidabile per rilevare se entrambi i campi sono validi. ad es. se si immette questo "-------" nel campo di immissione della data. Alcune delle risposte sopra non funzioneranno.

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}.');

La risposta selezionata è eccellente e la sto usando anche io. Tuttavia, se stai cercando un modo per convalidare l'input della data dell'utente, dovresti essere consapevole che l'oggetto Date è molto persistente nel trasformare quelli che potrebbero sembrare argomenti di costruzione non validi in quelli validi. Il seguente codice di unit test illustra il punto:

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());
});

function isValidDate(strDate) {
    var myDateStr= new Date(strDate);
    if( ! isNaN ( myDateStr.getMonth() ) ) {
       return true;
    }
    return false;
}

Chiamalo così

isValidDate(""2015/5/2""); // => true
isValidDate(""2015/5/2a""); // => false

Una funzione pronta basata sulla risposta più votata:

  /**
   * Check if date exists and is valid.
   *
   * @param {String} dateString Date in YYYY-mm-dd format.
   */
  function isValidDate(dateString) {
  var isValid = false;
  var date;

  date =
    new Date(
      dateString);

  if (
    Object.prototype.toString.call(
      date) === "[object Date]") {

    if (isNaN(date.getTime())) {

      // Date is unreal.

    } else {
      // Date is real if month and day match each other in date and string (otherwise may be shifted):
      isValid =
        date.getUTCMonth() + 1 === dateString.split("-")[1] * 1 &&
        date.getUTCDate() === dateString.split("-")[2] * 1;
    }
  } else {
    // It's not a date.
  }

  return isValid;
}

Soluzione semplice ed elegante:

const date = new Date(`${year}-${month}-${day} 00:00`)
const isValidDate = (Boolean(+date) && date.getDate() == day)

fonti:

[1] https://medium.com/@esganzerla/simple-date-validation-with-javascript-caea0f71883c

[2] Data errata visualizzata nella nuova data () in JavaScript

Penso che parte di questo sia un lungo processo. Possiamo abbreviarlo come mostrato di seguito:

 function isValidDate(dateString) {
        debugger;
        var dateStringSplit;
        var formatDate;

        if (dateString.length >= 8 && dateString.length<=10) {
            try {
                dateStringSplit = dateString.split('/');
                var date = new Date();
                date.setYear(parseInt(dateStringSplit[2]), 10);
                date.setMonth(parseInt(dateStringSplit[0], 10) - 1);
                date.setDate(parseInt(dateStringSplit[1], 10));

                if (date.getYear() == parseInt(dateStringSplit[2],10) && date.getMonth()+1 == parseInt(dateStringSplit[0],10) && date.getDate() == parseInt(dateStringSplit[1],10)) {
                    return true;
                }
                else {
                    return false;
                }

            } catch (e) {
                return false;
            }
        }
        return false;
    }

Per i componenti basati su int 1 di una data:

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
};

test:

    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)