3091

JavaScript のオブジェクト プロパティが未定義かどうかを確認する最良の方法は何ですか?

4

50 に答える 50

2856

プロパティの値が特別な値であるかどうかを確認する通常の方法は次のundefinedとおりです。

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

オブジェクトに実際にそのようなプロパティがなく、undefinedアクセスしようとするとデフォルトで返されるかどうかを確認するには:

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

識別子に関連付けられた値が特別な値undefinedであるかどうか、またはその識別子が宣言されていないかどうかを確認するには:

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

注: この最後のメソッドは、宣言されていない識別子を初期エラーなしで参照する唯一の方法です。これは、値を持つこととは異なりますundefined。

ECMAScript 5 より前のバージョンの JavaScript では、グローバル オブジェクトの "undefined" という名前のプロパティが書き込み可能であったため、誤って再定義された場合、単純なチェックfoo === undefinedが予期しない動作をする可能性がありました。最新の JavaScript では、プロパティは読み取り専用です。

ただし、最新の JavaScript では、「未定義」はキーワードではないため、関数内の変数に「未定義」という名前を付けて、グローバル プロパティをシャドウすることができます。

この (ありそうもない) エッジ ケースが心配な場合は、void 演算子を使用して特別なundefined値自体を取得できます。

if(myVariable === void 0) {
  alert("myVariable is the special value `undefined`");
}
于 2009-01-06T12:27:41.587 に答える
959

このトピックには多くの間違った答えがあると思います。一般に信じられていることとは反対に、「未定義」は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 が宣言されていない状況ではエラーが発生します。

于 2010-08-23T18:03:18.073 に答える
170

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
于 2008-08-26T07:36:13.453 に答える
131

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

実際には、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 が定義されていない場合、 thisx.a === undefinedまたは thistypeof 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 はグローバル変数undefinedas をサポートしていますglobal.undefined('global' プレフィックスなしで使用することもできます)。サーバーサイド JavaScript の他の実装については知りません。

于 2013-08-08T20:28:22.353 に答える
73

問題は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); }

しかし、すでに述べたように、これらは完全に同じではありません（ただし、私のニーズには十分すぎるほどです）。

于 2011-06-08T04:04:49.370 に答える
47 
if ( typeof( something ) == "undefined")

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

于 2010-07-27T16:03:52.583 に答える
44

===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
于 2010-09-22T14:20:18.533 に答える
26

関連する質問からの回答のクロスポストJavaScript で「未定義」を確認するにはどうすればよいですか? .

この質問に固有のものについては、テスト ケースを参照してくださいsomeObject.<whatever>。

さまざまな回答の結果を示すいくつかのシナリオ: http://jsfiddle.net/drzaus/UVjM4/

( varfor intests の使用は、スコープ指定されたラッパーで違いを生むことに注意してください)

参照用のコード:

(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
于 2013-01-13T17:43:07.540 に答える
21

もしあなたがそうするなら

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

変数が本当に存在するかどうかは問題ではありません。その値は正しくありません。そうでなければ、未定義で変数を初期化するのはばかげているので、値 false を使用して初期化することをお勧めします。!window.myvar宣言するすべての変数が false で初期化されていることがわかっている場合は、単純にその型を確認するか、適切な/有効な値があるかどうかを確認するために頼ることができます。したがって、変数が定義されていない場合でも、またはまたは!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)

于 2011-08-12T14:40:24.000 に答える
15

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

function isUndefined(obj){
    return obj === void 0;
}
于 2013-12-19T10:44:47.303 に答える
15

JavaScript で定義されていないものはundefinedであり、オブジェクト/配列内のプロパティであるか、単純な変数であるかは問題ではありません...

JavaScript にはtypeof、未定義の変数を非常に簡単に検出できる機能があります。

typeof whatever === 'undefined'ブール値を返すかどうかを確認するだけです。

これが、AngularJs v.1x の有名な関数のisUndefined()書き方です。

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 からこのセクションを追加します。

