it-swarm.com.de

Erkennen eines "ungültigen Datums" Datumsinstanz in JavaScript

Ich würde gerne den Unterschied zwischen gültigen und ungültigen Datumsobjekten in JS erkennen, konnte aber nicht herausfinden, wie:

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'

Ideen zum Schreiben einer isValidDate -Funktion?

  • Ash empfahl Date.parse zum Parsen von Datumszeichenfolgen, wodurch autorisiert überprüft werden kann, ob die Datumszeichenfolge gültig ist.
  • Wenn möglich, würde ich es vorziehen, wenn meine API eine Date-Instanz akzeptiert und in der Lage ist, zu überprüfen/zu bestätigen, ob sie gültig ist oder nicht. Borgars Lösung macht das, aber ich muss es über alle Browser hinweg testen. Ich frage mich auch, ob es einen eleganteren Weg gibt.
  • Ash veranlasste mich zu der Überlegung, dass meine API überhaupt keine Date -Instanzen akzeptiert. Dies ist am einfachsten zu validieren.
  • Borgar schlug vor, auf eine Date -Instanz und dann auf den Zeitwert von Date zu testen. Wenn das Datum ungültig ist, ist der Zeitwert NaN. Ich habe mit ECMA-262 nachgeprüft und dieses Verhalten ist in der Norm enthalten, genau das, wonach ich suche.
1318
orip

So würde ich es machen:

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
}

pdate [2018-05-31]: Wenn Sie sich nicht mit Datumsobjekten aus anderen JS-Kontexten (externen Fenstern, Frames oder Iframes) befassen, ist diese einfachere Form möglicherweise vorzuziehen:

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

Anstelle von new Date() sollten Sie verwenden:

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

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

Date.parse() gibt einen Zeitstempel zurück, eine Ganzzahl, die die Anzahl der Millisekunden seit dem 01.01.1970 angibt. Es wird NaN zurückgegeben, wenn die angegebene Datumszeichenfolge nicht analysiert werden kann.

236
Ash

Sie können die Gültigkeit eines Date Objekts d über überprüfen

d instanceof Date && isFinite(d)

Um rahmenübergreifende Probleme zu vermeiden, könnte man das Kontrollkästchen instanceof durch ersetzen

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

Ein Aufruf von getTime() wie in Borgars Antwort ist nicht erforderlich, da isNaN() und isFinite() beide implizit in Zahl konvertieren.

100
Christoph

Meine Lösung besteht darin, einfach zu überprüfen, ob Sie ein gültiges Datumsobjekt erhalten:

Implementierung

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

Verwendungszweck

var d = new Date("lol");

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

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

console.log(d.isValid()); // true
79
Ash Clarke

kürzeste Antwort zur Überprüfung des gültigen Datums

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

Sie können einfach moment.js verwenden.

Hier ist ein Beispiel:

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

Das Validierungsabschnitt in der Dokumentation ist ziemlich klar.

Die folgenden Parsing-Flags führen außerdem zu einem ungültigen Datum:

  • overflow: Ein Überlauf eines Datumsfelds, z. B. ein 13. Monat, ein 32. Tag des Monats (oder ein 29. Februar in Nicht-Schaltjahren), ein 367. Tag des Jahres usw., enthält den Index der ungültigen Einheit, die mit #invalidAt übereinstimmt (siehe unten); -1 bedeutet kein Überlauf.
  • invalidMonth: Ein ungültiger Monatsname, z. B. moment ('Marbruary', 'MMMM') ;. Enthält die ungültige Monatszeichenfolge selbst oder null.
  • empty: Eine Eingabezeichenfolge, die nichts Analysierbares enthält, z. B. moment ('this is nonsense') ;. Boolean.
  • Usw.

Quelle: http://momentjs.com/docs/

42
Yves M.

Ich möchte erwähnen, dass das jQuery UI DatePicker-Widget über eine sehr gute Datumsüberprüfungsmethode verfügt, die das Format und die Gültigkeit überprüft (z. B. sind keine Daten für den 33.01.2013 zulässig).

Auch wenn Sie das Datepicker-Widget auf Ihrer Seite nicht als UI-Element verwenden möchten, können Sie der Seite immer die .js-Bibliothek hinzufügen und dann die Validator-Methode aufrufen und den zu validierenden Wert übergeben. Um das Leben noch einfacher zu machen, wird eine Zeichenfolge als Eingabe verwendet, kein JavaScript-Datumsobjekt.

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

