JavaScript의 객체 속성이 올바른지 확인하는 가장 좋은 방법은 무엇입니까 undefined?

속성 값이 특별한 값인지 확인하는 일반적인 방법 undefined은 다음과 같습니다.

if(o.myProperty === undefined) {
  alert("myProperty value is the special value `undefined`");
}

객체에 실제로 이러한 속성이 없는지 확인 undefined하여 액세스하려고 할 때 기본적으로 반환 됩니다.

if(!o.hasOwnProperty('myProperty')) {
  alert("myProperty does not exist");
}

식별자와 연관된 값은 특수 값인지 확인하기 위해 undefined, 또는 그 식별자가 선언되지 않은 경우. 참고 :이 방법은 초기 오류없이 선언되지 않은 (참고 : 값을 갖는 것과는 다른 undefined) 식별자 를 참조하는 유일한 방법입니다 .

if(typeof myVariable === 'undefined') {
  alert('myVariable is either the special value `undefined`, or it has not been declared');
}

ECMAScript 5 이전의 JavaScript 버전에서는 전역 객체에서 "undefined"라는 속성을 쓸 foo === undefined수 있었으므로 실수로 재정의 된 경우 간단한 확인 이 예기치 않게 작동 할 수 있습니다. 최신 JavaScript에서이 속성은 읽기 전용입니다.

그러나 현대 JavaScript에서 "undefined"는 키워드가 아니므로 함수 내부의 변수 이름을 "undefined"로 지정하고 전역 속성을 숨길 수 있습니다.

이 경우에 대해 우려되는 경우 void 연산자 를 사용 하여 특수 undefined값 자체 를 얻을 수 있습니다.

if(myVariable === void 0) {
  alert("myVariable is the special value `undefined`");
}

이 주제에 대한 많은 잘못된 답변이 있다고 생각합니다. 일반적인 믿음과는 달리, "정의는" 하지 JavaScript의 키워드 실제로 값을 할당 할 수 있습니다.

올바른 코드

이 테스트를 수행하는 가장 강력한 방법은 다음과 같습니다.

if (typeof myVar === "undefined")

이것은 항상 올바른 결과를 반환하고 상황을 처리합니다. myVar 선언되지 않은 .

코드를 줄입니다. 사용하지 마세요.

var undefined = false;  // Shockingly, this is completely legal!
if (myVar === undefined) {
    alert("You have been misled. Run away!");
}

또한 myVar === undefinedmyVar가 선언되지 않은 상황에서 오류가 발생합니다.

여기에 많은 다른 답변들에 의해 강력히 추천되었지만 typeof , 나쁜 선택 입니다. 변수에 값이 있는지 여부를 확인하는 데 사용해서는 안됩니다. 변수가 값 undefined과 변수가 있는지 여부를 종합적으로 검사 하는 역할을하기 때문 undefined입니다. 대부분의 경우 변수가 존재하는시기를 알고 typeof있으며 변수 이름이나 문자열 literal에 오타가 있으면 자동 실패 가능성이 나타납니다 'undefined'.

var snapshot = …;

if (typeof snaposhot === 'undefined') {
    //         ^
    // misspelled¹ – this will never run, but it won’t throw an error!
}

var foo = …;

if (typeof foo === 'undefned') {
    //                   ^
    // misspelled – this will never run, but it won’t throw an error!
}

따라서 기능 감지를 수행하지 않는 한 (예 typeof module !== 'undefined': CommonJS 환경에 특정한 코드의 단계로 확인하는 것과 같이) 지정된 이름이 범위 내에 있는지 확실하지 않은 경우 typeof변수에 사용될 때 해로운 선택이며 올바른 옵션은 다음과 같습니다. 값을 직접 비교하려면 :

var foo = …;

if (foo === undefined) {
    ⋮
}

이에 대한 몇 가지 일반적인 오해는 다음과 같습니다.

• 에 "초기화되지 않은"변수 (읽는 것을 var foo() 또는 매개 변수 function bar(foo) { … }로 불리는 것은 bar()) 실패합니다. 이것은 명백한 사실이 아닙니다. 명시적인 초기화가없는 변수와 값이 주어지지 않은 매개 변수 undefined는 항상이고 항상 범위 내에 있습니다.

• 그게 undefined덮어 쓸 수 있습니다. 이것에 더 많은 것이 있습니다. undefinedJavaScript의 키워드가 아닙니다. 대신, 정의되지 않은 값을 가진 전역 객체의 속성입니다. 그러나 ES5 이후로이 특성은 읽기 전용 이며 구성 할 수 없습니다 . 현대의 브라우저는 undefined속성을 변경할 수 없으며 2017 년 현재 오랫동안 그렇게되었습니다. 엄격한 모드의 부족은 undefined의 행동에도 영향을 미치지 않습니다 – 그냥 undefined = 5던지기 대신 아무 것도하지 않는 것과 같은 문장을 만듭니다 . 키워드가 아니기 때문에 name을 사용하여 변수를 선언 할 수 undefined있으며 해당 변수를 변경하여 다음과 같은 일반적인 패턴을 만들 수 있습니다.

  (function (undefined) {
      // …
  })()

  전역을 사용하는 것보다 더 위험합니다 undefined. 당신이 ES3와 호환 될 경우, 대신 undefined에 void 0-에 의존하지 않습니다 typeof. ( void항상 피연산자에 대해 정의되지 않은 값으로 평가되는 단항 연산자였습니다.)

