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では、「未定義」はキーワードではないため、関数内の変数に「未定義」という名前を付けて、グローバルプロパティを隠すことができます。

この（ありそうにない）エッジケースが心配な場合は、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、変数名や文字列リテラルにタイプミスをすると、暗黙の失敗が発生する可能性があります'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ここでもuseを使用する必要があります。

オブジェクトのプロパティに関して他に考慮すべきことは、本当にチェックしたいかどうかですundefined。特定のプロパティ名は、オブジェクトに存在しない（undefined読み取り時に値を生成する）か、オブジェクト自体にvalue undefinedと存在するか、オブジェクトのプロトタイプにvalue undefinedと存在するか、または値のないオブジェクトのいずれかに存在しundefinedます。'key' in objキーがオブジェクトのプロトタイプチェーンのどこかにあるかどうか、およびObject.prototype.hasOwnProperty.call(obj, 'key')オブジェクトに直接あるかどうかがわかります。ただし、プロトタイプや文字列キーマップとしてのオブジェクトの使用については、この回答では詳しく説明しません。これは、元の質問の考えられる解釈に関係なく、他の回答のすべての悪いアドバイスに対抗することを主な目的としているためです。よく読んでMDNのオブジェクトプロトタイプの詳細！

_{例の変数名の変わった選択？これは、FirefoxのNoScript拡張機能からの実際のデッドコードです。
²ただし、スコープ内にあるものを知らなくても大丈夫だとは限りません。動的スコープの乱用によって引き起こされるボーナスの脆弱性：Project Zero
1225³もう一度ES5 +環境を想定し、それundefinedはundefinedグローバルオブジェクトのプロパティを参照します。void 0それ以外の場合は置き換えます。}

JavaScriptにはnullとundefinedがあります。彼らは異なる意味を持っています。

• undefinedは、変数値が定義されていないことを意味します。値が何であるかは不明です。
• nullは、変数値が定義され、nullに設定されている（値がない）ことを意味します。

Marijn Haverbekeは、彼の無料のオンラインブック「Eloquent JavaScript」で私の次のように述べています。

同様の値nullもあり、その意味は「この値は定義されていますが、値がありません」です。undefinedとnullの意味の違いは、ほとんどが学術的なものであり、通常はあまり興味深くありません。実際のプログラムでは、何かが「価値がある」かどうかを確認する必要があることがよくあります。これらのケースでは、something == undefinedという式を使用できます。これは、それらがまったく同じ値でなくても、null == undefinedがtrueを生成するためです。

だから、私は何かが定義されていないかどうかを確認する最良の方法は次のようになると思います：

if (something == undefined)

お役に立てれば！

編集：編集に応じて、オブジェクトのプロパティは同じように機能するはずです。

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

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

これはどういう意味ですか：「未定義のオブジェクトプロパティ」？

実際には、2つのまったく異なることを意味します。1 つ目は、オブジェクトで定義されたことのないプロパティを意味し、2つ目は、値が未定義のプロパティを意味します。このコードを見てみましょう：

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）プロパティが最初の意味でも2番目の意味でも定義されていないかどうかを知りたい（最も一般的な状況）。

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

2）オブジェクトにプロパティがあり、その値を気にしないかどうかを知りたい場合。

'prop' in obj

ノート：

• オブジェクトとそのプロパティを同時に確認することはできません。たとえば、xが定義されていない場合、this x.a === undefinedまたはthis typeof x.a == 'undefined'が発生しReferenceError: x is not definedます。
• 変数undefinedはグローバル変数です（つまり、実際にはwindow.undefinedブラウザーにあります）。ECMAScript 1st Edition以降、ECMAScript 5以降は読み取り専用でサポートされています。したがって、最近のブラウザーでは、多くの作成者が私たちを怖がらせたいので、これをtrueに再定義することはできませんが、これは古いブラウザーにも当てはまります。

ファイナルファイト：obj.prop === undefinedvstypeof 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（「グローバル」接頭辞なしでも使用できます）。サーバーサイドJavaScriptの他の実装については知りません。

問題は、3つのケースに要約されます。

1. オブジェクトにはプロパティがあり、その値はではありませんundefined。
2. オブジェクトにはプロパティがあり、その値はundefinedです。
3. オブジェクトにはプロパティがありません。

これは私が重要だと思うことを教えてくれます：

未定義のメンバーと、未定義の値を持つ定義済みメンバーとの間には違いがあります。

しかし、残念typeof obj.fooながら、3つのケースのどれが発生したかはわかりません。ただし、これを組み合わせ"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

プロパティが存在するかどうかを確認する方が、定義されていないかどうかを確認するよりも意味がある（そして明確である）場合があり、この確認が異なる唯一のケースはケース2で、まれなケースです。未定義の値を持つオブジェクトの実際のエントリ。

例：オブジェクトに特定のプロパティがあるかどうかをチェックする一連のコードをリファクタリングしています。

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

