정의되지 않은 객체 속성 감지

StackOverflow https://stackoverflow.com/questions/27509

  •  09-06-2019
  •  | 
  •  

문제

JavaScript의 객체 속성이 정의되지 않았는지 확인하는 가장 좋은 방법은 무엇입니까?

도움이 되었습니까?

해결책

사용:

if (typeof something === "undefined") {
    alert("something is undefined");
}

속성이있는 객체 변수의 경우 다음과 같은 것을 사용할 수 있습니다.

if (typeof my_obj.someproperties === "undefined"){
    console.log('the property is not available...'); // print into console
}

다른 팁

이 주제에 대한 여러 가지 잘못된 답변이 있다고 생각합니다. 일반적인 믿음과는 달리 "정의되지 않은"입니다 ~ 아니다 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 === undefined Myvar가 선언되지 않은 상황에서 오류가 발생합니다.

여기에서 다른 많은 답변에 의해 강력하게 추천 되었음에도 불구하고 typeof 나쁜 선택입니다. 변수가 값이 있는지 확인하는 데 사용해서는 안됩니다. undefined, 그것은 값에 대한 결합 된 점검 역할을하기 때문에 undefined 변수가 존재하는지 여부. 대부분의 경우 변수가 언제 존재하는지 알고 있으며 typeof 변수 이름 또는 문자열 리터럴에서 오타를 만들면 침묵 실패 가능성을 소개합니다. '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 덮어 쓸 수 있습니다. 이것에 더 많은 것이 있습니다. undefined JavaScript의 키워드가 아닙니다. 대신, 그것은 정의되지 않은 값을 가진 글로벌 객체의 속성입니다. 그러나 ES5 이후 로이 속성은있었습니다 읽기 전용 그리고 구성 불가능합니다. 최신 브라우저는 허용하지 않습니다 undefined 재산이 변경 될 것이며 2017 년 현재 오랫동안 발생했습니다. 엄격한 모드 부족은 영향을 미치지 않습니다 undefined의 행동 중 하나 - 그것은 단지 다음과 같은 진술을 만듭니다. undefined = 5 던지는 대신 아무것도하지 않습니다. 그러나 키워드가 아니므로 선언하다 이름이있는 변수 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 확장자의 실제 죽은 코드입니다.
² 그러나 범위에 무엇이 있는지 알지 못하는 것은 일반적으로 괜찮다고 가정하지 마십시오. 동적 범위의 남용으로 인한 보너스 취약성 : 프로젝트 제로 1225
³ 다시 한 번 ES5+ 환경을 가정하고 undefined 참조 undefined 글로벌 대상의 속성. 대리자 void 0 그렇지 않으면.

JavaScript에는 있습니다 없는 그리고 있습니다 찾으시는 주소가 없습니다. 그들은 다른 의미를 가지고 있습니다.

  • 찾으시는 주소가 없습니다 변수 값이 정의되지 않았 음을 의미합니다. 가치가 무엇인지 알 수 없습니다.
  • 없는 변수 값이 정의되어 널로 설정되었음을 의미합니다 (값이 없습니다).

Marijn Haverbeke는 그의 무료 온라인 책에서 "웅변 자바 스크립트"(강조 광산) :

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

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

if (something == undefined)

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

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

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

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

이것은 무엇을 의미 하는가: "정의되지 않은 개체 속성"?

실제로 그것은 두 가지 매우 다른 의미를 가질 수 있습니다!첫째, 다음을 의미할 수 있습니다. 정의된 적이 없는 속성 둘째, 이는 다음을 의미할 수 있습니다. 정의되지 않은 값을 갖는 속성.이 코드를 살펴보겠습니다.

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.a === undefined 아니면 이거 typeof x.a == 'undefined' 인상 ReferenceError: x is not defined x가 정의되지 않은 경우.
  • 변하기 쉬운 undefined 전역 변수입니다(따라서 실제로는 window.undefined 브라우저에서).ECMAScript 1st Edition부터 지원되었으며 ECMAScript 5부터 지원됩니다. 읽기 전용.따라서 최신 브라우저에서는 그럴 수 없습니다. true로 재정의됨 많은 저자들이 우리를 놀라게 하기를 좋아하지만 이는 여전히 오래된 브라우저에도 해당됩니다.