변수가 작동하지 않는 방식으로 실제 질문 인 객체 속성을 해결해야합니다. typeof객체 속성에 사용할 이유가 없습니다 . 기능 감지와 관련된 이전 예외는 여기에 적용되지 않습니다.typeof . 변수에 대한 특수 동작 만 있으며 개체 속성을 참조하는 식은 변수가 아닙니다.

이:

if (typeof foo.bar === 'undefined') {
    ⋮
}

입니다 항상 정확히 동등한 this³에 :

if (foo.bar === undefined) {
    ⋮
}

위의 조언을 고려하여 독자가 왜 사용하고 있는지 혼란스럽지 않게하기 위해 변수의 값을 나중에 확인하도록 리팩토링 할 수 있고 평범하기 때문에 평등을 확인 typeof하는 ===데 가장 적합하기 때문에 더 좋아 보인다, 당신은 항상 === undefined여기서도 ³ 를 사용해야한다 .

객체 속성과 관련하여 고려해야 할 사항은 실제로 확인하고 싶은지 여부 undefined입니다. 주어진 속성 이름은 객체에 없거나 ( undefined읽을 때 값을 생성 함) 값 과 함께 객체 자체 undefined에 존재 undefined하거나, 값과 함께 객체의 프로토 타입에 존재하거나, undefined값 이 아닌 객체에 존재 합니다. 'key' in obj키가 오브젝트의 프로토 타입 체인에 있는지 여부와 키가 오브젝트에 Object.prototype.hasOwnProperty.call(obj, 'key')직접 있는지 여부를 알려줍니다. 프로토 타입과 객체를 문자열 키 맵으로 사용하는 것에 대한이 답변에 대해서는 자세하게 설명하지 않겠습니다. 원래 질문에 대한 가능한 해석과 상관없이 다른 답변의 모든 나쁜 조언에 대항하기 때문입니다. 에 읽어더 많은 것을 위해 MDN의 객체 프로토 타입 !

_{¹ 예제 변수 이름의 특이한 선택? 이것은 Firefox 용 NoScript 확장 프로그램의 실제 죽은 코드입니다.
² 범위가 무엇인지 모르는 것이 일반적으로 괜찮다고 가정하지 마십시오. 다이나믹 스코프 남용으로 인한 보너스 취약점 : ES5 + 환경을 가정 하여 전역 객체 의 속성 을 나타내는 Project Zero 1225
³를 다시 한 번 . 그렇지 않으면 대체하십시오 .undefinedundefinedvoid 0}

JavaScript에는 null 이 있으며 정의되지 않았습니다 . 그들은 다른 의미를 가지고 있습니다.

• 찾으시는 주소가 없습니다 는 변수 값이 의미합니다. 값이 무엇인지 알 수 없습니다.
• null 은 변수 값이 정의되고 null로 설정됨을 의미합니다 (값 없음).

Marijn Haverbeke는 그의 무료 온라인 책 " Eloquent JavaScript "(강조 광산)에서 다음과 같이 말합니다.

비슷한 의미의 null도 있는데,이 의미는 '이 값은 정의되어 있지만 값이 없습니다'입니다. undefined와 null의 의미 차이는 대부분 학문적이며 일반적으로 그리 흥미롭지 않습니다. 실제 프로그램에서는 종종 '가치'가 있는지 확인해야합니다. 이러한 경우, == undefined라는 표현식이 사용될 수 있는데, 이는 정확히 같은 값이 아니더라도 null == undefined가 true를 생성하기 때문입니다.

따라서 정의되지 않은 것이 있는지 확인하는 가장 좋은 방법은 다음과 같습니다.

if (something == undefined)

도움이 되었기를 바랍니다!

편집 : 편집에 대한 응답으로 객체 속성이 같은 방식으로 작동해야합니다.

var person = {
    name: "John",
    age: 28,
    sex: "male"
};

alert(person.name); // "John"
alert(person.fakeVariable); // undefined

이것이 의미하는 것은 "undefined object property" ?

실제로 그것은 두 가지 다른 것을 의미 할 수 있습니다! 첫째, 그것은 의미 정의 적이 속성 둘째,이 의미는 개체 및 정의되지 않은 값을 갖는 속성 . 이 코드를 보자 :

var o = { a: undefined }

