JS에서 유효하고 유효하지 않은 날짜 객체의 차이점을 말하고 싶지만 방법을 알 수 없습니다.

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'

isValidDate함수 작성에 대한 아이디어가 있습니까?

• Ash는 Date.parse날짜 문자열을 구문 분석하는 데 권장 되며 날짜 문자열이 유효한지 확인하는 신뢰할 수있는 방법을 제공합니다.
• 가능한 경우 API가 Date 인스턴스를 수락하고 유효한지 여부를 확인 / 주장 할 수있게하는 것이 좋습니다. Borgar의 솔루션은 그렇게하지만 브라우저에서 테스트해야합니다. 또한 더 우아한 방법이 있는지 궁금합니다.
• Ash는 API 수락 Date인스턴스를 전혀 사용하지 않는 것을 고려 했습니다. 이는 확인하는 것이 가장 쉽습니다.
• Borgar는 Date인스턴스 테스트를 제안한 다음 Date시간 값 을 테스트 하도록 제안했습니다 . 날짜가 유효하지 않은 경우 시간 값은 NaN입니다. ECMA-262로 확인 했는데이 동작은 표준이며 정확히 내가 찾는 것입니다.

내가하는 방법은 다음과 같습니다.

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
}

업데이트 [2018-05-31] : 다른 JS 컨텍스트 (외부 창, 프레임 또는 iframe)의 Date 객체와 관련이없는 경우이 간단한 양식이 선호 될 수 있습니다.

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

사용하는 대신 new Date()다음을 사용해야합니다.

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

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

Date.parse()01 / Jan / 1970 이후의 밀리 초 수를 나타내는 정수인 타임 스탬프를 반환합니다. NaN제공된 날짜 문자열을 구문 분석 할 수 없으면 리턴 됩니다.

당신은 통해 Date객체 의 유효성을 확인할 수 있습니다d

d instanceof Date && isFinite(d)

교차 프레임 문제를 피하기 위해 instanceof수표를

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

에 대한 호출 getTime()에서와 같이 Borgar의 대답은 같은 불필요 isNaN()하고 isFinite()모두 암시 적으로 숫자로 변환.

내 솔루션은 유효한 날짜 개체가 있는지 간단히 확인하는 것입니다.

이행

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

용법

var d = new Date("lol");

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

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

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

유효한 날짜를 확인하는 가장 짧은 답변

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

간단히 moment.js 를 사용할 수 있습니다

예를 들면 다음과 같습니다.

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

문서 의 유효성 검사 섹션 은 매우 분명합니다.

또한 다음 구문 분석 플래그는 유효하지 않은 날짜를 초래합니다.

• overflow: 13 번째 달, 32 번째 날 (또는 윤년이 아닌 2 월 29 일), 367 번째 날 등의 날짜 필드 오버플로에는 잘못된 단위의 인덱스가 포함됩니다. #invalidAt와 일치합니다 (아래 참조). -1은 오버플로가 없음을 의미합니다.
• invalidMonth: moment ( 'Marbruary', 'MMMM');과 같은 잘못된 월 이름입니다. 잘못된 월 문자열 자체를 포함하거나 그렇지 않은 경우 널을 포함합니다.
• empty: moment ( 'this is nonsense');와 같이 구문 분석이 불가능한 입력 문자열. 부울.
• 기타.

출처 : http://momentjs.com/docs/

jQuery UI DatePicker 위젯에는 형식 및 유효성을 확인하는 매우 유용한 날짜 유효성 검증기 유틸리티 메소드가 있습니다 (예 : 01/33/2013 날짜는 허용되지 않음).

페이지에서 datepicker 위젯을 UI 요소로 사용하지 않더라도 항상 .js 라이브러리를 페이지에 추가 한 다음 유효성 검사기 메서드를 호출하여 유효성을 검사하려는 값을 전달할 수 있습니다. 삶을 더 쉽게 만들기 위해 JavaScript Date 객체가 아닌 입력으로 문자열을 사용합니다.

보다: http://api.jqueryui.com/datepicker/

메소드로 표시되지는 않지만 유틸리티 함수로 표시됩니다. "구문 분석"페이지를 검색하면 다음을 찾을 수 있습니다.

$ .datepicker.parseDate (format, value, settings)-지정된 형식의 문자열 값에서 날짜를 추출합니다.

사용법 예 :

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

