Qual è un modo semplice per verificare se un valore è una data valida, è ammesso qualsiasi formato di data noto.

Per esempio ho i valori 10-11-2009, 10/11/2009, 2009-11-10T07:00:00+0000che deve essere rilevato come valori di data, ei valori 200, 10, 350, che non dovrebbero essere riconosciute come valore data. Qual è il modo più semplice per verificarlo, se è possibile? Perché anche i timestamp sarebbero consentiti.

Sarebbe Date.parse()sufficiente?

Vedere la relativa pagina della documentazione MDN .

Aggiornamento 2015

È una vecchia domanda ma altre nuove domande come:

• Come convalidare se una stringa è una data valida in js

chiuso come duplicati di questo, quindi penso che sia importante aggiungere alcune nuove informazioni qui. Lo sto scrivendo perché mi sono spaventato pensando che le persone effettivamente copiano e incollano parte del codice pubblicato qui e lo usano nella produzione.

La maggior parte delle risposte qui o usano espressioni regolari complesse che corrispondono solo ad alcuni formati molto specifici e lo fanno effettivamente in modo errato (come la corrispondenza del 32 gennaio senza corrispondere alla data ISO effettiva come pubblicizzata - vedi la demo ) o provano a passare qualsiasi cosa al Datecostruttore e auguro il meglio.

Utilizzando Moment

Come ho spiegato in questa risposta, al momento è disponibile una libreria per questo: Moment.js

È una libreria per analizzare, convalidare, manipolare e visualizzare le date in JavaScript, che ha un'API molto più ricca delle funzioni standard di gestione delle date JavaScript.

È ridotto a 12kB / compresso con gzip e funziona in Node.js e in altri luoghi:

bower install moment --save # bower
npm install moment --save   # npm
Install-Package Moment.js   # NuGet
spm install moment --save   # spm
meteor add momentjs:moment  # meteor

Usando Moment puoi essere molto specifico sul controllo delle date valide. A volte è molto importante aggiungere alcuni indizi sul formato che ti aspetti. Ad esempio, una data come 22/06/2015 sembra una data valida, a meno che non si utilizzi un formato GG / MM / AAAA, nel qual caso tale data deve essere respinta in quanto non valida. Ci sono alcuni modi in cui puoi dire a Moment quale formato ti aspetti, ad esempio:

moment("06/22/2015", "MM/DD/YYYY", true).isValid(); // true
moment("06/22/2015", "DD/MM/YYYY", true).isValid(); // false

L' trueargomento è lì, quindi Moment non proverà ad analizzare l'input se non si conforma esattamente a uno dei formati forniti (secondo me dovrebbe essere un comportamento predefinito).

È possibile utilizzare un formato fornito internamente:

moment("2015-06-22T13:17:21+0000", moment.ISO_8601, true).isValid(); // true

E puoi usare più formati come un array:

var formats = [
    moment.ISO_8601,
    "MM/DD/YYYY  :)  HH*mm*ss"
];
moment("2015-06-22T13:17:21+0000", formats, true).isValid(); // true
moment("06/22/2015  :)  13*17*21", formats, true).isValid(); // true
moment("06/22/2015  :(  13*17*21", formats, true).isValid(); // false

Vedi: DEMO .

Altre biblioteche

Se non vuoi usare Moment.js, ci sono anche altre librerie:

• XDate
• DateJS

Aggiornamento 2016

Ho creato il modulo immoment che è simile a (un sottoinsieme di) Moment ma senza sorprese causate dalla mutazione di oggetti esistenti (vedi i documenti per maggiori informazioni).

Aggiornamento 2018

Oggi raccomando di usare Luxon per la manipolazione di data / ora anziché Moment, che (a differenza di Moment) rende immutabili tutti gli oggetti, quindi non ci sono brutte sorprese legate alla mutazione implicita delle date.

Ulteriori informazioni

Guarda anche:

• Gestione di date e orari utilizzando Moment.js di Jay Raj
• Lavorare con le date JavaScript utilizzando Moment.js di Bradley Holbrook

Una serie di articoli di Rob Gravelle sulle librerie di analisi della data JavaScript:

• Una carrellata di librerie di analisi delle date JavaScript popolari: Moment.js
• Una carrellata di librerie di analisi delle date JavaScript popolari: Datejs
• Una carrellata di librerie di analisi della data JavaScript popolari: XDate