마지막 전투: obj.prop === undefined 대 typeof obj.prop == 'undefined'

장점 obj.prop === undefined:

  • 좀 더 짧고 좀 더 예뻐보이네요
  • 철자가 틀리면 JavaScript 엔진에서 오류가 발생합니다. undefined

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

  • undefined 이전 브라우저에서는 재정의될 수 있습니다.

장점 typeof obj.prop == 'undefined':

  • 정말 보편적입니다!그것은 새로운 브라우저와 오래된 브라우저에서 작동합니다.

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

  • 'undefned' (철자가 틀린) 여기에는 단지 문자열 상수가 있으므로 방금 했던 것처럼 철자가 틀린 경우 JavaScript 엔진이 도움을 줄 수 없습니다.

업데이트(서버측 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 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';

글로벌 변수 미바 와 같다 Window.myvar 또는 창 [ 'myvar'

글로벌 변수가있을 때 테스트 할 오류를 피하려면 다음을 더 잘 사용합니다.

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

변수가 실제로 존재하는 경우 문제는 중요하지 않으며 그 값이 잘못되었습니다. 그렇지 않으면 정의되지 않은 상태로 변수를 초기화하는 것이 어리 석고, 값을 사용하여 초기화하는 것이 좋습니다. 선언하는 모든 변수가 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');
}

첫 번째 및 간단한 조건이 사실이되면 해석자는 다음 테스트를 건너칩니다.

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

(와이)

나는 보지 못했다 (내가 그것을 놓치지 않았기를 바랍니다)는 속성 전에 물건을 확인하는 사람을 보지 못했습니다. 따라서 이것은 가장 짧고 가장 효과적입니다 (반드시 가장 명확하지는 않지만).

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

obj 또는 obj.prop이 정의되지 않은, null 또는 "falsy"인 경우 if 문은 코드 블록을 실행하지 않습니다. 이것은 대개 대부분의 코드 블록 문 (JavaScript)에서 원하는 동작.

기사에서 JavaScript에서 Null의 심연과 정의되지 않은 탐색 나는 그 프레임 워크와 같은 것을 읽었다 aUNDSCORE.JS 이 기능 사용 :

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

'if (window.x) {}'오류가 안전합니다

당신이 원하는 것 같습니다 if (window.x). 이 점검은 X가 선언되지 않은 경우에도 안전합니다 (var x;) - 브라우저는 오류를 던지지 않습니다.

예 : 내 브라우저가 히스토리 API를 지원하는지 알고 싶습니다.

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

이것이 작동하는 방법 :

창문 모든 글로벌 변수를 회원으로 보유하는 객체이며, 존재하지 않는 회원에게 액세스하는 것이 합법적입니다. 만약에 엑스 그때 선언되지 않았거나 설정되지 않았습니다 window.x 보고 찾으시는 주소가 없습니다. 찾으시는 주소가 없습니다 ~으로 이끌다 거짓 언제 만약() 그것을 평가합니다.

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

이것을 읽었을 때, 나는 이것을 보지 못한 것에 놀랐습니다. 나는 이것에 효과가있는 여러 알고리즘을 발견했다.

정의되지 않았습니다

객체의 값이 정의되지 않은 경우, 이렇게하면 돌아 오는 것이 방지됩니다. true 정의 된 경우 null 또는 undefined. 다음과 같이 설정된 값에 대해 진실을 반환하려는 경우 도움이됩니다. 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");
}

다음 코드를 사용하여 경로로 배열을 모두 얻을 수 있습니다.

 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 링크

단순히 모든 것은 JavaScript로 정의되지 않습니다 찾으시는 주소가 없습니다, 객체/배열 내부의 속성이든 간단한 변수 인 경우에도 중요하지 않습니다 ...

