Was ist eine einfache Möglichkeit, um zu überprüfen, ob ein Wert ein gültiges Datum ist, wobei jedes bekannte Datumsformat zulässig ist.

Zum Beispiel habe ich die Werte 10-11-2009, 10/11/2009, 2009-11-10T07:00:00+0000die alle als Datumswerte erkannt werden sollen, und die Werte 200, 10, 350, die nicht als Datumswert erkannt werden. Was ist der einfachste Weg, dies zu überprüfen, wenn dies überhaupt möglich ist? Weil Zeitstempel auch erlaubt wären.

Würde Date.parse()ausreichen?

Siehe die entsprechende MDN-Dokumentationsseite .

Update 2015

Es ist eine alte Frage, aber andere neue Fragen wie:

• So überprüfen Sie, ob eine Zeichenfolge ein gültiges Datum in js ist

Schließen Sie als Duplikate dieses, daher denke ich, dass es wichtig ist, hier einige neue Informationen hinzuzufügen. Ich schreibe es, weil ich Angst hatte, dass die Leute tatsächlich einen Teil des hier veröffentlichten Codes kopieren und einfügen und ihn in der Produktion verwenden.

Die meisten Antworten hier verwenden entweder einige komplexe reguläre Ausdrücke, die nur einigen sehr spezifischen Formaten entsprechen und diese tatsächlich falsch ausführen (z. B. den 32. Januar, wenn das tatsächliche ISO-Datum nicht wie angegeben übereinstimmt - siehe Demo ), oder sie versuchen, etwas an den DateKonstruktor und zu übergeben wünsche das Beste.

Moment nutzen

Wie ich in dieser Antwort erklärt habe, steht derzeit eine Bibliothek dafür zur Verfügung: Moment.js

Es ist eine Bibliothek zum Parsen, Validieren, Bearbeiten und Anzeigen von Datumsangaben in JavaScript. Sie verfügt über eine wesentlich umfangreichere API als die Standardfunktionen für die JavaScript-Datumsverarbeitung.

Es ist 12kB minimiert / gezippt und funktioniert in Node.js und anderen Orten:

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

Mit Moment können Sie sehr genau festlegen, ob gültige Daten vorliegen. Manchmal ist es sehr wichtig, einige Hinweise zum erwarteten Format hinzuzufügen. Beispielsweise sieht ein Datum wie der 22.06.2015 wie ein gültiges Datum aus, es sei denn, Sie verwenden ein Format TT / MM / JJJJ. In diesem Fall sollte dieses Datum als ungültig abgelehnt werden. Es gibt nur wenige Möglichkeiten, wie Sie Moment mitteilen können, welches Format Sie erwarten, zum Beispiel:

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

Das trueArgument ist vorhanden, sodass der Moment nicht versucht, die Eingabe zu analysieren, wenn sie nicht genau einem der bereitgestellten Formate entspricht (es sollte meiner Meinung nach ein Standardverhalten sein).

Sie können ein intern bereitgestelltes Format verwenden:

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

Und Sie können mehrere Formate als Array verwenden:

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

Siehe: DEMO .

Andere Bibliotheken

Wenn Sie Moment.js nicht verwenden möchten, gibt es auch andere Bibliotheken:

• XDate
• DateJS

Update 2016

Ich habe das Immoment- Modul erstellt, das wie (eine Teilmenge von) Moment ist, aber keine Überraschungen aufweist, die durch die Mutation vorhandener Objekte verursacht werden ( weitere Informationen finden Sie in den Dokumenten ).

Update 2018

Heute empfehle ich die Verwendung von Luxon für die Datums- / Zeitmanipulation anstelle von Moment, wodurch (im Gegensatz zu Moment) alle Objekte unveränderlich werden, sodass es keine bösen Überraschungen im Zusammenhang mit der impliziten Mutation von Datumsangaben gibt.

Mehr Info

Siehe auch:

• Verwalten von Daten und Zeiten mit Moment.js von Jay Raj
• Arbeiten mit JavaScript-Daten mit Moment.js von Bradley Holbrook

Eine Reihe von Artikeln von Rob Gravelle über JavaScript-Datumsanalysebibliotheken:

• Eine Zusammenfassung der gängigen JavaScript-Datumsanalysebibliotheken: Moment.js
• Eine Zusammenfassung der gängigen JavaScript-Datumsanalysebibliotheken: Datejs
• Eine Zusammenfassung der gängigen JavaScript-Datumsanalysebibliotheken: XDate

Endeffekt