Linea di fondo

Ovviamente chiunque può provare a reinventare la ruota, scrivere un'espressione regolare (ma per favore leggi ISO 8601 e RFC 3339 prima di farlo) o chiama i costruttori incorporati con dati casuali per analizzare i messaggi di errore come 'Invalid Date'(Sei sicuro che questo messaggio sia esattamente lo stesso su tutte le piattaforme? In tutte le versioni locali? In futuro?) oppure puoi usare una soluzione testata e usare il tuo tempo per migliorarla, non reinventarla. Tutte le librerie elencate qui sono software libero e open source.

Ecco come ho risolto questo problema in un'app a cui sto lavorando in questo momento:

aggiornato in base al feedback di Krillgar:

var isDate = function(date) {
    return (new Date(date) !== "Invalid Date") && !isNaN(new Date(date));
}

new Date(date) === 'Invalid Date'funziona solo con Firefox e Chrome. IE8 (quello che ho sulla mia macchina a scopo di test) dà NaN.

Come indicato alla risposta accettata, Date.parse(date)funzionerà anche per i numeri. Quindi, per ovviare a questo, puoi anche verificare che non sia un numero (se è qualcosa che vuoi confermare).

var parsedDate = Date.parse(date);

// You want to check again for !isNaN(parsedDate) here because Dates can be converted
// to numbers, but a failed Date parse will not.
if (isNaN(date) && !isNaN(parsedDate)) {
    /* do your work */
}

Che ne dici di questo? Verificherà se si tratta di un oggetto Date o una stringa di date:

function isDate(value) {
    var dateFormat;
    if (toString.call(value) === '[object Date]') {
        return true;
    }
    if (typeof value.replace === 'function') {
        value.replace(/^\s+|\s+$/gm, '');
    }
    dateFormat = /(^\d{1,4}[\.|\\/|-]\d{1,2}[\.|\\/|-]\d{1,4})(\s*(?:0?[1-9]:[0-5]|1(?=[012])\d:[0-5])\d\s*[ap]m)?$/;
    return dateFormat.test(value);
}

Devo dire che questo non verifica le stringhe formattate ISO ma con un po 'più di lavoro su RegExp dovresti essere bravo.

Nessuna delle risposte qui risolve il problema se la data non è valida, ad esempio il 31 febbraio. Questa funzione risolve il problema verificando che il mese restituito sia equivalente al mese originale e assicurandosi che sia stato presentato un anno valido.

//expected input dd/mm/yyyy or dd.mm.yyyy or dd-mm-yyyy
function isValidDate(s) {
  var separators = ['\\.', '\\-', '\\/'];
  var bits = s.split(new RegExp(separators.join('|'), 'g'));
  var d = new Date(bits[2], bits[1] - 1, bits[0]);
  return d.getFullYear() == bits[2] && d.getMonth() + 1 == bits[1];
} 

Utilizzare l'espressione regolare per convalidarlo.

isDate('2018-08-01T18:30:00.000Z');

isDate(_date){
        const _regExp  = new RegExp('^(-?(?:[1-9][0-9]*)?[0-9]{4})-(1[0-2]|0[1-9])-(3[01]|0[1-9]|[12][0-9])T(2[0-3]|[01][0-9]):([0-5][0-9]):([0-5][0-9])(.[0-9]+)?(Z)?$');
        return _regExp.test(_date);
    }

Facendo riferimento a tutti i commenti di cui sopra, sono arrivato a una soluzione.

Funziona se il Datepassaggio è in formato ISO o deve essere manipolato per altri formati.

var isISO = "2018-08-01T18:30:00.000Z";

if (new Date(isISO) !== "Invalid Date" && !isNaN(new Date(isISO))) {
    if(isISO == new Date(isISO).toISOString()) {
        console.log("Valid date");
    } else {
        console.log("Invalid date");
    }
} else {
    console.log("Invalid date");
}

Puoi giocare qui su JSFiddle.

Ecco una funzione migliorata che utilizza solo Date.parse():

function isDate(s) {
    if(isNaN(s) && !isNaN(Date.parse(s)))
        return true;
    else return false;
}

Nota: Date.parse () analizzerà i numeri: ad esempio Date.parse(1)restituirà una data. Quindi qui controlliamo se snon è un numero, se è una data.

