¿Cuál es una manera fácil de verificar si un valor es una fecha válida? Se permite cualquier formato de fecha conocido.

Por ejemplo, tengo los valores 10-11-2009, 10/11/2009, 2009-11-10T07:00:00+0000la que todos deben ser reconocidos como valores de fecha, y los valores 200, 10, 350, que no deben ser reconocidos como un valor de fecha. ¿Cuál es la forma más sencilla de verificar esto, si esto es posible? Porque las marcas de tiempo también estarían permitidas.

Sería Date.parse()suficiente?

Consulte su página relativa de documentación de MDN .

Actualización 2015

Es una pregunta antigua pero otras preguntas nuevas como:

• Cómo validar si una cadena es una fecha válida en js

se cierren como duplicados de este, así que creo que es importante agregar información fresca aquí. Lo escribo porque me asusté pensando que la gente realmente copia y pega parte del código publicado aquí y lo usa en producción.

La mayoría de las respuestas aquí o bien usar expresiones regulares complejas que responden a formatos sólo algunos muy específicos y de hecho lo hacen de forma incorrecta (como ajuste de 32 de enero, cuando no coincida con la fecha ISO real como se anuncia - ver demostración ) o que tratan de pasar nada al Dateconstructor y desear lo mejor.

Usando momento

Como expliqué en esta respuesta, actualmente hay una biblioteca disponible para eso: Moment.js

Es una biblioteca para analizar, validar, manipular y mostrar fechas en JavaScript, que tiene una API mucho más rica que las funciones estándar de manejo de fechas de JavaScript.

Tiene 12kB minified / gzipped y funciona en Node.js y otros lugares:

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 puede ser muy específico sobre la verificación de fechas válidas. A veces es muy importante agregar algunas pistas sobre el formato que espera. Por ejemplo, una fecha como 22/06/2015 parece una fecha válida, a menos que use un formato DD / MM / AAAA, en cuyo caso esta fecha debe rechazarse como no válida. Hay pocas maneras de decirle a Moment qué formato espera, por ejemplo:

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

El trueargumento está ahí, por lo que el Momento no intentará analizar la entrada si no se ajusta exactamente a uno de los formatos proporcionados (en mi opinión, debería ser un comportamiento predeterminado).

Puede usar un formato provisto internamente:

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

Y puede usar múltiples formatos como una matriz:

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

Ver: DEMO .

Otras bibliotecas

Si no desea usar Moment.js, también hay otras bibliotecas:

• XDate
• DateJS

Actualización 2016

He creado el immoment módulo que es como (un subconjunto de) Momento pero sin sorpresas causadas por mutación de objetos existentes (véase la documentación para obtener más información).

Actualización 2018

Hoy recomiendo usar Luxon para la manipulación de fecha / hora en lugar de Moment, que (a diferencia de Moment) hace que todos los objetos sean inmutables, por lo que no hay sorpresas desagradables relacionadas con la mutación implícita de fechas.

Más información

Ver también:

• Administrar fechas y horas usando Moment.js por Jay Raj
• Trabajar con fechas JavaScript usando Moment.js por Bradley Holbrook

Una serie de artículos de Rob Gravelle en las bibliotecas de análisis de fechas de JavaScript:

• Resumen de las bibliotecas populares de análisis de fechas de JavaScript: Moment.js
• Resumen de las bibliotecas populares de análisis de fechas de JavaScript: Datejs
• Un resumen de las bibliotecas populares de análisis de fechas de JavaScript: XDate

Línea de fondo

Por supuesto, cualquier persona puede tratar de reinventar la rueda, escribir una expresión regular (pero por favor, lea realmente la norma ISO 8601 y RFC 3339 antes de hacerlo) o llame al buit-en los constructores con datos aleatorios a los mensajes de error de análisis como 'Invalid Date'(¿Estás seguro de que este mensaje es exactamente igual en todas las plataformas, en todos los entornos locales, en el futuro, o puede usar una solución probada y usar su tiempo para mejorarla, no reinventarla. Todas las bibliotecas enumeradas aquí son de código abierto, software libre.

Así es como resolví este problema en una aplicación en la que estoy trabajando ahora:

actualizado en base a los comentarios de krillgar:

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

new Date(date) === 'Invalid Date'solo funciona en Firefox y Chrome. IE8 (el que tengo en mi máquina con fines de prueba) proporciona NaN.

Como se indicó a la respuesta aceptada, Date.parse(date)también funcionará para los números. Entonces, para evitar eso, también puede verificar que no sea un número (si eso es algo que desea confirmar).

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

¿Qué tal algo como esto? Probará si es un objeto Date o una cadena de fecha:

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

Debo mencionar que esto no prueba las cadenas con formato ISO, pero con un poco más de trabajo para el RegExp debería ser bueno.

Ninguna de las respuestas aquí se dirige a verificar si la fecha no es válida, como el 31 de febrero. Esta función se ocupa de verificar si el mes devuelto es equivalente al mes original y asegurarse de que se haya presentado un año válido.

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

Use la expresión regular para validarlo.

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

Al referirme a todos los comentarios anteriores, he llegado a una solución.

Esto funciona si el Date pase está en formato ISO o necesita manipularse para otros formatos.

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

Puedes jugar aquí en JSFiddle.

Aquí hay una función mejorada que solo usa Date.parse():

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

Nota: Date.parse () analizará los números: por ejemplo Date.parse(1), devolverá una fecha. Así que aquí verificamos si sno es un número, si es una fecha.

Yo haría esto

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

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

Juega aqui

Aquí hay una versión minimalista.

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

Esta función invocable funciona perfectamente, devuelve verdadero para la fecha válida. Asegúrese de llamar utilizando una fecha en formato ISO (aaaa-mm-dd o aaaa / mm / dd):

function validateDate(isoDate) {

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

Sé que es una pregunta antigua, pero enfrenté el mismo problema y vi que ninguna de las respuestas funcionó correctamente, específicamente eliminando números (1,200,345, etc.) de las fechas, que es la pregunta original. Aquí hay un método poco ortodoxo en el que podría pensar y parece funcionar. Indique si hay casos en los que fallará.

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

Esta es la línea para eliminar los números. Por lo tanto, toda la función podría verse así:

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

¿está bien verificar que una función relacionada con la fecha esté disponible para que el objeto encuentre si es un objeto de fecha o no?

me gusta

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

Así es como termino haciéndolo. Esto no cubrirá todos los formatos. Tienes que ajustar en consecuencia. Tengo control sobre el formato, así que funciona para mí.

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, esta es una vieja pregunta, pero encontré otra solución mientras comprobaba las soluciones aquí. Para mí, funciona para verificar si la función getTime () está presente en el objeto de fecha:

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 biblioteca ligera está lista para ti: Day.js

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

Por defecto, esto se establece en VERDADERO. Entonces, incluso las cadenas de formato incorrecto devuelven buenos valores.

Lo he usado algo como esto:

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

Prueba esto:

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