now - javascript datetime format

Detectando una fecha de "fecha no válida" en JavaScript

Question

Me gustaría decir la diferencia entre objetos de fecha válidos e invá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 función isValidDate ?

• Ash recomendó Date.parse para analizar las 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 Fecha y pueda verificar / afirmar si es válida o no. La solución de Borgar hace eso, pero necesito probarlo en los navegadores. También me pregunto si hay una forma más elegante.
• Ash me hizo considerar no tener mi API para aceptar las instancias de la Date , esto sería más fácil de validar.
• Borgar sugirió probar una instancia de Date y luego probar el valor de tiempo de la Date . Si la fecha no es válida, el valor de tiempo es NaN . Lo comprobé con ECMA-262 y este comportamiento está en el estándar, que es exactamente lo que estoy buscando.

Answer 1

Puedes simplemente 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, las siguientes banderas 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 sin salto), un día 367 del año, etc., contiene el índice del inválido. unidad para coincidir 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, o bien nula.
• empty : una cadena de entrada que no contiene nada analizable, como el momento (''esto es un disparate'') ;. Booleano
• Etc.

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

Answer 2

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 está preocupado por los objetos Fecha de otros contextos JS (ventanas externas, marcos o marcos), esta forma más simple puede ser la preferida:

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

Answer 3

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

Answer 4

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

• es una instancia de fecha ( punto de referencia aquí )
• tiene una fecha válida ( jsperf.com/detecting-an-invalid-date )

El resultado es el siguiente:

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

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

Answer 5

Creo que algo de esto es un proceso largo. Podemos cortarlo corto 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;
    }

Answer 6

En general, me quedo con cualquier fecha de implantación en la pila del navegador. Lo que significa que siempre obtendrá una "Fecha no válida " cuando llame a toDateString () en Chrome, Firefox y Safari a partir de la fecha de esta respuesta.

if(!Date.prototype.isValidDate){
  Date.prototype.isValidDate = function(){
    return this.toDateString().toLowerCase().lastIndexOf(''invalid'') == -1;
  };
}

Sin embargo, no probé esto en IE.

Answer 7

En lugar de usar la 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 entero que representa el número de milisegundos desde 01 / Jan / 1970. NaN si no puede analizar la cadena de fecha suministrada.

Answer 8

Esto solo me funcionó

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

Sin embargo esto no funcionó

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

Answer 9

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

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

Answer 10

Inspirado por el enfoque de Borgar, me aseguré de que el código no solo valide la fecha, sino que en realidad se asegure de que la fecha sea una fecha real, lo que significa que las fechas como el 31/09/2011 y el 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!";
}

Answer 11

La fecha desde el objeto a la cadena 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}.'');

Answer 12

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

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

Answer 13

La respuesta seleccionada es excelente, y la estoy usando también. Sin embargo, si está buscando una manera de validar la entrada de la fecha del usuario, debe tener en cuenta que el objeto Fecha es muy persistente para convertir lo que podrían parecer argumentos de construcción invá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());
});

Answer 14

Me gustaría mencionar que el widget jQuery UI DatePicker tiene un método de utilidad de validador de fechas 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 del 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 del validador, pasando el valor que desea validar. Para hacer la vida aún más fácil, toma una cadena como entrada, no un objeto Fecha de JavaScript.

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

No está listado como un método, pero está ahí, como una función de utilidad. Busca en la página "parsedate" y encontrarás:

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

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 la especificación de 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 para el calendario en el formato especificado. Sin embargo, si creó ''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 el valor de una cadena pasada se analiza correctamente, el valor de ''testdate'' sería un objeto de fecha de Javascript que representa el valor de la cadena pasada. Si no, sería indefinido.

Answer 15

Mi solución es simplemente para comprobar si obtiene un objeto de fecha válida:

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

Answer 16

Ninguna de estas respuestas funcionó para mí (probado en Safari 6.0) cuando intenté validar una fecha como el 31 de febrero de 2012, sin embargo, funcionan bien cuando se intenta una fecha mayor a 31.

Así que tuve que fuerza bruta un poco. Suponiendo que la fecha está en 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

Answer 17

Ninguna de las soluciones anteriores funcionó para mí, pero sí funcionó.

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á cuándo JS hace el 31/02/2012 al 02/03/2012 que no es válido

Answer 18

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)

Answer 19

Para los proyectos de Angular.js puedes usar:

angular.isDate(myDate);

Answer 20

Puede comprobar la validez de un objeto Date través de

d instanceof Date && isFinite(d)

Para evitar problemas de cuadros cruzados, uno podría reemplazar la instanceof verificación con

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

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

Answer 21

Puede verificar el formato válido de txDate.value con este scirpt. si estaba en un formato incorrecto, la fecha no se instanciaba y devolvía el valor nulo a dt.

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

Y como @ MiF''s sugirió de manera corta.

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

Answer 22

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

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

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

d = new Date(userDate);
if (d.valid()) { /* do stuff */ }

Answer 23

Una función lista basada en la respuesta más valorada:

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

Answer 24

Utilizo el siguiente código para validar los valores de 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 Fecha de verificación en javascript.

Answer 25

Ya hay demasiadas respuestas complicadas aquí, pero una simple línea 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));

Answer 26

puedes convertir tu fecha y hora en milisegundos getTime()

este método getTime() devuelve No un número NaN cuando no es válido

if(!isNaN(new Date("2012/25/255").getTime()))
  return ''valid date time'';
  return ''Not a valid date time'';

Answer 27

function isValidDate(date) {
  return !! (Object.prototype.toString.call(date) === "[object Date]" && +date);
}

Answer 28

// check whether date is valid
var t = new Date(''2011-07-07T11:20:00.000+00:00x'');
valid = !isNaN(t.valueOf());

Answer 29

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

Answer 30

function isValidDate(strDate) {
    var myDateStr= new Date(strDate);
    if( ! isNaN ( myDateStr.getMonth() ) ) {
       return true;
    }
    return false;
}

Llamalo asi

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