validacion - validar formulario javascript html5

Cómo validar una fecha?

Question

Estoy tratando de probar para asegurarme de que la fecha sea válida en el sentido de que si alguien ingresa el 2/30/2011 entonces debería estar equivocado.

¿Cómo puedo hacer esto con cualquier fecha?

Answer 1

¿La primera función es ValidData (s) propuesta por RobG funcionará para la cadena de entrada ''1/2 /''? Creo que NO, porque el AÑO no está validado;

Mi proposición es usar una versión mejorada de esta función:

//input in ISO format: yyyy-MM-dd
function DatePicker_IsValidDate(input) {
        var bits = input.split(''-'');
        var d = new Date(bits[0], bits[1] - 1, bits[2]);
        return d.getFullYear() == bits[0] && (d.getMonth() + 1) == bits[1] && d.getDate() == Number(bits[2]);
}

Answer 2

Aunque esto se planteó hace mucho tiempo, sigue siendo una validación más buscada. Encontré un blog interesante con pocas funciones.

/* Please use these function to check the reuslt only. do not check for otherewise. other than utiljs_isInvalidDate

Ex:-

utiljs_isFutureDate() retuns only true for future dates. false does not mean it is not future date. it may be an invalid date.

practice :

call utiljs_isInvalidDate first and then use the returned date for utiljs_isFutureDate()

var d = {};

if(!utiljs_isInvalidDate(''32/02/2012'', d))

if(utiljs_isFutureDate(d))

//date is a future date

else

// date is not a future date



 */

function utiljs_isInvalidDate(dateStr, returnDate) {

    /*dateStr | format should be dd/mm/yyyy, Ex:- 31/10/2017

     *returnDate will be in {date:js date object}.

     *Ex:- if you only need to check whether the date is invalid,

     * utiljs_isInvalidDate(''03/03/2017'')

     *Ex:- if need the date, if the date is valid,

     * var dt = {};

     * if(!utiljs_isInvalidDate(''03/03/2017'', dt)){

     *  //you can use dt.date

     * }

     */

    if (!dateStr)
        return true;
    if (!dateStr.substring || !dateStr.length || dateStr.length != 10)
        return true;
    var day = parseInt(dateStr.substring(0, 2), 10);
    var month = parseInt(dateStr.substring(3, 5), 10);
    var year = parseInt(dateStr.substring(6), 10);
    var fullString = dateStr.substring(0, 2) + dateStr.substring(3, 5) + dateStr.substring(6);
    if (null == fullString.match(/^/d+$/)) //to check for whether there are only numbers
        return true;
    var dt = new Date(month + "/" + day + "/" + year);
    if (dt == ''Invalid Date'' || isNaN(dt)) { //if the date string is not valid, new Date will create this string instead
        return true;
    }
    if (dt.getFullYear() != year || dt.getMonth() + 1 != month || dt.getDate() != day) //to avoid 31/02/2018 like dates
        return true;
    if (returnDate)
        returnDate.date = dt;
    return false;
}

function utiljs_isFutureDate(dateStrOrObject, returnDate) {
    return utiljs_isFuturePast(dateStrOrObject, returnDate, true);
}

function utiljs_isPastDate(dateStrOrObject, returnDate) {
    return utiljs_isFuturePast(dateStrOrObject, returnDate, false);
}

function utiljs_isValidDateObjectOrDateString(dateStrOrObject, returnDate) { //this is an internal function
    var dt = {};
    if (!dateStrOrObject)
        return false;
    if (typeof dateStrOrObject.getMonth === ''function'')
        dt.date = new Date(dateStrOrObject); //to avoid modifying original date
    else if (utiljs_isInvalidDate(dateStrOrObject, dt))
        return false;
    if (returnDate)
        returnDate.date = dt.date;
    return true;

}

function utiljs_isFuturePast(dateStrOrObject, returnDate, isFuture) { //this is an internal function, please use isFutureDate or isPastDate function
    if (!dateStrOrObject)
        return false;
    var dt = {};
    if (!utiljs_isValidDateObjectOrDateString(dateStrOrObject, dt))
        return false;
    today = new Date();
    today.setHours(0, 0, 0, 0);
    if (dt.date)
        dt.date.setHours(0, 0, 0, 0);
    if (returnDate)
        returnDate.date = dt.date;
    //creating new date using only current d/m/y. as td.date is created with string. otherwise same day selection will not be validated.
    if (isFuture && dt.date && dt.date.getTime && dt.date.getTime() > today.getTime()) {
        return true;
    }
    if (!isFuture && dt.date && dt.date.getTime && dt.date.getTime() < today.getTime()) {
        return true;
    }
    return false;
}

function utiljs_isLeapYear(dateStrOrObject, returnDate) {
    var dt = {};
    if (!dateStrOrObject)
        return false;
    if (utiljs_isValidDateObjectOrDateString(dateStrOrObject, dt)) {
        if (returnDate)
            returnDate.date = dt.date;
        return dt.date.getFullYear() % 4 == 0;
    }
    return false;
}