厳密な等値と未
定義 undefined と厳密な等値および不等値演算子を使用して、変数に値があるかどうかを判断できます。次のコードでは、変数 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 を使用する理由の 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`)
}

もっと >ここに

于 2017-05-24T14:15:55.670 に答える
13

これを読んで、私はこれを見ていないことに驚いています。これに適したアルゴリズムを複数見つけました。

未定義

オブジェクトの値が一度も定義されていない場合、またはtrueとして定義されている場合、これは戻ることを防ぎます。これは、次のように設定された値に対して true を返したい場合に役立ちます。nullundefinedundefined

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");
}
于 2015-02-15T03:10:11.330 に答える
13

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

const userPhone = user?.contactDetails?.phone;

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

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

于 2019-09-27T06:56:09.697 に答える
12

解決策が正しくありません。JavaScript では、

null == undefined

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

if (something === undefined)

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

于 2008-08-26T12:38:22.120 に答える
12 
"propertyName" in obj //-> true | false
于 2014-05-05T00:13:09.987 に答える
10

次のコードを使用して、パスですべて未定義の配列を取得できます。

 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リンク

于 2011-10-17T11:22:52.710 に答える
9

新しい変数が定義されている場合は定義済みのプロパティを割り当て、未定義の場合はフォールバックとしてデフォルト値を割り当てるための洗練された方法があります。

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
于 2016-03-03T10:05:36.950 に答える
7

これが私の状況です：

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

弁護しなければならないエラーが 1 つあります。ユーザーが引数を間違って指定している限り、REST 呼び出しへの引数が正しくない場合、REST 呼び出しは基本的に空に戻ります。

これを防ぐためにこの投稿を使用している間、私はこれを試しました：

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

私の状況では、restResult.data[0] === "object" の場合、残りのメンバーの検査を安全に開始できます。未定義の場合は、上記のエラーをスローします。

私が言いたいのは、私の状況では、この投稿の以前の提案はすべてうまくいかなかったということです. 私が正しく、誰もが間違っていると言っているのではありません。私は JavaScript の達人ではありませんが、これが誰かの役に立てば幸いです。

于 2013-08-15T13:56:36.923 に答える
6

両方を確認したい人のために、コメントを調べて、それが未定義であるか、その値が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;
于 2014-07-08T08:19:07.007 に答える
6

とても簡単で簡単な方法があります。

オプションのチェーンを使用できます:

x = {prop:{name:"sajad"}}

console.log(x.prop?.name) // Output is: "sajad"
console.log(x.prop?.lastName) // Output is: undefined

また

if(x.prop?.lastName) // The result of this 'if' statement is false and is not throwing an error

関数や配列に対してもオプションのチェーンを使用できます。

2020 年半ばの時点で、これは普遍的に実装されていません。https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Optional_chainingでドキュメントを確認してください

于 2020-05-05T06:41:09.523 に答える
4 
function isUnset(inp) {
  return (typeof inp === 'undefined')
}

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

次に使用します。

if (isUnset(var)) {
  // initialize variable here
}
于 2010-07-12T20:54:23.913 に答える
4

lodash.js から。

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

これは、デフォルト値 (実数) で初期化された名前のローカル変数を作成し、変数と比較します。undefinedundefinedvalueundefined

2019 年 9 月 9 日更新

Lodash がその実装を更新したことがわかりました。私の問題とコードを参照してください。

防弾するには、単に次を使用します。

function isUndefined(value) {
  return value === void 0;
}
于 2016-01-14T05:43:53.703 に答える
4

プロキシを使用することもできます。ネストされた呼び出しでも機能しますが、追加のチェックが 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 something
}
于 2018-03-21T16:50:26.090 に答える
4

undefined変数を保護するために使用しているものをお見せしたいと思います。

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

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

于 2014-10-09T08:09:08.953 に答える
2

使用する：

プロパティが未定義かどうかを確認するには:

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

プロパティが未定義でないかどうかを確認するには:

if (typeof something !== "undefined") {
    alert("not undefined");
}
于 2015-08-14T11:34:02.417 に答える
2

また、同じことを短く書くことができます。

if (!variable){
    // Do it if the variable is undefined
}

また

if (variable){
    // Do it if the variable is defined
}
于 2014-06-16T12:15:57.733 に答える
0

これはおそらく、既存の property-name が明示的で意図された の値を持っているかどうかを判断する唯一の明示的な形式ですundefined。それにもかかわらず、これは JavaScript 型です。

"propertyName" in containerObject && ""+containerObject["propertyName"] == "undefined";
>> true \ false

この式はtrue、指定されたコンテキストのプロパティ名が (本当に) 存在し、その意図した値が明示的に である場合にのみ返されますundefined。

空または空の文字列ゼロ、null、空の配列などのような誤検知はありません。これはまさにそれを行います。つまり、プロパティ名が存在することを確認します (そうでない場合は誤検知になります)。その値が、undefinedたとえば文字列表現形式 (文字通り「未定義」) で未定義の JavaScript 型であるかどうかを明示的にチェックし==ます。===変換が可能です。そして、この式は両方、つまりすべての条件が満たされた場合にのみ true を返します。たとえば、プロパティ名が存在しない場合は、false が返されます。存在しないプロパティは未定義の値であっても値を持つことができないため、これが唯一の正しい戻り値です。

例：

containerObject = { propertyName: void "anything" }
>> Object { propertyName: undefined }

// Now the testing

"propertyName" in containerObject && ""+containerObject["propertyName"] == "undefined";
>> true

/* Which makes sure that nonexistent property will not return a false positive
 * unless it is previously defined  */

"foo" in containerObject && ""+containerObject["foo"] == "undefined";
>> false
于 2017-04-20T19:01:28.930 に答える
-2

Object.hasOwnProperty(o, 'propertyname');

ただし、これはプロトタイプ チェーンを参照しません。

于 2012-02-18T16:26:44.083 に答える
-21 
if (somevariable == undefined) {
  alert('the variable is not defined!');
}

次に示すように、関数にすることもできます。

function isset(varname){
  return(typeof(window[varname]) != 'undefined');
}
于 2008-08-26T07:27:57.327 に答える