Natürlich kann jeder versuchen, das Rad neu zu erfinden, einen regulären Ausdruck zu schreiben (aber bitte lesen Sie vorher ISO 8601 und RFC 3339, bevor Sie dies tun) oder Buit-In-Konstruktoren mit zufälligen Daten aufrufen, um Fehlermeldungen wie 'Invalid Date'(Sind Sie sicher, dass diese Nachricht ist) zu analysieren auf allen Plattformen genau gleich ? In allen Regionen? In der Zukunft?) oder Sie können eine getestete Lösung verwenden und Ihre Zeit nutzen, um sie zu verbessern, nicht neu zu erfinden. Alle hier aufgeführten Bibliotheken sind Open Source, freie Software.

So habe ich dieses Problem in einer App gelöst, an der ich gerade arbeite:

aktualisiert basierend auf dem Feedback von krillgar:

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

new Date(date) === 'Invalid Date'funktioniert nur in Firefox und Chrome. IE8 (der, den ich zu Testzwecken auf meinem Computer habe) gibt NaN.

Wie in der akzeptierten Antwort angegeben, Date.parse(date)funktioniert dies auch für Zahlen. Um dies zu umgehen, können Sie auch überprüfen, ob es sich nicht um eine Zahl handelt (wenn Sie dies bestätigen möchten).

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 */
}

Wie wäre es mit so etwas? Es wird getestet, ob es sich um ein Datumsobjekt oder eine Datumszeichenfolge handelt:

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

Ich sollte erwähnen, dass dies nicht auf ISO-formatierte Zeichenfolgen getestet wird, aber mit etwas mehr Arbeit an RegExp sollten Sie gut sein.

Keine der Antworten hier befasst sich mit der Überprüfung, ob das Datum ungültig ist, wie z. B. dem 31. Februar. Diese Funktion behebt dies, indem sie überprüft, ob der zurückgegebene Monat dem ursprünglichen Monat entspricht, und sicherstellt, dass ein gültiges Jahr angegeben wurde.

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

Verwenden Sie den regulären Ausdruck, um ihn zu validieren.

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

Durch Bezugnahme auf alle obigen Kommentare bin ich zu einer Lösung gekommen.

Dies funktioniert, wenn das Dateübergebene Format im ISO-Format vorliegt oder für andere Formate bearbeitet werden muss.

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

Sie können hier auf JSFiddle spielen.

Hier ist eine verbesserte Funktion, die nur verwendet Date.parse():

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

Hinweis: Date.parse () analysiert Zahlen : Gibt beispielsweise Date.parse(1)ein Datum zurück. Hier prüfen wir also, ob ses sich nicht um eine Nummer handelt, ob es sich um ein Datum handelt.

Ich würde das tun

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

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

Spielen Sie hier

Hier ist eine minimalistische Version.

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

Diese aufrufbare Funktion funktioniert einwandfrei und gibt für das gültige Datum true zurück. Rufen Sie unbedingt mit einem Datum im ISO-Format an (JJJJ-MM-TT oder JJJJ / MM / TT):

function validateDate(isoDate) {

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

Ich weiß, dass es eine alte Frage ist, aber ich hatte das gleiche Problem und sah, dass keine der Antworten richtig funktionierte - insbesondere das Aussortieren von Zahlen (1.200.345 usw.) aus Daten, was die ursprüngliche Frage ist. Hier ist eine ziemlich unorthodoxe Methode, die mir einfällt und die zu funktionieren scheint. Bitte weisen Sie darauf hin, wenn es Fälle gibt, in denen dies fehlschlägt.

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

Dies ist die Zeile, um Zahlen auszusortieren. Somit könnte die gesamte Funktion folgendermaßen aussehen:

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

Ist es in Ordnung zu prüfen, ob für das Objekt eine datumsbezogene Funktion verfügbar ist, um festzustellen, ob es sich um ein Datumsobjekt handelt oder nicht?

mögen

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

So mache ich es am Ende. Dies wird nicht alle Formate abdecken. Sie müssen entsprechend anpassen. Ich habe die Kontrolle über das Format, also funktioniert es für mich

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, das ist eine alte Frage, aber ich habe eine andere Lösung gefunden, als ich die Lösungen hier überprüft habe. Bei mir wird geprüft, ob die Funktion getTime () am Datumsobjekt vorhanden ist:

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>

Eine leichte Bibliothek steht für Sie bereit: Day.js

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

Standardmäßig ist dies auf TRUE gesetzt. Selbst Zeichenfolgen mit falschem Format geben also gute Werte zurück.

Ich habe es so etwas benutzt:

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

Versuche dies:

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