function utiljs_firstDateLaterThanSecond(firstDate, secondDate, returnFirstDate, returnSecondDate) {
    if (!firstDate || !secondDate)
        return false;
    var dt1 = {},
    dt2 = {};
    if (!utiljs_isValidDateObjectOrDateString(firstDate, dt1) || !utiljs_isValidDateObjectOrDateString(secondDate, dt2))
        return false;
    if (returnFirstDate)
        returnFirstDate.date = dt1.date;
    if (returnSecondDate)
        returnSecondDate.date = dt2.date;
    dt1.date.setHours(0, 0, 0, 0);
    dt2.date.setHours(0, 0, 0, 0);
    if (dt1.date.getTime && dt2.date.getTime && dt1.date.getTime() > dt2.date.getTime())
        return true;
    return false;
}

function utiljs_isEqual(firstDate, secondDate, returnFirstDate, returnSecondDate) {
    if (!firstDate || !secondDate)
        return false;
    var dt1 = {},
    dt2 = {};
    if (!utiljs_isValidDateObjectOrDateString(firstDate, dt1) || !utiljs_isValidDateObjectOrDateString(secondDate, dt2))
        return false;
    if (returnFirstDate)
        returnFirstDate.date = dt1.date;
    if (returnSecondDate)
        returnSecondDate.date = dt2.date;
    dt1.date.setHours(0, 0, 0, 0);
    dt2.date.setHours(0, 0, 0, 0);
    if (dt1.date.getTime && dt2.date.getTime && dt1.date.getTime() == dt2.date.getTime())
        return true;
    return false;
}

function utiljs_firstDateEarlierThanSecond(firstDate, secondDate, returnFirstDate, returnSecondDate) {
    if (!firstDate || !secondDate)
        return false;
    var dt1 = {},
    dt2 = {};
    if (!utiljs_isValidDateObjectOrDateString(firstDate, dt1) || !utiljs_isValidDateObjectOrDateString(secondDate, dt2))
        return false;
    if (returnFirstDate)
        returnFirstDate.date = dt1.date;
    if (returnSecondDate)
        returnSecondDate.date = dt2.date;
    dt1.date.setHours(0, 0, 0, 0);
    dt2.date.setHours(0, 0, 0, 0);
    if (dt1.date.getTime && dt2.date.getTime && dt1.date.getTime() < dt2.date.getTime())
        return true;
    return false;
}

copie todo el código en un archivo e incluya.

espero que esto ayude.

Answer 3

Es desafortunado que parezca que JavaScript no tiene una forma simple de validar una cadena de fecha en estos días. Esta es la manera más simple en que puedo pensar para analizar las fechas en el formato "m / d / aaaa" en los navegadores modernos (es por eso que no especifica la raíz para parseInt, ya que debería ser 10 desde ES5):

const dateValidationRegex = /^/d{1,2}///d{1,2}///d{4}$/;
function isValidDate(strDate) {
  if (!dateValidationRegex.test(strDate)) return false;
  const [m, d, y] = strDate.split(''/'').map(n => parseInt(n));
  return m === new Date(y, m - 1, d).getMonth() + 1;
}

[''10/30/2000abc'', ''10/30/2000'', ''1/1/1900'', ''02/30/2000'', ''1/1/1/4''].forEach(d => {
  console.log(d, isValidDate(d));
});

Answer 4

Esta solución no aborda validaciones de fecha obvias como asegurarse de que las partes de fecha sean números enteros o que las partes de fecha cumplan con comprobaciones de validación obvias como el día que sea mayor que 0 y menor que 32. Esta solución supone que ya tiene las tres partes de fecha ( año, mes, día) y que cada uno ya pasa validaciones obvias. Dados estos supuestos, este método debería funcionar simplemente para verificar si existe la fecha.

Por ejemplo, el 29 de febrero de 2009 no es una fecha real, pero el 29 de febrero de 2008 es. Cuando crea un nuevo objeto Date como el 29 de febrero de 2009, observe lo que ocurre (recuerde que los meses comienzan en cero en JavaScript):

console.log(new Date(2009, 1, 29));

Las salidas de línea anteriores: dom mar 01 2009 00:00:00 GMT-0800 (PST)

Observe cómo la fecha simplemente se lamina hasta el primer día del mes siguiente. Suponiendo que tiene las otras validaciones obvias en su lugar, esta información puede usarse para determinar si una fecha es real con la siguiente función (esta función permite meses no basados ​​en cero para una entrada más conveniente):

var isActualDate = function (month, day, year) {
    var tempDate = new Date(year, --month, day);
    return month === tempDate.getMonth();
};

Esta no es una solución completa y no tiene en cuenta i18n, pero podría hacerse más robusta.

Answer 5

Este es JS6 (con let declaration).

