Me gustaría saber la diferencia entre los objetos de fecha válidos y no válidos en JS, pero no pude averiguar cómo:

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'

¿Alguna idea para escribir una isValidDatefunción?

• Ash recomendado Date.parsepara analizar cadenas de fecha, lo que proporciona una forma autorizada de verificar si la cadena de fecha es válida.
• Lo que preferiría, si es posible, es que mi API acepte una instancia de Date y poder verificar / afirmar si es válida o no. La solución de Borgar hace eso, pero necesito probarlo en todos los navegadores. También me pregunto si hay una forma más elegante.
• Ash me hizo considerar que mi API no aceptaba Dateinstancias en absoluto, esto sería más fácil de validar.
• Borgar sugirió probar una Dateinstancia y luego probar el Datevalor de tiempo de la. Si la fecha no es válida, el valor de la hora es NaN. Verifiqué con ECMA-262 y este comportamiento está en el estándar, que es exactamente lo que estoy buscando.

Así es como lo haría yo:

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
}

Actualización [2018-05-31] : si no le preocupan los objetos Date de otros contextos JS (ventanas externas, marcos o iframes), puede preferir esta forma más simple:

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

En lugar de usar new Date(), debes usar:

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

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

Date.parse()devuelve una marca de tiempo, un número entero que representa el número de milisegundos desde el 01 / Ene / 1970. Volverá NaNsi no puede analizar la cadena de fecha proporcionada.

Puede comprobar la validez de un Dateobjeto a dtravés de

d instanceof Date && isFinite(d)

Para evitar problemas de marcos cruzados, se puede reemplazar el instanceofcheque con

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

Una llamada a getTime()como en la respuesta de Borgar es innecesaria isNaN()y isFinite()ambos se convierten implícitamente en un número.

Mi solución es simplemente verificar si obtiene un objeto de fecha válido:

Implementación

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

respuesta más corta para verificar la fecha válida

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

Simplemente puede usar moment.js

Aquí hay un ejemplo:

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

La sección de validación en la documentación es bastante clara.

Y también, los siguientes indicadores de análisis dan como resultado una fecha no válida:

• overflow: Un desbordamiento de un campo de fecha, como un mes 13, un día 32 del mes (o un 29 de febrero en años no bisiestos), un día 367 del año, etc. El desbordamiento contiene el índice de la unidad no válida para que coincida con #invalidAt (ver más abajo); -1 significa que no hay desbordamiento.
• invalidMonth: Un nombre de mes no válido, como moment ('Marbruary', 'MMMM') ;. Contiene la cadena de mes no válida en sí, o nula.
• empty: Una cadena de entrada que no contiene nada analizable, como moment ('esto es una tontería') ;. Booleano.
• Etc.

Fuente: http://momentjs.com/docs/

Me gustaría mencionar que el widget jQuery UI DatePicker tiene un método de utilidad validador de fecha muy bueno que verifica el formato y la validez (por ejemplo, no se permiten fechas del 33/01/2013).

Incluso si no desea utilizar el widget de selector de fechas en su página como un elemento de la interfaz de usuario, siempre puede agregar su biblioteca .js a su página y luego llamar al método de validación, pasando el valor que desea validar en él. Para hacer la vida aún más fácil, se necesita una cadena como entrada, no un objeto Fecha de JavaScript.

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

No aparece como método, pero está ahí, como función de utilidad. Busque en la página "parsedate" y encontrará:

$ .datepicker.parseDate (formato, valor, configuración): extrae una fecha de un valor de cadena con un formato específico.

Uso de ejemplo:

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