Vorrei fare questo

var myDateStr= new Date("2015/5/2");

if( ! isNaN ( myDateStr.getMonth() )) {
    console.log("Valid date");
}
else {
    console.log("Invalid date");
}

Gioca qui

Ecco una versione minimalista.

var isDate = function (date) {
    return!!(function(d){return(d!=='Invalid Date'&&!isNaN(d))})(new Date(date));
}

Questa funzione richiamabile funziona perfettamente, restituisce vero per data valida. Assicurati di chiamare utilizzando una data in formato ISO (aaaa-mm-gg o aaaa / mm / gg):

function validateDate(isoDate) {

    if (isNaN(Date.parse(isoDate))) {
        return false;
    } else {
        if (isoDate != (new Date(isoDate)).toISOString().substr(0,10)) {
            return false;
        }
    }
    return true;
}

So che è una vecchia domanda, ma ho affrontato lo stesso problema e ho visto che nessuna delle risposte ha funzionato correttamente, in particolare eliminando i numeri (1.200.345, ecc.) Dalle date, che è la domanda originale. Ecco un metodo piuttosto non ortodosso che mi viene in mente e sembra funzionare. Si prega di sottolineare se ci sono casi in cui fallirà.

if(sDate.toString() == parseInt(sDate).toString()) return false;

Questa è la linea per eliminare i numeri. Pertanto, l'intera funzione potrebbe apparire come:

function isDate(sDate) {  
  if(sDate.toString() == parseInt(sDate).toString()) return false; 
  var tryDate = new Date(sDate);
  return (tryDate && tryDate.toString() != "NaN" && tryDate != "Invalid Date");  
}

console.log("100", isDate(100));
console.log("234", isDate("234"));
console.log("hello", isDate("hello"));
console.log("25 Feb 2018", isDate("25 Feb 2018"));
console.log("2009-11-10T07:00:00+0000", isDate("2009-11-10T07:00:00+0000"));

va bene verificare se è disponibile una funzione relativa alla data affinché l'oggetto possa scoprire se si tratta di un oggetto Date o no?

piace

var l = new Date();
var isDate = (l.getDate !== undefined) ? true; false;

È così che finisco per farlo. Questo non coprirà tutti i formati. Devi adeguarti di conseguenza. Ho il controllo sul formato, quindi funziona per me

function isValidDate(s) {
            var dt = "";
            var bits = [];
            if (s && s.length >= 6) {
                if (s.indexOf("/") > -1) {
                    bits = s.split("/");
                }
                else if (s.indexOf("-") > -1) {
                    bits = s.split("-");
                }
                else if (s.indexOf(".") > -1) {
                    bits = s.split(".");
                }
                try {
                    dt = new Date(bits[2], bits[0] - 1, bits[1]);
                } catch (e) {
                    return false;
                }
                return (dt.getMonth() + 1) === parseInt(bits[0]);
            } else {
                return false;
            }
        }

Ok, questa è una vecchia domanda, ma ho trovato un'altra soluzione durante il controllo delle soluzioni qui. Per me lavora per verificare se la funzione getTime () è presente nell'oggetto data:

const checkDate = new Date(dateString);

if (typeof checkDate.getTime !== 'function') {
  return;
}

document.getElementById('r1').innerHTML = dayjs('sdsdsd').isValid()

document.getElementById('r2').innerHTML = dayjs('2/6/20').isValid()

<script src="https://unpkg.com/dayjs@1.8.21/dayjs.min.js"></script>

<p>'sdsdsd' is a date: <span id="r1"></span></p>
<p>'2/6/20' is a date: <span id="r2"></span></p>

Una libreria leggera è pronta per te: Day.js

SimpleDateFormat sdf = new SimpleDateFormat(dateFromat);
sdf.setLenient(false);

Per impostazione predefinita, questo è impostato su VERO. Quindi anche le stringhe di formato errato restituiscono buoni valori.

L'ho usato in questo modo:

SimpleDateFormat formatter = new SimpleDateFormat("yyyy/MM/dd");
formatter.setLenient(false);
String value = "1990/13/23"; 

try {
      Date date = formatter.parse(value);
      System.out.println(date);
    }catch (ParseException e) 
  {
    System.out.println("its bad");
  }

Prova questo:

if (var date = new Date(yourDateString)) {
    // if you get here then you have a valid date       
}