JS'de geçerli ve geçersiz tarih nesneleri arasındaki farkı söylemek istiyorum, ancak nasıl olduğunu anlayamadım:

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'

Bir isValidDateişlev yazmak için herhangi bir fikrin var mı?

• Date.parseTarih dizelerinin ayrıştırılması için önerilen kül , tarih dizesinin geçerli olup olmadığını kontrol etmek için yetkili bir yol sunar.
• Mümkünse tercih edeceğim şey, API'mın bir Date örneğini kabul etmesi ve geçerli olup olmadığını kontrol edebilmesidir. Borgar'ın çözümü bunu yapıyor, ancak tarayıcılarda test etmem gerekiyor. Ayrıca daha zarif bir yol olup olmadığını merak ediyorum.
• Ash, API'mın Dateörnekleri kabul etmediğini düşünmemi sağladı , bunu doğrulamak en kolayı olurdu.
• Borgar bir Dateörnek için test yapılmasını ve ardından Date's zaman değerini test etmeyi önerdi . Tarih geçersizse, zaman değeri olur NaN. ECMA-262 ile kontrol ettim ve bu davranış standart, tam olarak aradığım şey.

İşte nasıl yaparım:

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
}

Güncelleme [2018-05-31] : Diğer JS bağlamlarındaki Date nesneleriyle (harici pencereler, çerçeveler veya iframe'ler) ilgilenmiyorsanız, bu daha basit form tercih edilebilir:

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

Kullanmak yerine new Date()şunları kullanmalısınız:

var timestamp = Date.parse('foo');

if (isNaN(timestamp) == false) {
  var d = new Date(timestamp);
}

Date.parse()01 / Ocak / 1970'den bu yana milisaniye sayısını temsil eden bir tam sayı döndürür. NaNSağlanan tarih dizesini ayrıştıramıyorsa geri döner .

Bir Datenesnenin geçerliliğini şu dyolla kontrol edebilirsiniz:

d instanceof Date && isFinite(d)

Çerçeveler arası sorunları önlemek için, instanceofçek ile değiştirilebilir

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

Borgar'ın cevabındakigetTime() gibi bir çağrı gereksizdir ve her ikisi de dolaylı olarak sayıya dönüşür .isNaN()isFinite()

Çözümüm, geçerli bir tarih nesnesi alıp almadığınızı kontrol etmektir:

uygulama

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

kullanım

var d = new Date("lol");

console.log(d.isValid()); // false

d = new Date("2012/09/11");

console.log(d.isValid()); // true

geçerli tarihi kontrol etmek için en kısa cevap

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

Moment.js'yi kullanabilirsiniz .

İşte bir örnek:

var m = moment('2015-11-32', 'YYYY-MM-DD');
m.isValid(); // false

Doğrulama bölümünde belgelerinde oldukça açıktır.

Ayrıca, aşağıdaki ayrıştırma bayrakları geçersiz bir tarihle sonuçlanır:

• overflow: 13. ay, ayın 32. günü (veya artık olmayan yıllarda 29 Şubat), yılın 367. günü vb. Gibi bir tarih alanının taşması, geçersiz birimin dizinini içeriyor #invalidAt ile eşleşmek için (aşağıya bakın); -1 taşma anlamına gelir.
• invalidMonth: Moment ('Mart', 'MMMM') gibi geçersiz bir ay adı ;. Geçersiz ay dizesinin kendisini veya null değerini içerir.
• empty: Moment ('bu saçmalık') gibi ayrıştırılabilir hiçbir şey içermeyen bir giriş dizesi; Boole.
• Vb.

Kaynak: http://momentjs.com/docs/

JQuery UI DatePicker widget'ının biçim ve geçerliliği kontrol eden çok iyi bir tarih doğrulama aracı yöntemine sahip olduğunu belirtmek isteriz (örneğin, 01/33/2013 tarihlerine izin verilmez).

Sayfanızdaki tarih seçici widget'ını bir kullanıcı arayüzü öğesi olarak kullanmak istemeseniz bile, her zaman .js kütüphanesini sayfanıza ekleyebilir ve ardından, doğrulamak istediğiniz değeri ona aktararak doğrulama aracı yöntemini çağırabilirsiniz. Hayatı daha da kolaylaştırmak için, bir JavaScript Tarihi nesnesi değil, girdi olarak bir dize alır.

Bkz. Http://api.jqueryui.com/datepicker/

Bir yöntem olarak listelenmez, ancak orada - bir yardımcı program işlevi olarak. Sayfayı "parsedate" için aradığınızda şunları bulabilirsiniz:

$ .datepicker.parseDate (biçim, değer, ayarlar) - Belirtilen biçime sahip bir dize değerinden bir tarih ayıklar.

Örnek kullanım:

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

(Tarih biçimlerini belirlemeye ilişkin daha fazla bilgiyi http://api.jqueryui.com/datepicker/#utility-parseDate adresinde bulabilirsiniz )

Yukarıdaki örnekte, '01 / 03/2012 'belirtilen biçimde takvimde geçerli bir tarih olduğu için uyarı iletisini göremezsiniz. Ancak, 'stringval' değerini '13 / 04/2013 'e eşit yaparsanız, '13 / 04/2013' değeri takvimde geçerli olmadığından uyarı iletisini alırsınız.

Geçirilen bir dize değeri başarıyla ayrıştırılırsa, 'testdate' değeri, iletilen dize değerini temsil eden bir Javascript Date nesnesi olur. Değilse, tanımsız olurdu.

Christoph'un yaklaşımını gerçekten sevdim (ancak oy kullanmak için yeterli bir üne sahip değildim). Benim kullanım için, her zaman bir Date nesnesi olacak biliyorum, bu yüzden sadece geçerli bir () yöntemi ile tarihi uzattım.

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

Şimdi bunu yazabilirim ve sadece koddaki isFinite'i kontrol etmekten çok daha açıklayıcı ...

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

bu cıvıltı ile geçerli txDate.value biçimini kontrol edebilirsiniz. yanlış biçimdeyse Date obejct somutlaştırılmadı ve nt değerini dt'ye döndür.

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

Ve @ MiF'nin kısaca önerdiği gibi

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

Yıl, ay ve tarih için değerleri doğrulamak için aşağıdaki kodu kullanın.

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

Ayrıntılar için bkz . Javascript'teki tarihi kontrol etme

Burada zaten çok fazla karmaşık cevap var, ancak basit bir satır yeterli (ES5):

Date.prototype.isValid = function (d) { return !isNaN(Date.parse(d)) } ;

hatta ES6'da:

Date.prototype.isValid = d => !isNaN(Date.parse(d));

Bu küçük pasaja yaklaşan bazı cevaplar gördüm.

JavaScript yolu:

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

TypeScript yolu:

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

Güzel çözüm! Yardımcı fonksiyonlar kütüphaneme dahil, şimdi şöyle görünüyor:

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

Bu benim için çalıştı

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

Ancak bu işe yaramadı

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

Angular.js projeleri için şunları kullanabilirsiniz:

angular.isDate(myDate);

31.02.2012 gibi bir tarihi doğrulamaya çalışırken bu yanıtların hiçbiri benim için (Safari 6.0'da test edildi) işe yaramadı, ancak 31'den büyük herhangi bir tarihi denerken iyi çalışıyorlar.

Bu yüzden biraz güç harcamam gerekiyordu. Tarihin formatta olduğu varsayılarak mm/dd/yyyy. @Broox cevap kullanıyorum:

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

Yukarıdaki çözümlerin hiçbiri benim için işe yaramadı, ancak ne işe yaradı?

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

yukarıdaki kod, JS'nin 02.02.2012 ile 03/02/2012 tarihine kadar geçerli olmadığını gördüğünde

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

Bu işlevi yazdım. Bir string parametresi iletin ve bu "dd / AA / yyyy" biçimini temel alarak geçerli bir tarih olup olmadığını belirler.

işte bir test

girdi: "hahaha", çıktı: yanlış.

girdi: "29/2/2000", çıktı: doğru.

girdi: "29/2/2001", çıktı: yanlış.

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.toISOStringRangeErrorgeçersiz tarihlerde atar (en azından Chromium ve Firefox'ta). Doğrulama aracı olarak kullanabilirsiniz ve bu şekilde gerekmeyebilir isValidDate(EAFP). Aksi takdirde:

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

Borgar'ın yaklaşımından esinlenerek kodun sadece tarihi doğrulamakla kalmayıp, aynı zamanda tarihin gerçek bir tarih olmasını da sağladım, yani 31/09/2011 ve 29/02/2011 gibi tarihlere izin verilmiyor.

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

Belirli bir nesne olup olmadığını kontrol ettiğimde bulduğum en iyi performans sonuçlarını birleştirdim:

• bir Date örneğidir ( burada karşılaştırma ölçütü )
• geçerli bir tarihi var ( karşılaştırma ölçütü )

Sonuç şudur:

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

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

Dizeye tarih nesnesi, her iki alanın da geçerli tarih olup olmadığını tespit etmenin daha basit ve güvenilir bir yoludur. Örneğin, tarih giriş alanına "-------" girerseniz. Yukarıdaki cevaplardan bazıları işe yaramaz.

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

Seçilen cevap mükemmel ve ben de kullanıyorum. Ancak, kullanıcı tarihi girişini doğrulamanın bir yolunu arıyorsanız, Date nesnesinin geçersiz inşaat bağımsız değişkenleri gibi görünen şeyleri geçerli olanlara dönüştürmede çok kalıcı olduğunu bilmelisiniz. Aşağıdaki birim test kodu noktayı gösterir:

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

Buna şöyle deyin

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

En yüksek puan alan cevaba dayalı hazır bir fonksiyon:

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

Basit ve zarif bir çözüm:

const date = new Date(`${year}-${month}-${day} 00:00`)
const isValidDate = (Boolean(+date) && date.getDate() == day)

kaynaklar:

[1] https://medium.com/@esganzerla/simple-date-validation-with-javascript-caea0f71883c

[2] JavaScript'te yeni Date () ile yanlış tarih gösteriliyor

Bence bunlardan bazıları uzun bir süreç. Aşağıda gösterildiği gibi kısa kesebiliriz:

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

Bir tarihin int 1 tabanlı bileşenleri için:

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

Testler:

    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)