Me gustaría decir la diferencia entre objetos de fecha válidos e inválidos en JS, pero no pude entender 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 se recomienda 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 pueda 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 no tener mi API para aceptar Dateinstancias, esto sería más fácil de validar.
• Borgar sugirió probar para una Dateinstancia, y luego probar el Datevalor de tiempo del 's. Si la fecha no es válida, el valor del tiempo 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:

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 marcos flotantes), se puede preferir esta forma más simple:

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

En lugar de usar new Date(), debe 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 / enero / 1970. Volverá NaNsi no puede analizar la cadena de fecha proporcionada.

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

d instanceof Date && isFinite(d)

Para evitar problemas de marcos cruzados, uno podría reemplazar el instanceofcheque con

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

Una llamada al getTime()igual que en la respuesta de Borgar es innecesario, ya que isNaN()y isFinite()tanto convertir implícitamente al 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 13º mes, un 32º día del mes (o un 29 de febrero en años no bisiestos), un 367º día 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 momento ('marzo', 'MMMM') ;. Contiene la cadena de mes inválida o nula.
• empty: Una cadena de entrada que no contiene nada analizable, como momento ('esto no tiene sentido') ;. Booleano
• Etc.

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

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

Incluso si no desea utilizar el widget de selector de fecha 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 en la lista como método, pero está allí, como una 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 especificado.

Ejemplo de uso:

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

(Más información sobre cómo especificar formatos de fecha se encuentra en http://api.jqueryui.com/datepicker/#utility-parseDate )

En el ejemplo anterior, no vería el mensaje de alerta ya que '01 / 03/2012 'es una fecha válida de calendario en el formato especificado. Sin embargo, si hizo 'stringval' igual a '13 / 04/2013 ', por ejemplo, recibirá 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 Javascript que representa el valor de cadena pasado. Si no, serí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 simplemente extendí la fecha con un método válido ().

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, la fecha no obedece y devuelve nulo a dt.

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

Y como sugirió @ MiF en breve

 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 más detalles, consulte Comprobar fecha en javascript

Demasiadas respuestas complicadas aquí ya, 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));

Vi algunas respuestas que se acercaron mucho a este pequeño fragmento.

Forma JavaScript:

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

Forma TypeScript:

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

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

Esto solo funcionó para mí

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

Sin embargo esto no funcionó

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

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 2/31/2012, sin embargo, funcionan bien al intentar cualquier fecha mayor que 31.

Así que tuve que forzar un poco la fuerza bruta. Asumiendo que la fecha está en el formato mm/dd/yyyy. Estoy usando la respuesta @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

Ninguna de las soluciones anteriores funcionó para mí, 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 02/03/2012 que no es válido

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

He escrito esta función. Páselo como un parámetro de cadena y determinará si es una fecha válida o no según este formato "dd / MM / aaaa".

aquí hay una prueba

entrada: "jajaja", salida: falso.

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

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.toISOStringtiradas RangeError(al menos en Chromium y Firefox) en fechas no válidas. Puede usarlo como un medio de validación y puede que no lo necesite isValidDatecomo tal (EAFP). De lo contrario es:

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

Inspirado por el enfoque de Borgar, me he asegurado de que el código no solo valide la fecha, sino que también se asegure 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!";
}

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

• es una instancia de fecha ( punto de referencia aquí )
• tiene una fecha válida ( punto de 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;
};

Date object to string es una forma más simple y confiable de detectar si ambos campos son fecha válida. 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}.');

La respuesta seleccionada es excelente, y la estoy usando también. 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 para convertir los argumentos de construcción no válidos en válidos. El siguiente código de prueba de unidad 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

Creo que algo de esto es un proceso largo. Podemos acortarlo como se muestra a continuación:

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

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)