validacion - validar formulario javascript html5

Verifica si una cadena es un valor de fecha

Question

¿Cuál es una forma fácil de verificar si un valor es una fecha válida, cualquier formato de fecha conocido permitido.

Por ejemplo, tengo los valores 10-11-2009 , 10/11/2009 , 2009-11-10T07:00:00+0000 que deberían reconocerse como valores de fecha, y los valores 200 , 10 , 350 , que no deberían ser reconocido 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.

Answer 1

Actualización 2015

Es una vieja pregunta, pero otras preguntas nuevas como:

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

cerrarse como duplicados de este, así que creo que es importante agregar algo de información nueva aquí. Lo escribo porque me asusté al pensar 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í usan algunas expresiones regulares complejas que coinciden solo con algunos formatos muy específicos y lo hacen incorrectamente (como hacer coincidir el 32 de enero sin coincidir con la fecha ISO real tal como se anuncia - ver demo ) o intentan pasarle algo al constructor de la Date y deseo lo mejor.

Usando el 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 en 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

Con Moment puede ser muy específico para verificar fechas válidas. A veces es muy importante agregar algunas pistas sobre el formato que esperas. Por ejemplo, una fecha como 22/06/2015 parece una fecha válida, a menos que use un formato DD / MM / YYYY en cuyo caso esta fecha debe rechazarse como no válida. Hay algunas maneras de cómo 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 true argumento está ahí para que el Momento no intente 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 puedes 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

Más información

Ver también:

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

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

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

Línea de fondo

Por supuesto, cualquiera puede intentar reinventar la rueda, escribir una expresión regular (pero lea realmente ISO 8601 y RFC 3339 antes de hacerlo) o llame a los constructores buit-in con datos aleatorios para analizar los mensajes de error como ''Invalid Date'' (¿Está usted? ¿Seguro que este mensaje es exactamente el mismo en todas las plataformas? ¿En todas las configuraciones regionales? ¿En el futuro?) o puede usar una solución probada y usar su tiempo para mejorarla, no para reinventarla. Todas las bibliotecas enumeradas aquí son de código abierto, software libre.

Answer 2

¿ Date.parse() suficiente Date.parse() ?

Vea su página relativa a la Documentación MDN .

Answer 3

¿Está bien comprobar si hay una función relacionada con la fecha disponible para que el objeto encuentre si se trata de un objeto Date o no?

me gusta

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

Answer 4

¿Qué tal algo como esto? Se probará si se trata de 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 RegExp deberías estar bien.

Answer 5

Aquí hay una versión minimalista.

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

Answer 6

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

actualizado según los comentarios de krillgar:

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

o...

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

....

Answer 7

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

Answer 8

Después de probar todas las respuestas enumeradas anteriormente terminé con lo siguiente:

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

Tenga en cuenta que la new Date(date) !== "Invalid Date" válida new Date(date) !== "Invalid Date" siempre es verdadera. Espero que esto ayude.

Answer 9

Esta función invocable funciona perfectamente, devuelve verdadero para fecha válida. Asegúrese de llamar usando 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;
}

Answer 10

Esto funciona:

var isDate = function(date) {
    return ((new Date(date)).toString() !== "Invalid Date") ? true : false;         
}

Answer 11

Ninguna de las respuestas aquí trata la comprobación de si la fecha no es válida, como el 31 de febrero. Esta función se encarga de eso comprobando si el mes devuelto es equivalente al mes original y asegurándose de que se presentó 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];
} 

Answer 12

Prueba esto:

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

Answer 13

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 here

Answer 14

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

Como se indicó en la respuesta aceptada, Date.parse(date) también funcionará para los números. Entonces, para evitar eso, también podría 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 */
}

Answer 15

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

Por defecto, esto está establecido en TRUE. Así que incluso 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");
  }