未定義のチェックなしで書かれたとき、それはより明確でした。

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

しかし、すでに述べたように、これらはまったく同じではありません（ただし、私のニーズには十分満足できます）。

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

これは私にとってはうまくいきましたが、他の人はうまくいきませんでした。

===with の起源がどこ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/

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

myvarmyvarが定義されていないため、変数が存在しない場合は失敗します。そのため、スクリプトは壊れ、テストは効果がありません。

ウィンドウオブジェクトには関数の外部にグローバルスコープ（デフォルトオブジェクト）があるため、宣言はウィンドウオブジェクトに「アタッチ」されます。

例えば：

var myvar = 'test';

グローバル変数myvarはwindow.myvarまたはwindow ['myvar']と同じです

グローバル変数が存在するときにテストするエラーを回避するには、以下を使用することをお勧めします。

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

変数が実際に存在するかどうかは問題ではなく、その値は正しくありません。それ以外の場合、変数をundefinedで初期化するのはばかげています。値falseを使用して初期化することをお勧めします。宣言するすべての変数がfalseで初期化されていることがわかっている場合は、その型!window.myvarを確認するか、適切な値または有効な値があるかどうかを確認することができます。したがって、変数が定義されていない場合でも、or または!window.myvarは同じです。myvar = undefinedmyvar = falsemyvar = 0

特定の型が予想される場合は、変数の型をテストします。条件のテストをスピードアップするには、次のようにします。

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

最初の単純な条件が真の場合、インタープリターは次のテストをスキップします。

変数のインスタンス/オブジェクトを使用して、有効な値を取得したかどうかを確認することをお勧めします。それはより安定しており、プログラミングのより良い方法です。

（y）

プロパティの前にオブジェクトをチェックしている人を見かけませんでした（見逃してはいけません）。したがって、これは最も短く、最も効果的です（ただし、必ずしも最も明確ではありません）。

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

objまたはobj.propが未定義、null、または「偽」である場合、ifステートメントはコードブロックを実行しません。これは通常、ほとんどのコードブロックステートメント（JavaScript）で望ましい動作です。

記事「JavaScriptでNullと未定義の深淵を探索する」では、Underscore.jsのようなフレームワークがこの関数を使用することを読みました。

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

単に何かが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に、コードで単純に使用できますが、何度も使用している場合は、角度サンプルのような関数を作成し、共有して再利用します。次の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';}

また、アンダースコアのような他の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でないため、標準の等価演算子ではなく厳密な等価演算子を使用する必要があります。nullはundefinedと同等ではありません。詳細については、比較演算子を参照してください。

Typeof演算子と未定義
別の方法として、typeofを使用することもできます。

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

typeofを使用する1つの理由は、変数が宣言されていなくてもエラーをスローしないためです。

// 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演算子と未定義

void演算子は3番目の選択肢です。

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

偽の値として定義されている、未定義、null、または定義されていない。

一般的に、人々は、値がどちらかfalsyであれば把握するアルゴリズムのための私を求めている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')

ソリューションは正しくありません。JavaScriptでは、

null == undefined

どちらもブール値に「キャスト」され、falseであるため、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オブジェクトに解析されます。

私が守る必要のあるエラーが1つあります。引数を間違って指定している限り、残りの呼び出しに対する引数が正しくなかった場合、残りの呼び出しは基本的に空に戻ります。

この投稿を使用してこれを防ぐ手助けをしている間に、私はこれを試しました。

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

これが正解であることは残念ですが、間違った答えに埋もれています> _ <

だから、通り過ぎる人のために、私はあなたに無料で未定義を与えます！

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)で推奨されている Simple は私にとって失敗します。これは、変数が何らかのオブジェクトのフィールドである場合にのみ機能obj.someFieldし、辞書で定義されているかどうかを確認します。しかし、私が理解しているように、変数は現在のウィンドウのフィールドであるため、thisまたはwindowを辞書オブジェクトとして使用できます。したがって、ここにテストがあります

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

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

最初に変数abcが未定義であり、初期化後に定義されていることを検出します。

奇妙な答えを期待する人のために、ここで3つの方法を提供します。

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。

ES2019は新機能を導入しました- オプションの連鎖を使用して、オブジェクトが次のように定義されている場合にのみオブジェクトのプロパティを使用できます。

const userPhone = user?.contactDetails?.phone;

userおよびcontactDetailsが定義されている場合にのみ、phoneプロパティを参照します。

参照 https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Optional_chaining

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

変数が設定されている場合はfalseを返し、未定義の場合はtrueを返します。

次に使用します：

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

undefined変数を保護するために使用しているものを紹介します。

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

これは誰もがwindow.undefined値を変更することを禁止し、そのためその変数に基づくコードを破壊します。を使用している場合"use strict"、その値を変更しようとするとエラーで終了します。それ以外の場合は、黙って無視されます。

プロキシを使用することもできます。これはネストされた呼び出しで動作しますが、追加のチェックが1つ必要になります。

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
}