되어 o.a정의되지? 예! 그 값은 정의되어 있지 않습니다. 되어 o.b정의되지? 확실한! 'b'속성이 전혀 없습니다! 두 상황에서 서로 다른 접근법이 어떻게 작동하는지 봅시다.

typeof o.a == 'undefined' // true
typeof o.b == 'undefined' // true
o.a === undefined // true
o.b === undefined // true
'a' in o // true
'b' in o // false

우리는 그것을 명확하게 볼 수 typeof obj.prop == 'undefined'있고 obj.prop === undefined동등하며, 그들은 서로 다른 상황을 구별하지 않습니다. 과'prop' in obj 속성이 전혀 정의되지 않았고 정의되지 않은 속성 값에주의를 기울이지 않는 상황을 감지 할 수 있습니다.

그래서 뭘 할건데?

1) 속성이 첫 번째 또는 두 번째 의미 (가장 일반적인 상황)에 의해 정의되지 않았는지 알고 싶습니다.

obj.prop === undefined // IMHO, see "final fight" below

2) 객체에 속성이 있고 그 값에 신경 쓰지 않는지 알고 싶습니다.

'prop' in obj

노트:

• 객체와 그 속성을 동시에 확인할 수는 없습니다. 예를 들어 x가 정의되지 않은 경우이 값 x.a === undefined이 typeof x.a == 'undefined'증가 ReferenceError: x is not defined합니다.
• 변수 undefined는 전역 변수이므로 실제로는window.undefined 브라우저에 있습니다). ECMAScript 1st Edition부터 지원되었으며 ECMAScript 5부터는 읽기 전용 입니다. 따라서 현대의 브라우저에서는 많은 저자가 우리를 놀라게하는 것을 좋아하므로 사실 로 재정의 할 수 없지만 오래된 브라우저의 경우 여전히 그렇습니다.

마지막 싸움 : obj.prop === undefinedvstypeof obj.prop == 'undefined'

장점 obj.prop === undefined:

• 조금 더 짧고 조금 더 예쁘게 보입니다
• 철자가 틀리면 자바 스크립트 엔진에서 오류가 발생합니다. undefined

마이너스 obj.prop === undefined :

• undefined 오래된 브라우저에서 재정의 가능

플러스 typeof obj.prop == 'undefined':

• 정말 보편적입니다! 새롭고 오래된 브라우저에서 작동합니다.

마이너스 typeof obj.prop == 'undefined' :

• 'undefned'( 철자가 틀렸다 난 그냥 그랬던 것처럼 당신이 그것을 맞춤법이 틀린 경우 자바 스크립트 엔진이 당신을 도울 수 있도록 여기에 단지 문자열 상수이다).

업데이트 (서버 측 JavaScript의 경우) :

Node.js는 전역 변수 undefined를 지원합니다 global.undefined( 'global'접두어 없이도 사용할 수 있습니다). 서버 쪽 JavaScript의 다른 구현에 대해서는 모르겠습니다.

이 문제는 다음 세 가지 사례로 요약됩니다.

1. 개체에 속성이 있으며 값이 아닙니다 undefined.
2. 객체에는 속성이 있으며 그 값은 undefined입니다.
3. 개체에 속성이 없습니다.

이것은 내가 중요하다고 생각하는 것을 알려줍니다.

정의되지 않은 멤버와 정의되지 않은 값을 가진 정의 된 멤버간에 차이가 있습니다.

그러나 불행하게도 typeof obj.foo우리가 가지고있는 세 가지 경우를 알려주지 않습니다. 그러나 "foo" in obj사례를 구별하기 위해 이를 결합 할 수 있습니다 .

                               |  typeof obj.x === 'undefined' | !("x" in obj)
1.                     { x:1 } |  false                        | false
2.    { x : (function(){})() } |  true                         | false
3.                          {} |  true                         | true

이 시험은 null출품작에 대해서도 동일하다는 점은 주목할 가치가 있습니다.

                               |  typeof obj.x === 'undefined' | !("x" in obj)
                    { x:null } |  false                        | false

나는 어떤 경우에는 속성이 있는지 여부를 확인하는 것보다 속성이 있는지 여부를 확인하는 것이 더 합리적이며 더 명확하다고 주장하며,이 확인이 다른 유일한 경우는 드문 경우입니다. 정의되지 않은 값을 가진 객체의 실제 항목

예를 들어, 방금 객체에 주어진 속성이 있는지 확인하는 많은 코드를 리팩토링했습니다.

if( typeof blob.x != 'undefined' ) {  fn(blob.x); }

정의되지 않은 검사없이 작성되었을 때 더 명확했습니다.

if( "x" in blob ) { fn(blob.x); }

그러나 언급했듯이 이것들은 정확히 동일하지는 않습니다 (그러나 내 필요에 충분합니다).

if ( typeof( something ) == "undefined") 

다른 사람들은 그렇지 않은 동안 이것은 나를 위해 일했습니다.