(날짜 형식을 지정하는 자세한 정보는 http://api.jqueryui.com/datepicker/#utility-parseDate에 있습니다. )

위의 예에서는 '01 / 03 / 2012 '가 지정된 형식의 달력 유효 날짜이므로 경고 메시지가 표시되지 않습니다. 그러나 'stringval'을 '13 / 04 / 2013 '과 동일하게 만든 경우 값 '13 / 04 / 2013'이 달력이 아니므로 경고 메시지가 표시됩니다.

전달 된 문자열 값이 성공적으로 구문 분석되면 'testdate'의 값은 전달 된 문자열 값을 나타내는 Javascript Date 객체입니다. 그렇지 않으면 정의되지 않은 것입니다.

나는 Christoph의 접근법을 정말로 좋아했지만 (투표 할만큼 평판이 충분하지 않았습니다). 필자는 항상 Date 객체를 사용하므로 valid () 메서드로 날짜를 연장했습니다.

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

이제 이것을 작성할 수 있으며 코드에서 isFinite를 확인하는 것보다 훨씬 더 설명 적입니다 ...

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

이 scirpt를 사용하여 txDate.value의 유효한 형식을 확인할 수 있습니다. 형식이 올바르지 않은 경우 Date obejct는 인스턴스화되지 않으며 dt에 null을 반환합니다.

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

그리고 @MiF가 짧은 방법으로 제안한 것처럼

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

다음 코드를 사용하여 연도, 월 및 날짜의 값을 확인합니다.

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

자세한 내용 은 자바 스크립트에서 날짜 확인을 참조하십시오.

여기에 너무 많은 복잡한 답변이 있지만 간단한 줄이면 충분합니다 (ES5).

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

또는 ES6에서도 :

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

나는이 작은 발췌 문장에 가까운 몇 가지 답변을 보았습니다.

자바 스크립트 방식 :

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

TypeScript 방식 :

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

좋은 해결책! 보조 기능 라이브러리에 포함되어 이제 다음과 같이 보입니다.

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

이것은 단지 나를 위해 일했다

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

그러나 이것은 작동하지 않았습니다

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

Angular.js 프로젝트의 경우 다음을 사용할 수 있습니다.

angular.isDate(myDate);

이 답변 중 어느 것도 2012 년 2 월 31 일과 같은 날짜의 유효성을 검사하려고 할 때 (Safari 6.0에서 테스트) 나에게 도움이되지 않지만 31보다 큰 날짜를 시도하면 제대로 작동합니다.

그래서 나는 약간의 힘을가했습니다. 날짜가 형식이라고 가정합니다 mm/dd/yyyy. @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

그러나 위의 해결책 중 어느 것도 효과가 없었습니다.

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

위의 코드는 JS가 2012 년 2 월 31 일을 2012 년 3 월 2 일에 유효하지 않은 것으로 만들 때 볼 수 있습니다

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

이 기능을 작성했습니다. 문자열 매개 변수를 전달하면이 형식 "dd / MM / yyyy"를 기반으로 유효한 날짜인지 여부를 판별합니다.

여기 시험이있다

입력 : "hahaha", 출력 : false.

입력 : "29/2/2000", 출력 : true.

입력 : "29/2/2001", 출력 : false.

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.toISOString발생 RangeError(크롬과 파이어 폭스에 적어도) 잘못된 날짜에. 이를 검증 수단으로 사용할 수 있으며 필요하지 않을 수도 있습니다 isValidDate(EAFP). 그렇지 않으면 :

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

Borgar의 접근 방식에서 영감을 받아 코드가 날짜의 유효성을 검사 할뿐만 아니라 실제로 날짜가 실제 날짜인지 확인했습니다. 즉, 31/09/2011 및 29/02/2011과 같은 날짜는 허용되지 않습니다.

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

주어진 객체인지 확인한 결과 최고의 성능 결과를 결합했습니다.

• Date 인스턴스입니다 ( 여기에서 벤치 마크 ).
• 유효한 날짜가 있습니다 ( 여기에서 벤치 마크 )

결과는 다음과 같습니다.

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

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

Date object to string은 두 필드가 모두 유효한 날짜인지 감지하는보다 간단하고 안정적인 방법입니다. 예를 들어 날짜 입력 필드에 "-------"를 입력하면 위의 답변 중 일부가 작동하지 않습니다.

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

선택한 답변이 우수하며 사용하고 있습니다. 그러나 사용자 날짜 입력의 유효성을 검사하는 방법을 찾고 있다면 Date 객체가 유효하지 않은 구성 인수로 보이는 것을 유효한 것으로 만드는 것에 대해 매우 영구적이라는 것을 알고 있어야합니다. 다음 단위 테스트 코드는 요점을 보여줍니다.

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

이렇게 불러

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

최고 등급의 답변을 기반으로 준비된 기능 :

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

간단하고 우아한 솔루션 :

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

출처 :

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

[2] JavaScript에서 new Date ()에 잘못된 날짜가 표시됨

나는 이것의 일부가 긴 과정이라고 생각한다. 아래와 같이 짧게 줄일 수 있습니다.

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

날짜의 int 1 기반 구성 요소의 경우 :

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

테스트 :

    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)