function checkExistingDate(year, month, day){ // year, month and day should be numbers
     // months are intended from 1 to 12
    let months31 = [1,3,5,7,8,10,12]; // months with 31 days
    let months30 = [4,6,9,11]; // months with 30 days
    let months28 = [2]; // the only month with 28 days (29 if year isLeap)

    let isLeap = ((year % 4 === 0) && (year % 100 !== 0)) || (year % 400 === 0);

    let valid = (months31.indexOf(month)!==-1 && day <= 31) || (months30.indexOf(month)!==-1 && day <= 30) || (months28.indexOf(month)!==-1 && day <= 28) || (months28.indexOf(month)!==-1 && day <= 29 && isLeap);

    return valid; // it returns true or false
}

En este caso, he pensado en meses del 1 al 12. Si prefiere o usa el modelo basado en 0-11, puede simplemente cambiar las matrices con:

let months31 = [0,2,4,6,7,9,11];
let months30 = [3,5,8,10];
let months28 = [1];

Si su fecha está en el formato dd / mm / aaaa, puede quitar los parámetros de función de día, mes y año y hacer esto para recuperarlos:

let arrayWithDayMonthYear = myDateInString.split(''/'');
let year = parseInt(arrayWithDayMonthYear[2]);
let month  = parseInt(arrayWithDayMonthYear[1]);
let day = parseInt(arrayWithDayMonthYear[0]);

Answer 6

Hola, encuentra la respuesta a continuación. Esto se hace al validar la fecha recién creada.

var year=2019;
var month=2;
var date=31;
var d = new Date(year, month - 1, date);
if (d.getFullYear() != year
        || d.getMonth() != (month - 1)
        || d.getDate() != date) {
    alert("invalid date");
    return false;
}

Answer 7

Mi función devuelve verdadero si es una fecha válida; de lo contrario, devuelve falso: D

function isDate  (day, month, year){
 if(day == 0 ){
  return false;
 }
 switch(month){
  case 1: case 3: case 5: case 7: case 8: case 10: case 12:
   if(day > 31)
    return false;
   return true;
  case 2:
   if (year % 4 == 0)
    if(day > 29){
     return false;
    }
    else{
     return true;
    }
   if(day > 28){
    return false;
   }
   return true;
  case 4: case 6: case 9: case 11:
   if(day > 30){
    return false;
   }
   return true;
  default:
   return false;
 }
}

console.log(isDate(30, 5, 2017));
console.log(isDate(29, 2, 2016));
console.log(isDate(29, 2, 2015));

Answer 8

Recomiendo usar moment.js. Solo proporcionar la fecha al momento lo validará, no es necesario pasar el formato de fecha.

var date = moment("2016-10-19");

Y luego date.isValid() da el resultado deseado.

Se poste HERE

Answer 9

Solo hago un remake de la solución RobG

var daysInMonth = [31,28,31,30,31,30,31,31,30,31,30,31];
var isLeap = new Date(theYear,1,29).getDate() == 29;

if (isLeap) {
  daysInMonth[1] = 29;
}
return theDay <= daysInMonth[--theMonth]

Answer 10

Una forma sencilla de validar una cadena de fecha es convertirla en un objeto de fecha y probarla, por ejemplo

// Expect input as d/m/y
function isValidDate(s) {
  var bits = s.split(''/'');
  var d = new Date(bits[2], bits[1] - 1, bits[0]);
  return d && (d.getMonth() + 1) == bits[1];
}

[''0/10/2017'',''29/2/2016'',''01/02''].forEach(function(s) {
  console.log(s + '' : '' + isValidDate(s))
})

Al probar una Fecha de esta manera, solo se debe probar el mes, ya que si la fecha está fuera de rango, el mes cambiará. Lo mismo si el mes está fuera del rango. Cualquier año es válido

También puedes probar los bits de la cadena de fecha:

function isValidDate2(s) {
  var bits = s.split(''/'');
  var y = bits[2],
    m = bits[1],
    d = bits[0];
  // Assume not leap year by default (note zero index for Jan)
  var daysInMonth = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];

  // If evenly divisible by 4 and not evenly divisible by 100,
  // or is evenly divisible by 400, then a leap year
  if ((!(y % 4) && y % 100) || !(y % 400)) {
    daysInMonth[1] = 29;
  }
  return !(//D/.test(String(d))) && d > 0 && d <= daysInMonth[--m]
}

[''0/10/2017'',''29/2/2016'',''01/02''].forEach(function(s) {
  console.log(s + '' : '' + isValidDate2(s))
})

Answer 11

function isValidDate(year, month, day) {
        var d = new Date(year, month - 1, day, 0, 0, 0, 0);
        return (!isNaN(d) && (d.getDate() == day && d.getMonth() + 1 == month && d.getYear() == year));
    }

Answer 12

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

esta función devuelve el valor bool de si la entrada dada es una fecha válida o no. ex:

if(isDate_(var_date)) {
  // statements if the date is valid
} else {
  // statements if not valid
}