Es ist nicht als Methode aufgeführt, aber es ist da - als Utility-Funktion. Durchsuchen Sie die Seite nach "Parsedate" und finden Sie:

$ .datepicker.parseDate (Format, Wert, Einstellungen) - Extrahiert ein Datum aus einem Zeichenfolgenwert mit einem angegebenen Format.

Verwendungsbeispiel:

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

(Weitere Informationen zum Festlegen von Datumsformaten finden Sie unter http://api.jqueryui.com/datepicker/#utility-parseDate )

Im obigen Beispiel wird die Warnmeldung nicht angezeigt, da "01.03.2012" ein für den Kalender gültiges Datum im angegebenen Format ist. Wenn Sie jedoch beispielsweise 'stringval' auf '13/04/2013 'setzen, erhalten Sie eine Warnmeldung, da der Wert '13/04/2013' nicht für den Kalender gültig ist.

Wenn ein übergebener Zeichenfolgewert erfolgreich analysiert wird, ist der Wert von 'testdate' ein Javascript-Datumsobjekt, das den übergebenen Zeichenfolgewert darstellt. Wenn nicht, wäre es undefiniert.

37
Matt Campbell

Ich mochte Christophs Herangehensweise sehr (hatte aber nicht genug Ruf, um darüber abzustimmen). Zu meiner Verwendung weiß ich, dass ich immer ein Date-Objekt haben werde, daher habe ich das Datum nur mit einer valid () -Methode erweitert.

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

Jetzt kann ich dies einfach schreiben und es ist viel aussagekräftiger als nur das Überprüfen von isFinite im Code ...

d = new Date(userDate);
if (d.valid()) { /* do stuff */ }
22
broox
// check whether date is valid
var t = new Date('2011-07-07T11:20:00.000+00:00x');
valid = !isNaN(t.valueOf());
21
faridz

Ich verwende den folgenden Code, um Werte für Jahr, Monat und Datum zu validieren.

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

Einzelheiten finden Sie unter Datum in Javascript prüfen

15
Jingguo Yao

mit dieser Meldung können Sie das gültige Format von txDate.value überprüfen. Wenn es im falschen Format war, wurde das Datumsobjekt nicht instanziiert und null an dt zurückgegeben.

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

Und wie @ MiF's in Kürze andeutet

 if(isNaN(new Date(...)))
12
Yusef Mohamadi

Zu viele komplizierte Antworten hier, aber eine einfache Zeile reicht aus (ES5):

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

oder sogar in ES6:

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

Schöne lösung! In meiner Bibliothek von Hilfsfunktionen enthalten, sieht es jetzt so aus:

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

Für Angular.js-Projekte können Sie Folgendes verwenden:

angular.isDate(myDate);
9
Nick Taras

Das hat gerade bei mir funktioniert

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

Dies hat jedoch nicht funktioniert

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

Keine dieser Antworten hat bei mir funktioniert (getestet in Safari 6.0), als ich versuchte, ein Datum wie den 31.02.2012 zu validieren. Sie funktionieren jedoch einwandfrei, wenn ich ein Datum größer als 31 probiere.

Also musste ich ein wenig Gewalt anwenden. Angenommen, das Datum hat das Format mm/dd/yyyy. Ich benutze @broox Antwort:

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
6
Dex

Keine der oben genannten Lösungen hat für mich funktioniert, was jedoch funktioniert hat, ist

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

der obige Code wird sehen, wenn JS den 31.02.2012 zum 02.03.2012 macht, dass er nicht gültig ist

5
John

Ich habe einige Antworten gesehen, die diesem kleinen Ausschnitt sehr nahe kamen.

JavaScript Weg:

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

TypeScript-Methode:

const isValidDate = dateObject => new Date(dateObject ).toString() !== 'Invalid Date';
isValidDate(new Date('WTH'));
5
Jason Foglia
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;
}
5

Ich habe diese Funktion geschrieben. Übergeben Sie einen Zeichenfolgenparameter und es wird basierend auf diesem Format "TT/MM/JJJJ" bestimmt, ob es sich um ein gültiges Datum handelt oder nicht.

hier ist ein Test

eingabe: "hahaha", Ausgabe: false.

eingabe: "29/2/2000", Ausgabe: wahr.