===와 함께 사용의 출처가 어디에서 왔는지 확실하지 않으며 typeof, 많은 라이브러리에서 사용 된 규칙을 보았지만 typeof 연산자는 문자열 리터럴을 반환하므로 우리는 그것을 미리 알고 있기 때문에 왜 입력하고 싶습니까? 그것도 확인?

typeof x;                      // some string literal "string", "object", "undefined"
if (typeof x === "string") {   // === is redundant because we already know typeof returns a string literal
if (typeof x == "string") {    // sufficient

관련 질문에 대한 답변 을 크로스 포스팅 JavaScript에서 "정의되지 않은"항목을 확인하는 방법은 무엇입니까?

이 질문과 관련된 테스트 사례를 참조하십시오 someObject.<whatever>.

다양한 답변의 결과를 보여주는 일부 시나리오 : http://jsfiddle.net/drzaus/UVjM4/

(주 사용한다는 var대한 in검사 차이를 만들 때 범위 래퍼)

참조 코드 :

(function(undefined) {
    var definedButNotInitialized;
    definedAndInitialized = 3;
    someObject = {
        firstProp: "1"
        , secondProp: false
        // , undefinedProp not defined
    }
    // var notDefined;

    var tests = [
        'definedButNotInitialized in window',
        'definedAndInitialized in window',
        'someObject.firstProp in window',
        'someObject.secondProp in window',
        'someObject.undefinedProp in window',
        'notDefined in window',

        '"definedButNotInitialized" in window',
        '"definedAndInitialized" in window',
        '"someObject.firstProp" in window',
        '"someObject.secondProp" in window',
        '"someObject.undefinedProp" in window',
        '"notDefined" in window',

        'typeof definedButNotInitialized == "undefined"',
        'typeof definedButNotInitialized === typeof undefined',
        'definedButNotInitialized === undefined',
        '! definedButNotInitialized',
        '!! definedButNotInitialized',

        'typeof definedAndInitialized == "undefined"',
        'typeof definedAndInitialized === typeof undefined',
        'definedAndInitialized === undefined',
        '! definedAndInitialized',
        '!! definedAndInitialized',

        'typeof someObject.firstProp == "undefined"',
        'typeof someObject.firstProp === typeof undefined',
        'someObject.firstProp === undefined',
        '! someObject.firstProp',
        '!! someObject.firstProp',

        'typeof someObject.secondProp == "undefined"',
        'typeof someObject.secondProp === typeof undefined',
        'someObject.secondProp === undefined',
        '! someObject.secondProp',
        '!! someObject.secondProp',

        'typeof someObject.undefinedProp == "undefined"',
        'typeof someObject.undefinedProp === typeof undefined',
        'someObject.undefinedProp === undefined',
        '! someObject.undefinedProp',
        '!! someObject.undefinedProp',

        'typeof notDefined == "undefined"',
        'typeof notDefined === typeof undefined',
        'notDefined === undefined',
        '! notDefined',
        '!! notDefined'
    ];

    var output = document.getElementById('results');
    var result = '';
    for(var t in tests) {
        if( !tests.hasOwnProperty(t) ) continue; // bleh

        try {
            result = eval(tests[t]);
        } catch(ex) {
            result = 'Exception--' + ex;
        }
        console.log(tests[t], result);
        output.innerHTML += "\n" + tests[t] + ": " + result;
    }
})();

그리고 결과 :

definedButNotInitialized in window: true
definedAndInitialized in window: false
someObject.firstProp in window: false
someObject.secondProp in window: false
someObject.undefinedProp in window: true
notDefined in window: Exception--ReferenceError: notDefined is not defined
"definedButNotInitialized" in window: false
"definedAndInitialized" in window: true
"someObject.firstProp" in window: false
"someObject.secondProp" in window: false
"someObject.undefinedProp" in window: false
"notDefined" in window: false
typeof definedButNotInitialized == "undefined": true
typeof definedButNotInitialized === typeof undefined: true
definedButNotInitialized === undefined: true
! definedButNotInitialized: true
!! definedButNotInitialized: false
typeof definedAndInitialized == "undefined": false
typeof definedAndInitialized === typeof undefined: false
definedAndInitialized === undefined: false
! definedAndInitialized: false
!! definedAndInitialized: true
typeof someObject.firstProp == "undefined": false
typeof someObject.firstProp === typeof undefined: false
someObject.firstProp === undefined: false
! someObject.firstProp: false
!! someObject.firstProp: true
typeof someObject.secondProp == "undefined": false
typeof someObject.secondProp === typeof undefined: false
someObject.secondProp === undefined: false
! someObject.secondProp: true
!! someObject.secondProp: false
typeof someObject.undefinedProp == "undefined": true
typeof someObject.undefinedProp === typeof undefined: true
someObject.undefinedProp === undefined: true
! someObject.undefinedProp: true
!! someObject.undefinedProp: false
typeof notDefined == "undefined": true
typeof notDefined === typeof undefined: true
notDefined === undefined: Exception--ReferenceError: notDefined is not defined
! notDefined: Exception--ReferenceError: notDefined is not defined
!! notDefined: Exception--ReferenceError: notDefined is not defined

당신이 할 경우

if (myvar == undefined )
{ 
    alert('var does not exists or is not initialized');
}

변수 myvar가 존재하지 않으면 myvar이 정의되지 않아 스크립트가 손상되고 테스트가 효과가 없으므로 실패합니다.

창 개체는 함수 외부에 전역 범위 (기본 개체)가 있으므로 선언은 창 개체에 '첨부'됩니다.

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

var myvar = 'test';

전역 변수 myvar 은 window.myvar 또는 window [ 'myvar']와 같습니다.

전역 변수가 존재할 때 테스트 오류를 ​​피하려면 다음을 사용하는 것이 좋습니다.

if(window.myvar == undefined )
{ 
    alert('var does not exists or is not initialized');
}

변수가 실제로 존재하는지에 대한 질문은 중요하지 않으며 값이 올바르지 않습니다. 그렇지 않으면 정의되지 않은 변수를 초기화하는 것은 어리석은 일이며 false 값을 사용하여 초기화하는 것이 좋습니다. 선언 한 모든 변수가 false로 초기화 된 것을 알면 단순히 해당 유형 !window.myvar을 확인 하거나 올바른 / 유효한 값이 있는지 확인하기 만하면 됩니다. 그래서 변수가 다음 정의되지 않은 경우에도 !window.myvar동일하다 myvar = undefined거나 myvar = false또는 myvar = 0.

특정 유형이 필요한 경우 변수 유형을 테스트하십시오. 조건 테스트 속도를 높이려면 다음을 수행하는 것이 좋습니다.

if( !window.myvar || typeof window.myvar != 'string' )
{
    alert('var does not exists or is not type of string');
}

첫 번째 간단한 조건이 true이면 인터프리터는 다음 테스트를 건너 뜁니다.

변수의 인스턴스 / 객체를 사용하여 유효한 값을 갖는지 확인하는 것이 좋습니다. 보다 안정적이며 더 나은 프로그래밍 방법입니다.

(와이)

나는 재산 앞에 물건을 검사하는 사람을 보지 못했다. 따라서 가장 짧고 효과적입니다 (반드시 가장 명확하지는 않지만).

if (obj && obj.prop) {
  // Do something;
}

obj 또는 obj.prop가 undefined, null 또는 "falsy"인 경우 if 문은 코드 블록을 실행하지 않습니다. 이것은 일반적으로 대부분의 코드 블록 명령문 (JavaScript)에서 원하는 동작입니다.

JavaScript에서 Nby와 Null의 심연 탐험 기사 에서 Underscore.js 와 같은 프레임 워크 가이 함수를 사용 한다는 것을 읽었습니다 .

function isUndefined(obj){
    return obj === void 0;
}

단순히 JavaScript로 정의되지 않은 , undefined , Object / Array 내부의 속성인지 여부는 중요하지 않습니다. 인지 또는 단순한 변수인지는 ...

자바 스크립트 typeof 정의되지 않은 변수를 매우 쉽게 감지 할 수 있도록합니다.

단순히 확인 typeof whatever === 'undefined' 부울을 반환 .

isUndefined()AngularJs v.1x 의 유명한 기능 은 다음과 같습니다.

function isUndefined(value) {return typeof value === 'undefined';} 

함수가 값을받는 것을 볼 수 있듯이, 해당 값이 정의되면을 반환하고 false, 그렇지 않으면 정의되지 않은 값을 반환 true합니다.

아래와 같이 객체 속성을 포함하여 값을 전달할 때 결과가 어떻게 될지 살펴 보겠습니다. 이것은 우리가 가진 변수의 목록입니다.

var stackoverflow = {};
stackoverflow.javascipt = 'javascript';
var today;
var self = this;
var num = 8;
var list = [1, 2, 3, 4, 5];
var y = null;

그리고 우리는 그것들을 아래에서 확인하면, 그 결과를 주석으로 볼 수 있습니다 :

isUndefined(stackoverflow); //false
isUndefined(stackoverflow.javascipt); //false
isUndefined(today); //true
isUndefined(self); //false
isUndefined(num); //false
isUndefined(list); //false
isUndefined(y); //false
isUndefined(stackoverflow.java); //true
isUndefined(stackoverflow.php); //true
isUndefined(stackoverflow && stackoverflow.css); //true

보시다시피 코드에서 이와 같이 무언가를 사용하여 무엇이든 확인할 수 있습니다. 단순히 typeof코드에서 사용할 수 있지만 반복해서 사용하는 경우 공유하고 재사용하는 각도 샘플과 같은 함수를 만듭니다. DRY 코드 패턴을 따릅니다.

또한 실제 응용 프로그램에서 객체가 존재하는지 확실하지 않은 객체의 속성을 확인하려면 객체가 먼저 존재하는지 확인하십시오.

객체의 속성을 확인하고 객체가 존재하지 않으면 오류가 발생하고 전체 응용 프로그램 실행이 중지됩니다.

isUndefined(x.css);
VM808:2 Uncaught ReferenceError: x is not defined(…)

다음과 같이 if 문을 감싸면 간단합니다.

if(typeof x !== 'undefined') {
  //do something
}

또한 Angular 1.x에서 isDefined와 동일합니다 ...

function isDefined(value) {return typeof value !== 'undefined';}

또한 밑줄과 같은 다른 자바 스크립트 프레임 워크에는 유사한 정의 검사가 있지만 typeof프레임 워크를 아직 사용하지 않는 경우 사용 하는 것이 좋습니다 .

또한 typeof, undefined 및 void (0)에 대한 유용한 정보가있는 MDN에서이 섹션을 추가합니다.

엄격한 동등성 및 정의되지 않음 정의되지 않은
엄격한 동등성 및 부등식 연산자를 사용하여 변수에 값이 있는지 확인할 수 있습니다. 다음 코드에서 변수 x는 정의되어 있지 않으며 if 문은 true로 평가됩니다.

var x;
if (x === undefined) {
   // these statements execute
}
else {
   // these statements do not execute
}

참고 : 여기서 x == undefined는 x가 null인지 여부를 검사하지만 엄격한 같음은 그렇지 않으므로 표준 같음 연산자가 아닌 엄격한 같음 연산자를 사용해야합니다. null은 undefined와 동일하지 않습니다. 자세한 내용은 비교 연산자를 참조하십시오.

Typeof 연산자 및 undefined
또는 typeof를 사용할 수 있습니다.

var x;
if (typeof x === 'undefined') {
   // these statements execute
}

typeof를 사용하는 한 가지 이유는 변수가 선언되지 않은 경우 오류가 발생하지 않기 때문입니다.

// x has not been declared before
if (typeof x === 'undefined') { // evaluates to true without errors
   // these statements execute
}

if (x === undefined) { // throws a ReferenceError

}

그러나 이런 종류의 기술은 피해야합니다. JavaScript는 정적으로 범위가 지정된 언어이므로 변수가 선언되어 있는지 알면 둘러싼 컨텍스트에서 선언되어 있는지 확인할 수 있습니다. 유일한 예외는 전역 범위이지만 전역 범위는 전역 객체에 바인딩되므로 전역 컨텍스트에서 변수의 존재를 확인하려면 전역 객체의 속성 존재 여부를 확인하여 수행 할 수 있습니다 (in 연산자, 예를 들어).

무효 연산자 및 정의되지 않음

void 연산자는 세 번째 대안입니다.

var x;
if (x === void 0) {
   // these statements execute
}

// y has not been declared before
if (y === void 0) {
   // throws a ReferenceError (in contrast to `typeof`)
}

더> 여기

' if (window.x) {} '는 오류 안전

아마 당신이 원할 것 if (window.x)입니다. 이 검사는 x가 선언되지 않은 경우에도 안전합니다 ( var x;). 브라우저에서 오류가 발생하지 않습니다.

예 : 브라우저가 History API를 지원하는지 알고 싶습니다

if (window.history) {
    history.call_some_function();
}

작동 원리 :

window 는 모든 전역 변수를 멤버로 보유하는 객체이며 존재하지 않는 멤버에 액세스하는 것은 합법적입니다. 경우 x는 다음 선언되지 않았거나 설정되지 않은 window.x반환 정의되지 않은 . undefined 는 if ()가 평가할 때 false 가 됩니다 .

이것을 통해, 나는 이것을 보지 못해서 놀랐습니다. 나는 이것을 위해 작동하는 여러 알고리즘을 발견했다.

절대 정의되지 않음

객체의 값이 정의되지 않은 true경우 null또는 로 정의 된 경우 반환 되지 않습니다 undefined. 이것은 다음과 같이 설정된 값에 대해 true를 반환하려는 경우에 유용합니다undefined

if(obj.prop === void 0) console.log("The value has never been defined");

정의되지 않은 또는 정의되지 않은 것으로 정의

true값으로 정의 undefined되거나 절대 정의되지 않은 값에 대해 결과를 얻으려면 간단히 사용할 수 있습니다.=== undefined

if(obj.prop === undefined) console.log("The value is defined as undefined, or never defined");

허위 값, 정의되지 않음, 널 또는 절대 정의되지 않음으로 정의됩니다.

일반적으로 사람들은 값이 거짓 undefined인지 또는 인지 아닌지를 알아내는 알고리즘을 요구했습니다 null. 다음과 같이 작동합니다.

if(obj.prop == false || obj.prop === null || obj.prop === undefined) {
    console.log("The value is falsy, null, or undefined");
}

"propertyName" in obj //-> true | false

void 0간결함을 위해 와 비교하십시오 .

if (foo !== void 0)

그것은 장황하지 않다 if (typeof foo !== 'undefined')

해결책이 잘못되었습니다. 자바 스크립트에서

null == undefined

둘 다 부울에 "캐스트되고"거짓이기 때문에 true를 리턴합니다. 올바른 방법은 확인하는 것입니다

if (something === undefined)

이것은 신원 연산자입니다 ...

다음 코드를 사용하여 경로로 정의되지 않은 배열을 모두 얻을 수 있습니다.

 function getAllUndefined(object) {

        function convertPath(arr, key) {
            var path = "";
            for (var i = 1; i < arr.length; i++) {

                path += arr[i] + "->";
            }
            path += key;
            return path;
        }


        var stack = [];
        var saveUndefined= [];
        function getUndefiend(obj, key) {

            var t = typeof obj;
            switch (t) {
                case "object":
                    if (t === null) {
                        return false;
                    }
                    break;
                case "string":
                case "number":
                case "boolean":
                case "null":
                    return false;
                default:
                    return true;
            }
            stack.push(key);
            for (k in obj) {
                if (obj.hasOwnProperty(k)) {
                    v = getUndefiend(obj[k], k);
                    if (v) {
                        saveUndefined.push(convertPath(stack, k));
                    }
                }
            }
            stack.pop();

        }

        getUndefiend({
            "": object
        }, "");
        return saveUndefined;
    }

jsFiddle 링크

내 상황은 다음과 같습니다.

REST 호출 결과를 사용하고 있습니다. 결과는 JSON에서 JavaScript 객체로 구문 분석해야합니다.

방어해야 할 오류가 하나 있습니다. 사용자가 인수를 잘못 지정하는 한 나머지 통화에 대한 인수가 올바르지 않은 경우 나머지 통화는 기본적으로 비어 있습니다.

이 게시물을 사용하여 이것을 방어하는 데 도움을 주면서 시도했습니다.

if( typeof restResult.data[0] === "undefined" ) { throw  "Some error"; }

내 상황에서 restResult.data [0] === "object"이면 나머지 멤버를 안전하게 검사 할 수 있습니다. 정의되지 않은 경우 위와 같이 오류를 발생시킵니다.

내가 말하는 것은 내 상황에 따라이 게시물의 위의 모든 제안이 효과가 없다는 것입니다. 나는 내가 옳다고 말하지 않고 모두가 틀렸다. 나는 전혀 JavaScript 마스터가 아니지만 희망적으로 이것이 누군가를 도울 것입니다.

정의 된 속성이 정의 된 경우 정의 된 속성을 새 변수에 할당하거나 정의되지 않은 경우 대체 값으로 기본값을 할당하는 좋은 방법이 있습니다.

var a = obj.prop || defaultValue;

추가 구성 속성을받는 함수가있는 경우 적합합니다.

var yourFunction = function(config){

   this.config = config || {};
   this.yourConfigValue = config.yourConfigValue || 1;
   console.log(this.yourConfigValue);

}

지금 실행 중

yourFunction({yourConfigValue:2});
//=> 2

yourFunction();
//=> 1

yourFunction({otherProperty:5});
//=> 1

모든 답변이 불완전합니다. 이것은 '정의되지 않은 것으로 정의 된'속성이 있음을 아는 올바른 방법입니다.

var hasUndefinedProperty = function hasUndefinedProperty(obj, prop){
  return ((prop in obj) && (typeof obj[prop] == 'undefined')) ;
} ;

예:

var a = { b : 1, e : null } ;
a.c = a.d ;

hasUndefinedProperty(a, 'b') ; // false : b is defined as 1
hasUndefinedProperty(a, 'c') ; // true : c is defined as undefined
hasUndefinedProperty(a, 'd') ; // false : d is undefined
hasUndefinedProperty(a, 'e') ; // false : e is defined as null

// And now...
delete a.c ;
hasUndefinedProperty(a, 'c') ; // false : c is undefined

이것이 정답 인 것이 잘못되어 잘못된 답변에 묻혔습니다.> _ <

그래서, 지나가는 사람을 위해 나는 당신에게 undefineds를 무료로 줄 것입니다!

var undefined ; undefined ; // undefined
({}).a ;                    // undefined
[].a ;                      // undefined
''.a ;                      // undefined
(function(){}()) ;          // undefined
void(0) ;                   // undefined
eval() ;                    // undefined
1..a ;                      // undefined
/a/.a ;                     // undefined
(true).a ;                  // undefined

주석을 살펴보면 둘 다 확인하려는 사람들이 정의되지 않았거나 값이 null인지 확인하십시오.

//Just in JavaScript
var s; // Undefined
if (typeof s == "undefined" || s === null){
    alert('either it is undefined or value is null')
}

jQuery Library를 사용 jQuery.isEmptyObject()하는 경우 두 경우 모두 충분합니다.

var s; // Undefined
jQuery.isEmptyObject(s); // Will return true;

s = null; // Defined as null
jQuery.isEmptyObject(s); // Will return true;

//Usage
if (jQuery.isEmptyObject(s)) {
    alert('Either variable:s is undefined or its value is null');
} else {
     alert('variable:s has value ' + s);
}

s = 'something'; // Defined with some value
jQuery.isEmptyObject(s); // Will return false;

Angular를 사용하는 경우 :

angular.isUndefined(obj)
angular.isUndefined(obj.prop)

Underscore.js :

_.isUndefined(obj) 
_.isUndefined(obj.prop) 

if (this.variable)정의되어 있는지 테스트하는 데 사용 합니다. 간단한은 if (variable), 위의 추천 , 나를 위해 실패합니다. 변수가 일부 객체의 필드 일 때만 작동 obj.someField하여 사전에 정의되어 있는지 확인합니다. 그러나 변수는 현재 창의 필드이므로 이해할 수 있듯이 this또는 window사전 개체로 사용할 수 있습니다 . 따라서 여기에 테스트가 있습니다

if (this.abc) alert("defined"); else alert("undefined");

abc = "abc";
if (this.abc) alert("defined"); else alert("undefined");

먼저 변수 abc가 정의되지 않았 음을 감지하고 초기화 후에 정의됩니다.

나는 이상한 답변을 기대하는 사람들을 위해 여기에 세 가지 방법을 제공합니다.

function isUndefined1(val) {
    try {
        val.a;
    } catch (e) {
        return /undefined/.test(e.message);
    }
    return false;
}
function isUndefined2(val) {
    return !val && val+'' === 'undefined';
}
function isUndefined3(val) {
    const defaultVal={};
    return ((input=defaultVal)=>input===defaultVal)(val);
}
function test(func){
    console.group(`test start :`+func.name);
    console.log(func(undefined));
    console.log(func(null));
    console.log(func(1));
    console.log(func("1"));
    console.log(func(0));
    console.log(func({}));
    console.log(func(function () { }));
    console.groupEnd();
}
test(isUndefined1);
test(isUndefined2);
test(isUndefined3);

isUndefined1 :

입력 값의 속성을 얻으려고 시도하고 오류 메시지가 있는지 확인하십시오. 입력 값이 정의되지 않은 경우 오류 메시지는 Uncaught TypeError : undefined의 'b'속성을 읽을 수 없습니다

isUndefined2 :

입력 값을 문자열로 변환하여 비교하고 "undefined"음수 값인지 확인하십시오.

isUndefined3 :

js에서는 입력 값이 정확히 일 때 선택적 매개 변수가 작동합니다 undefined.

function isUnset(inp) {
  return (typeof inp === 'undefined')
}

변수가 설정되어 있으면 false를, 정의되지 않으면 true를 반환합니다.

그런 다음 사용하십시오.

if (isUnset(var)) {
  // initialize variable here
}

undefined변수 를 보호하기 위해 사용중인 것을 보여주고 싶습니다 .

Object.defineProperty(window, 'undefined', {});

이것은 누군가가 window.undefined값 을 변경하는 것을 금지 하므로 해당 변수를 기반으로 코드를 파괴합니다. 을 사용하면 "use strict"값을 변경하려고 시도하면 오류가 발생하고 그렇지 않으면 자동으로 무시됩니다.

당신은 또한 프록시를 사용할 수 있습니다, 그것은 중첩 된 호출과 함께 작동하지만 하나의 추가 검사가 필요합니다 :

function resolveUnknownProps(obj, resolveKey) {
  const handler = {
    get(target, key) {
      if (
        target[key] !== null &&
        typeof target[key] === 'object'
      ) {
        return resolveUnknownProps(target[key], resolveKey);
      } else if (!target[key]) {
        return resolveUnknownProps({ [resolveKey]: true }, resolveKey);
      }

      return target[key];
    },
  };

  return new Proxy(obj, handler);
}

const user = {}

console.log(resolveUnknownProps(user, 'isUndefined').personalInfo.name.something.else); // { isUndefined: true }

그래서 당신은 그것을 다음과 같이 사용할 것입니다 :

const { isUndefined } = resolveUnknownProps(user, 'isUndefined').personalInfo.name.something.else;
if (!isUndefined) {
  // do someting
}

lodash.js에서.

var undefined;
function isUndefined(value) {
  return value === undefined;
}

undefined기본값으로 초기화 된 LOCAL 변수를 작성합니다 . 실수 는 변수와 undefined비교 value됩니다 undefined.

2019 년 9 월 9 일 업데이트

lodash가 구현을 업데이트 한 것을 발견했습니다. 내 문제 와 코드를 참조하십시오 .

방탄하려면 간단히 다음을 사용하십시오.

function isUndefined(value) {
  return value === void 0;
}