JavaScript가 있습니다 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 코드에서는 반복해서 사용하는 경우 공유하는 각도 샘플과 같은 기능을 만들고 건식 코드 패턴을 따라 계속 재사용하십시오.

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

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

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

따라서 간단하게 아래와 같이 if 문을 감싸 수 있습니다.

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

또한 각도 1.x에서 정의 된 것과 같습니다.

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

또한 밑줄과 같은 다른 JavaScript 프레임 워크에는 비슷한 정의 검사가 있지만 사용하는 것이 좋습니다. 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은 정의되지 않은 것과 동일하지 않습니다. 자세한 내용은 비교 연산자를 참조하십시오.

타입 연산자 및 정의되지 않은
또는 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 Operator, Operator, 사용)에 속성의 존재를 확인하여 수행 할 수 있습니다. 예를 들어).

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

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

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

더> 여기

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

if (foo !== void 0)

그것은 말이되지 않습니다 if (typeof foo !== 'undefined')

솔루션이 잘못되었습니다. JavaScript에서

null == undefined

둘 다 부울에게 "캐스트"되어 거짓이기 때문에 참으로 돌아올 것입니다. 올바른 방법은 확인하는 것입니다

if (something === undefined)

신분 운영자입니다 ...

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

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

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

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

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

내 상황에서는 vestresult.data [0] === "객체"가 있다면 나머지 멤버를 안전하게 검사 할 수 있습니다. 정의되지 않은 경우 위와 같이 오류를 던지십시오.

내가 말하는 것은 내 상황 에서이 게시물의 위의 모든 제안이 작동하지 않았다는 것입니다. 나는 내가 옳고 모두가 틀렸다고 말하지 않는다. 나는 자바 스크립트 마스터가 아니지만, 이것이 누군가를 도울 것입니다.

정의 된 경우 정의 된 속성을 새 변수에 할당하거나 정의되지 않은 경우 기본값을 폴백으로 할당하는 멋진 우아한 방법이 있습니다.

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

이것이 올바른 답변이되어서 너무 나쁘다> _

그래서 지나가는 사람이라면 누구나 당신에게 정의되지 않은 것을 무료로 줄 것입니다 !!

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 라이브러리를 사용하는 경우 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)

alterscore.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 isUnset(inp) {
  return (typeof inp === 'undefined')
}

변수가 설정된 경우 false를 반환하고 정의되지 않은 경우 true.

그런 다음 사용하십시오 :

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

또한 더 짧은 글을 쓸 수 있습니다.

if (!variable){
    //do it if variable is Undefined
}

또는 

if (variable){
    //do it if variable is Defined
}

보호하기 위해 내가 사용하는 것을 보여 드리고 싶습니다. undefined 변하기 쉬운:

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

이것은 누구나 변경하는 것을 금지합니다 window.undefined 따라서 해당 변수에 따라 코드를 파괴합니다. 사용하는 경우 "use strict", 값을 변경하려는 모든 것은 오류로 끝납니다. 그렇지 않으면 조용히 무시됩니다.

lodash.js에서.

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

이름이 지정된 로컬 변수를 만듭니다 undefined 기본값으로 초기화됩니다. undefined, 그런 다음 비교합니다 value 변수와 함께 undefined.

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

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 :

입력 값의 속성을 얻으려면 오류 메시지가 존재하는 경우 오류 메시지를 확인하십시오. 입력 값이 정의되지 않은 경우 오류 메시지는 다음과 같습니다. Uncught TypeError : 정의되지 않은 속성 'b'를 읽을 수 없습니다.

isundefined2 :

입력 값을 문자열로 변환하여 비교하십시오 "undefined" 그리고 그것이 음의 가치인지 확인하십시오.

isundefined3 :

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

라이센스 : CC-BY-SA ~와 함께 속성
제휴하지 않습니다 StackOverflow
scroll top