(Encontrará más información sobre los formatos de fecha especificados en http://api.jqueryui.com/datepicker/#utility-parseDate)

En el ejemplo anterior, no verá el mensaje de alerta ya que '01 / 03/2012 'es una fecha válida para el calendario en el formato especificado. Sin embargo, si hiciera 'stringval' igual a '13 / 04/2013 ', por ejemplo, obtendría el mensaje de alerta, ya que el valor '13 / 04/2013' no es válido para el calendario.

Si un valor de cadena pasado se analiza correctamente, el valor de 'testdate' sería un objeto de fecha de Javascript que representa el valor de cadena pasado. Si no, estaría indefinido.

Realmente me gustó el enfoque de Christoph (pero no tenía suficiente reputación para votarlo). Para mi uso, sé que siempre tendré un objeto Date, así que solo extendí la fecha con un método valid ().

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

Ahora puedo escribir esto y es mucho más descriptivo que simplemente verificar isFinite en el código ...

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

puede verificar el formato válido de txDate.value con este scirpt. si estaba en formato incorrecto, el objeto Date no se instancia y devuelve nulo a dt.

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

Y como @ MiF's sugirió brevemente

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

Utilizo el siguiente código para validar valores para año, mes y fecha.

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

Para obtener más información, consulte Comprobar fecha en javascript.

He visto algunas respuestas que se acercan mucho a este pequeño fragmento.

Forma de JavaScript:

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

ES2015 forma:

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

Actualizado: para reflejar comentarios.

Ya hay demasiadas respuestas complicadas aquí, pero una línea simple es suficiente (ES5):

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

o incluso en ES6:

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

Esto solo funcionó para mi

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

Sin embargo, esto no funcionó

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

¡Buena solución! Incluido en mi biblioteca de funciones auxiliares, ahora se ve así:

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

Para proyectos de Angular.js puede usar:

angular.isDate(myDate);

Ninguna de estas respuestas funcionó para mí (probada en Safari 6.0) al intentar validar una fecha como el 31/02/2012; sin embargo, funcionan bien cuando se intenta con cualquier fecha superior a 31.

Así que tuve que usar la fuerza bruta un poco. Suponiendo que la fecha tiene el formato mm/dd/yyyy. Estoy usando la respuesta de @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

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

Inspirado por el enfoque de Borgar, me aseguré de que el código no solo valida la fecha, sino que también se asegura de que la fecha sea una fecha real, lo que significa que fechas como 31/09/2011 y 29/02/2011 no están permitidas.

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

He escrito esta función. Pásale un parámetro de cadena y determinará si es una fecha válida o no en base a este formato "dd / MM / aaaa".

aquí hay una prueba

entrada: "jajaja", salida: falso.

entrada: "29/2/2000", salida: verdadera.

entrada: "29/2/2001", salida: 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.toISOStringarroja RangeError(al menos en Chromium y Firefox) en fechas no válidas. Puede usarlo como un medio de validación y es posible que no lo necesite isValidDatecomo tal (EAFP). De lo contrario, es:

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

Ninguna de las soluciones anteriores funcionó para mí, pero lo que sí funcionó es

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

el código anterior verá cuando JS convierte el 31/02/2012 en el 02/03/2012 que no es válido

Combiné los mejores resultados de rendimiento que encontré alrededor de esa verificación si un objeto dado:

• es una instancia de Date ( referencia aquí )
• tiene una fecha válida ( referencia aquí )

El resultado es el siguiente:

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

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

La fecha del objeto a la cadena es una forma más simple y confiable de detectar si ambos campos son fechas válidas. Por ejemplo, si ingresa este "-------" en el campo de entrada de fecha. Algunas de las respuestas anteriores no funcionarán.

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

Para componentes basados ​​en int 1 de una fecha:

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

Pruebas:

    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)

La respuesta seleccionada es excelente y también la estoy usando. Sin embargo, si está buscando una forma de validar la entrada de la fecha del usuario, debe tener en cuenta que el objeto Date es muy persistente a la hora de convertir lo que pueden parecer argumentos de construcción no válidos en argumentos válidos. El siguiente código de prueba unitaria ilustra el 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;
}

Llámalo así

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

Una función lista basada en la respuesta mejor calificada:

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

Solución simple y elegante:

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

fuentes:

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

[2] Fecha incorrecta mostrada en la nueva fecha () en JavaScript

Nadie lo ha mencionado todavía, por lo que Symbols también sería un camino a seguir:

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

Ser consciente de: https://caniuse.com/#search=Symbol