未定義のオブジェクトプロパティの検出

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') {
    ⋮
}

は 常に完全に同等 これに¶:

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

を使用する理由について読者を混乱させないように、上記のアドバイスを考慮してください。 typeof, を使用するのが最も合理的であるため、 === 等しいかどうかをチェックするためです。後で変数の値をチェックするようにリファクタリングでき、見た目がより良くなるからです。 常に使用する必要があります === undefined¶ここでも.

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

¹ 変数名の例の選択が異常ですか?これは、Firefox の NoScript 拡張機能の実際のデッド コードです。
² ただし、一般的には、範囲内に何が含まれるか分からなくても問題ないとは考えないでください。ダイナミック スコープの悪用によって引き起こされる追加の脆弱性: プロジェクトゼロ1225
³ もう一度 ES5+ 環境を想定します。 undefined を参照 undefined グローバルオブジェクトのプロパティ。代わりの void 0 さもないと。

JavaScriptには、 ヌル そこには 未定義. 。それらにはさまざまな意味があります。

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

マリジン・ハフェルベケ氏は、無料のオンライン書籍で次のように述べています。雄弁な JavaScript" (私の言葉を強調):

同様の値 null もあり、これは「この値は定義されていますが、値を持ちません」という意味です。未定義と null の意味の違いは主に学術的なものであり、通常はあまり興味深いものではありません。 実際のプログラムでは、何かに「値がある」かどうかを確認する必要があることがよくあります。このような場合、正確に同じ値ではない場合でも、null == unknown は true を生成するため、something == unknown という式が使用されることがあります。

したがって、何かが未定義であるかどうかを確認する最良の方法は次のとおりだと思います。

if (something == undefined)

お役に立てれば！

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

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

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

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

実際には、これは 2 つのまったく異なる意味を持ちます。まず、それが意味するのは、 一度も定義されていないプロパティ オブジェクトの中で、そして第二に、それは、 未定義の値を持つプロパティ. 。このコードを見てみましょう:

var o = { a: undefined }

は o.a 未定義？はい！その値は未定義です。は o.b 未定義？もちろん！プロパティ「b」がまったくありません。OK、両方の状況でさまざまなアプローチがどのように動作するかを見てみましょう。

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) プロパティが 1 番目または 2 番目の意味で未定義かどうかを知りたいとします (最も典型的な状況)。

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 の他の実装については知りません。

この問題は、次の 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")

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

使用の起源がどこにあるのかはわかりません === と 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';

グローバル変数 マイバール と同じです window.myvar または ウィンドウ['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 の場合、インタプリタは次のテストをスキップします。

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

(y)

物件の前で物体をチェックしている人は見かけませんでした（見落とさなかったらいいのですが）。したがって、これは最も短く、最も効果的です (ただし、必ずしも最も明確であるとは限りません)。

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

obj または obj.prop が未定義、null、または「falsy」の場合、if ステートメントはコード ブロックを実行しません。これは いつもの ほとんどのコード ブロック ステートメント (JavaScript の場合) で望ましい動作を実現します。

記事の中で JavaScript における Null と Unknown の深淵を探索する 次のようなフレームワークがあると読みました アンダースコア.js この関数を使用します。

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

'if (window.x) { }' はエラーセーフです

おそらくあなたが望んでいるでしょう if (window.x). 。このチェックは、x が宣言されていない場合でも安全です (var x;) - ブラウザはエラーをスローしません。

例：使用しているブラウザが History API をサポートしているかどうかを知りたい

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

これがどのように機能するか:

窓 は、すべてのグローバル変数をメンバーとして保持するオブジェクトであり、存在しないメンバーにアクセスしようとすることは合法です。もし バツ 宣言されていない、または設定されていません window.x 戻り値 未定義. 未定義 につながる 間違い いつ もし（） それを評価します。

"propertyName" in obj //-> true | 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、または未定義として定義されています。

よく、値が偽であるかどうかを判断するアルゴリズムを求められます。 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;
    }

jsフィドル リンク

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 コード内で繰り返し使用する場合は、私が共有する Angular サンプルのような関数を作成し、次の DRY コード パターンとして再利用し続けます。

もう 1 つ、実際のアプリケーションでオブジェクトが存在するかどうかさえわからないオブジェクトのプロパティを確認するには、まずオブジェクトが存在するかどうかを確認します。

オブジェクトのプロパティを確認し、そのオブジェクトが存在しない場合は、エラーがスローされ、アプリケーション全体の実行が停止します。

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、unknown、void(0) に関する有益な情報を入手した MDN からこのセクションも追加します。

厳密な等価性と未定義
未定義および厳格な平等および不平等演算子を使用して、変数に値があるかどうかを判断できます。次のコードでは、変数xは定義されておらず、IFステートメントはtrueに評価されます。

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

注記：x == undefinedはxがnullかどうかをチェックしますが、厳密な平等はそうではないため、標準の平等演算子ではなく厳密な平等演算子を使用する必要があります。ヌルは未定義に相当しません。詳細については、比較演算子を参照してください。

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 operator、in 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`)
}

もっと見る > ここ

と比べて void 0, 、簡潔にするために。

if (foo !== void 0)

それほど冗長ではありません if (typeof foo !== 'undefined')

解決策が間違っています。JavaScriptでは、

null == undefined

どちらもブール値に「キャスト」されており false であるため、true が返されます。正しい方法はチェックすることです

if (something === undefined)

これは恒等演算子です...

私の状況は次のとおりです。

REST呼び出しの結果を使用しています。結果は JSON から JavaScript オブジェクトに解析される必要があります。

擁護しなければならない間違いが 1 つあります。ユーザーが指定した引数が間違っていて、rest 呼び出しへの引数が間違っていた場合、rest 呼び出しは基本的に空に返されます。

この記事を参考にしながら、これを試してみました。

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ライブラリを使用している場合は、 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)

アンダースコア.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;
}

という名前の LOCAL 変数を作成します。 undefined これはデフォルト値、つまり実際の値で初期化されます。 undefined, 、比較します value 変数を使って undefined.

奇妙な答えを期待している人のために、ここで 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);

は未定義1:

入力値のプロパティを取得してみ、エラー メッセージが存在する場合はそれを確認してください。入力値が未定義の場合、エラー メッセージは次のようになります。 キャッチされないタイプエラー:未定義のプロパティ「b」を読み取れません

は未定義2:

入力値を文字列に変換して比較します "undefined" そしてそれが負の値であることを確認してください。

は未定義3:

js では、入力値が正確に一致する場合にオプションのパラメーターが機能します。 undefined.

ライセンス： CC-BY-SA と 帰属
所属していません StackOverflow
scroll top