eingabe: "29/2/2001", Ausgabe: false.

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

Inspiriert von Borgars Ansatz habe ich sichergestellt, dass der Code nicht nur das Datum validiert, sondern auch sicherstellt, dass das Datum ein echtes Datum ist, was bedeutet, dass Datumsangaben wie 31.09.2011 und 29.02.2011 nicht zulässig sind.

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

Ich habe die besten Leistungsergebnisse kombiniert, die ich bei dieser Prüfung gefunden habe, wenn ein bestimmtes Objekt:

Das Ergebnis ist das Folgende:

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

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

Eine Ready-Funktion basierend auf der bestbewerteten Antwort:

  /**
   * 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;
}
2
Zon

Die ausgewählte Antwort ist ausgezeichnet und ich benutze sie auch. Wenn Sie jedoch nach einer Möglichkeit suchen, die Eingabe des Benutzerdatums zu überprüfen, sollten Sie sich darüber im Klaren sein, dass das Date-Objekt sehr beständig ist, um möglicherweise ungültige Konstruktionsargumente in gültige zu verwandeln. Der folgende Unit-Test-Code veranschaulicht den Punkt:

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

Date.prototype.toISOString wirft RangeError (zumindest in Chromium und Firefox) an ungültigen Daten. Sie können es als Validierungsmittel verwenden und benötigen möglicherweise nicht isValidDate als solches (EAFP). Ansonsten ist es:

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

Das Datumsobjekt für die Zeichenfolge ist eine einfachere und zuverlässigere Methode, um festzustellen, ob beide Felder ein gültiges Datum sind. z.B. Wenn Sie dieses "-------" in das Datumseingabefeld eingeben. Einige der obigen Antworten funktionieren nicht.

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}.');
2
kam
function isValidDate(strDate) {
    var myDateStr= new Date(strDate);
    if( ! isNaN ( myDateStr.getMonth() ) ) {
       return true;
    }
    return false;
}

Nenne es so

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

sie können Datum und Uhrzeit in Millisekunden umrechnen getTime ()

this getTime() Methode return Not a Number NaN wenn nicht gültig

if(!isNaN(new Date("2012/25/255").getTime()))
  return 'valid date time';
  return 'Not a valid date time';
2
Mina Gabriel
function isValidDate(date) {
  return !! (Object.prototype.toString.call(date) === "[object Date]" && +date);
}
1
Joel Kornbluh

Für int 1-basierte Komponenten eines Datums:

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

Tests:

    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)
1
Denis Ryzhkov

Ich denke, ein Teil davon ist ein langer Prozess. Wir können es wie folgt abkürzen:

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

Einfache und elegante Lösung:

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

quellen:

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

[2] Falsches Datum in new Date () in JavaScript

1
Soubriquet

Im Allgemeinen würde ich bei der Datumsimplantation bleiben, die sich im Browser-Stack befindet. Das heißt, Sie erhalten immer "Ungültiges Datum", wenn Sie toDateString () in Chrome, Firefox und Safari zum Datum dieser Antwort aufrufen.

if(!Date.prototype.isValidDate){
  Date.prototype.isValidDate = function(){
    return this.toDateString().toLowerCase().lastIndexOf('invalid') == -1;
  };
}

Ich habe dies jedoch nicht in IE getestet.

1
pixelbacon

Also mochte ich @Ask Clarke Antwort mit wenig Verbesserung, indem ich try catch Block für Daten hinzufügte, die nicht durch var d = new Date (d) gehen können -

function checkIfDateNotValid(d) {
        try{
            var d = new Date(d);
            return !(d.getTime() === d.getTime()); //NAN is the only type which is not equal to itself.
        }catch (e){
            return true;
        }

    }
1
Saurabh Gupta

date.parse(valueToBeTested) > 0 ist alles, was benötigt wird. Ein gültiges Datum gibt den Epochenwert zurück, und ein ungültiger Wert gibt NaN zurück, das den Test > 0 nicht besteht, da es sich nicht einmal um eine Zahl handelt.

Dies ist so einfach, dass eine Hilfsfunktion Code nicht speichert, obwohl er möglicherweise etwas besser lesbar ist. Wenn Sie eines wollten:

String.prototype.isDate = function() {
  return !Number.isNaN(Date.parse(this));
}

OR

Benutzen:

"StringToTest".isDate();
0
rainabba

Noch eine andere Möglichkeit, um zu überprüfen, ob das Datum ein gültiges Datumsobjekt ist:

const isValidDate = (date) => 
  typeof date === 'object' && 
  typeof date.getTime === 'function' && 
  !isNaN(date.getTime())
0
iwatakeshi
Date.valid = function(str){
  var d = new Date(str);
  return (Object.prototype.toString.call(d) === "[object Date]" && !isNaN(d.getTime()));
}

https://Gist.github.com/dustinpoissant/b83750d8671f10c414b346b16e290ecf

0
Dustin Poissant

Diese Variante von isValidDate verwendet einen regulären Ausdruck, der Schaltjahre behandelt:

function isValidDate(value)
{
    return /((^(10|12|0?[13578])([/])(3[01]|[12][0-9]|0?[1-9])([/])((1[8-9]\d{2})|([2-9]\d{3}))$)|(^(11|0?[469])([/])(30|[12][0-9]|0?[1-9])([/])((1[8-9]\d{2})|([2-9]\d{3}))$)|(^(0?2)([/])(2[0-8]|1[0-9]|0?[1-9])([/])((1[8-9]\d{2})|([2-9]\d{3}))$)|(^(0?2)([/])(29)([/])([2468][048]00)$)|(^(0?2)([/])(29)([/])([3579][26]00)$)|(^(0?2)([/])(29)([/])([1][89][0][48])$)|(^(0?2)([/])(29)([/])([2-9][0-9][0][48])$)|(^(0?2)([/])(29)([/])([1][89][2468][048])$)|(^(0?2)([/])(29)([/])([2-9][0-9][2468][048])$)|(^(0?2)([/])(29)([/])([1][89][13579][26])$)|(^(0?2)([/])(29)([/])([2-9][0-9][13579][26])$))/.test(value)
}
0
Greg Finzer
var isDate_ = function(input) {
        var status = false;
        if (!input || input.length <= 0) {
          status = false;
        } else {
          var result = new Date(input);
          if (result == 'Invalid Date') {
            status = false;
          } else {
            status = true;
          }
        }
        return status;
      }
0
Dhayalan

Diese Funktion validiert ein Zeichenfolgedatum in Ziffernformaten, die durch ein Zeichen begrenzt sind, z. TT/MM/JJJJ, MM/TT/JJJJ

/*
Param  : 
1)the date in string data type 
2)[optional - string - default is "/"] the date delimiter, most likely "/" or "-"
3)[optional - int - default is 0] the position of the day component when the date string is broken up via the String.split function (into arrays)
4)[optional - int - default is 1] the position of the month component when the date string is broken up via the String.split function (into arrays)
5)[optional - int - default is 2] the position of the year component when the date string is broken up via the String.split function (into arrays)

Return : a javascript date is returned if the params are OK else null
*/
function IsValidDate(strDate, strDelimiter, iDayPosInArray, iMonthPosInArray, iYearPosInArray) {
    var strDateArr; //a string array to hold constituents day, month, and year components
    var dtDate; //our internal converted date
    var iDay, iMonth, iYear;


    //sanity check 
    //no integer checks are performed on day, month, and year tokens as parsing them below will result in NaN if they're invalid
    if (null == strDate || typeof strDate != "string")
        return null;

    //defaults
    strDelimiter = strDelimiter || "/";
    iDayPosInArray = undefined == iDayPosInArray ? 0 : iDayPosInArray;
    iMonthPosInArray = undefined == iMonthPosInArray ? 1 : iMonthPosInArray;
    iYearPosInArray = undefined == iYearPosInArray ? 2 : iYearPosInArray;

    strDateArr = strDate.split(strDelimiter);

    iDay = parseInt(strDateArr[iDayPosInArray],10);
    iMonth = parseInt(strDateArr[iMonthPosInArray],10) - 1; // Note: months are 0-based
    iYear = parseInt(strDateArr[iYearPosInArray],10);

    dtDate = new Date(
        iYear,
        iMonth, // Note: months are 0-based
        iDay);

    return (!isNaN(dtDate) && dtDate.getFullYear() == iYear && dtDate.getMonth() == iMonth && dtDate.getDate() == iDay) ? dtDate : null; // Note: months are 0-based
}

Beispielaufruf:

var strDate="18-01-1971";

if (null == IsValidDate(strDate)) {

  alert("invalid date");
}
0
wanglabs