変数が初期化されているかどうかを確認する方法はどちらが良い/正しいですか？（変数が何か（文字列、int、オブジェクト、関数など）を保持できると仮定）

if (elem) { // or !elem

または

if (typeof(elem) !== 'undefined') {

または

if (elem != null) {

あなたはtypeof演算子が欲しい。具体的には：

if (typeof variable !== 'undefined') {
    // the variable is defined
}

typeof変数が実際に定義されていない場合は、オペレータがチェックされます。

if (typeof variable === 'undefined') {
    // variable is undefined
}

このtypeof演算子は、他の演算子とは異なり、宣言されていない変数と共に使用してもReferenceError例外をスローしません。

ただし、typeof nullが返されることに注意してください"object"。変数をに初期化するミスを回避するように注意する必要がありますnull。安全のために、これを代わりに使用できます。

if (typeof variable === 'undefined' || variable === null) {
    // variable is undefined or null
}

===単純な等価の代わりに厳密な比較を使用する方法の詳細については、JavaScriptの比較で使用するべき等号演算子（== vs ===）を==参照してください
。

多くの場合、以下を使用します：

if (elem) { // or !elem

あなたのために仕事をします！...これは以下のケースをチェックします：

1. undefined：値が定義されておらず、undefined
2. null：nullの場合、たとえば、DOM要素が存在しない場合...
3. 空の文字列：''
4. 0：数値ゼロ
5. NaN：数値ではありません
6. 偽

したがって、すべてのケースをカバーしますが、カバーする必要がある奇妙なケースも常にあります。たとえば、このようなスペースのある文字列は、文字列内にスペース' 'があるため、JavaScriptで定義されます。 ...たとえば、この場合、次のように、trim（）を使用してもう1つのチェックを追加します。

if(elem) {

if(typeof elem === 'string' && elem.trim()) {
///

また、これらのチェックは値のみに対するものです。オブジェクトと配列はJavaScriptでは動作が異なるため、空の配列[]と空のオブジェクト{}は常にtrueです。

以下の画像を作成して、回答の簡単な概要を示します。

JavaScriptでは、変数を定義できますが、値を保持しているundefinedため、最も一般的な答えは技術的に正しくなく、代わりに以下を実行します。

if (typeof v === "undefined") {
   // no variable "v" is defined in the current scope
   // *or* some variable v exists and has been assigned the value undefined
} else {
   // some variable (global or local) "v" is defined in the current scope
   // *and* it contains a value other than undefined
}

それはあなたの目的には十分かもしれません。次のテストのセマンティクスは単純なので、コードの動作を正確に記述し、自分で理解することが容易になります（そのようなことに関心がある場合）。

if ("v" in window) {
   // global variable v is defined
} else {
   // global variable v is not defined
}

もちろん、これはブラウザで実行していることを前提としています（windowはグローバルオブジェクトの名前です）。しかし、このようなグローバルをいじくり回している場合は、おそらくブラウザーを使用していることになります。主観的に、使用することは、グローバルを参照するために'name' in window使用window.nameすることと文体的に一貫しています。変数としてでwindowはなくプロパティとしてグローバルにアクセスすると、コード内で参照する宣言されていない変数の数を最小限に抑えることができ（lintingのために）、ローカル変数によってグローバルがシャドウされる可能性を回避できます。また、グローバルが皮膚を這わせる場合、この比較的長いスティックでのみ、より快適に触れることができます。

ほとんどの場合、以下を使用します。

elem != null

シンプルとは異なりif (elem)、それは可能に0、false、NaNと''、しかし、拒否nullまたはundefined、それ良い、引数の存在のための一般的なテスト、またはオブジェクトのプロパティ作ります。

他のチェックも正しくないわけではなく、用途が異なるだけです。

• if (elem)次の場合に使用することができるelemオブジェクトであることが保証されている場合、またはfalse、0等が（それゆえに相当する「デフォルト」値であると考えられるundefined又はnull）。

• typeof elem == 'undefined'指定されたものnullが初期化されていない変数またはプロパティに対して明確な意味を持つ場合に使用できます。

  • これは、が宣言されていない場合にエラーをスローしない唯一のチェックです（つまり、ステートメントがない、のプロパティではない、または関数の引数ではない）。私の考えでは、タイプミスが気付かれずに滑ってしまうので、これはかなり危険です。これを回避するには、以下の方法を参照してください。elemvarwindow

また、以下に対する厳密な比較も役立ちますundefined。

if (elem === undefined) ...

ただし、グローバルundefinedは別の値でオーバーライドできるため、undefined現在のスコープで変数を宣言してから使用することをお勧めします。

var undefined; // really undefined
if (elem === undefined) ...

または：

(function (undefined) {
    if (elem === undefined) ...
})();

この方法の2番目の利点は、JS縮小機能がundefined変数を1文字に減らし、毎回数バイトを節約できることです。

かどうかを確認しますwindow。hasOwnProperty（" varname"）

膨大な数のtypeof答えの代替案。

グローバルvar varname = value;スコープのステートメントで宣言されたグローバル変数

windowオブジェクトのプロパティとしてアクセスできます。

このように、hasOwnProperty()メソッド

（継承ではなく）オブジェクトが指定されたプロパティを独自のプロパティとして持っているかどうかを示すブール値を返します

かどうかを判断するために使用できます

「varname」の a varはグローバルに宣言されています。つまり、のプロパティですwindow。

// Globally established, therefore, properties of window
var foo = "whatever", // string
    bar = false,      // bool
    baz;              // undefined
//  window.qux does not exist

console.log( [
    window.hasOwnProperty( "foo" ), // true
    window.hasOwnProperty( "bar" ), // true
    window.hasOwnProperty( "baz" ), // true
    window.hasOwnProperty( "qux" )  // false
] );

素晴らしいのhasOwnProperty()は、それを呼び出す際に、まだ宣言されていない可能性のある変数を使用しないことです。もちろん、これは最初から問題の半分です。

常に完璧または理想的なソリューションであるとは限りませんが、特定の状況では、それは単なる仕事です！

ノート

上記とはvar対照的に、を使用して変数を定義する場合、上記は当てはまりますlet。

ブロックスコープのローカル変数を宣言し、オプションで値に初期化します。

var変数をグローバルに、またはブロックのスコープに関係なく関数全体に対してローカルに定義するキーワードとは異なります。

プログラムおよび関数の最上位レベルではlet、とは異なりvar、グローバルオブジェクトにプロパティは作成されません。

完全を const期すために：定数は、定義により、実際には変数ではありません（ただし、内容は変更可能です）。より適切に：

var変数とは異なり、グローバル定数はウィンドウオブジェクトのプロパティにはなりません。定数の初期化子が必要です。つまり、その値は宣言されているのと同じステートメントで指定する必要があります。

定数の値は、再割り当てによって変更することはできません。また、再宣言することもできません。

const宣言は、値への読み取り専用の参照を作成します。それが保持する値が不変であることを意味するのではなく、変数識別子を再割り当てできないということだけです。

以来let、変数やconst定数が継承している任意のオブジェクトのプロパティことはありませんhasOwnProperty()方法を、彼らの存在を確認するために使用することはできません。

の可用性と使用についてhasOwnProperty()：

Objectの子孫であるすべてのオブジェクトがhasOwnProperty()メソッドを継承します。[...] in演算子とは異なり、このメソッドはオブジェクトのプロトタイプチェーンをチェックダウンしません。

変数が存在するかどうかを確認する方法

これは、変数が存在し、初期化されているかどうかをテストするための非常に優れたソリューションです。

var setOrNot = typeof variable !== typeof undefined;

特定の変数が初期化されていない場合にデフォルトを設定するために、3項演算子と組み合わせて使用​​するのが最も一般的です。

var dark = typeof darkColor !== typeof undefined ? darkColor : "black";

カプセル化の問題

残念ながら、チェックを関数に単純にカプセル化することはできません。

あなたはこのようなことをすることを考えるかもしれません：

function isset(variable) {
    return typeof variable !== typeof undefined;
}

ただし、これを呼び出すと、たとえば参照エラーが発生します。存在しない変数を関数に渡すことができないためisset(foo)、変数fooは定義されていません：

キャッチされていないReferenceError：fooが定義されていません

関数パラメーターが未定義かどうかのテスト

私たちの間にisset関数が変数が存在するかどうかをテスト（理由はhereaboveを説明するために）に使用することはできません、それは、関数のパラメータが未定義されているかどうかのテストに私たちを認めていません。

var a = '5';

var test = function(x, y) {
    console.log(isset(x));
    console.log(isset(y));
};

test(a);

// OUTPUT :
// ------------
// TRUE
// FALSE

の値yはfunction testに渡されませんが、関数では値として知られているissetため、このコンテキストでyは関数は完全に機能testしundefinedます。

簡単な割り当てと関連するチェックを実行するときに、これをチェックする別の簡単な方法があります。単に条件付き（三項）演算子を使用してください。

var values = typeof variable !== 'undefined' ? variable : '';

これは、参照変数のインスタンス割り当てを使用してグローバル変数を宣言するときにも役立ちます。

変数をチェックする場合は、undefinedまたはにしないでくださいnull。次に、以下のチェックを実行します。

変数が宣言されているときに、値を確認する場合、これはSimple：でも 実行されundefined、null一緒に実行および確認されます。

var values = variable ? variable : '';

変数が宣言されていない（未定義ではない）ことをテストする短い方法は

if (typeof variable === "undefined") {
  ...
}

（window変数を宣言していない）ブラウザーの外で実行されているスクリプトを検出するのに役立ちました。

変数が定義されていることだけを気にするか、意味のある値にしたいかによって異なります。

タイプが未定義であるかどうかをチェックすると、変数がまだ定義されているかどうかがチェックされます。

=== nullまたは!== null、変数の値が正確かどうかのみをチェックしますnull。

== null!= nullまたはは、値がundefinedまたはであるかどうかを確認しますnull。

if(value)変数があるかどうかを確認しますundefined、null、0、または空の文字列。

最高の答えは正解です。typeofを使用してください。

ただし、私が指摘したかったのは、JavaScript undefinedは（なんらかの理由で）変更可能であることです。したがってvarName !== undefined、他のライブラリが未定義に変更されている可能性があるため、単にチェックを行うだけでは、必ずしも期待どおりに戻らない可能性があります。いくつかの回答（@skaleeの回答など）は、を使用しない方がよいようで、typeof問題が発生する可能性があります。

これを処理する「古い」方法は、undefinedをvarとして宣言して、の潜在的なミュート/オーバーライドを相殺していましたundefined。ただし、他のコードからのtypeofオーバーライドを無視するため、最善の方法はまだ使用することundefinedです。特に、ページで他に何が実行されている可能性があるかを知っている野生で使用するコードを記述している場合は...

if (typeof console != "undefined") {    
   ...
}

以上

if ((typeof console == "object") && (typeof console.profile == "function")) {    
   console.profile(f.constructor);    
}

すべてのブラウザで動作します

議論に貢献するために、変数が文字列またはオブジェクトでなければならないことがわかっている場合、私は常に好むif (!variable)ので、その偽物かどうかを確認します。これにより、よりクリーンなコードを作成できるため、たとえば次のようになります。

if (typeof data !== "undefined" && typeof data.url === "undefined") {
    var message = 'Error receiving response';
    if (typeof data.error !== "undefined") {
        message = data.error;
    } else if (typeof data.message !== "undefined") {
        message = data.message;
    }
    alert(message); 
}

..次のように減らすことができます：

if (data && !data.url) {
  var message = data.error || data.message || 'Error receiving response';
  alert(message)
} 

未定義とnullを区別することは困難です。Nullは、変数に特定の値がないことを示す場合に変数に割り当てることができる値です。Undefined は、割り当てられていない変数のデフォルト値になる特別な値です。

var _undefined;
var _null = null;

alert(_undefined); 
alert(_null); 
alert(_undefined == _null);
alert(_undefined === _null);

NullはJavaScriptの値であり、typeof null戻り値"object"

したがって、null値を渡すと、受け入れられた回答は機能しません。null値を渡す場合は、null値のチェックを追加する必要があります。

if ((typeof variable !== "undefined") && (variable !== null))  
{
   // the variable is defined and not null
}

最も堅牢な「定義済み」チェックはtypeof

if (typeof elem === 'undefined')

定義済みの変数をチェックしてデフォルトを割り当てるだけの場合、1つのライナーを読みやすくするには、次のようにします。

elem = elem || defaultElem;

多くの場合、使用しても問題ありません。参照：JavaScriptでデフォルト値を設定する慣用的な方法

typeofキーワードを使用するこの1つのライナーもあります。

elem = (typeof elem === 'undefined') ? defaultElem : elem;

typeof演算子を使用できます。

例えば、

var dataSet;

alert("Variable dataSet is : " + typeof dataSet);

上記のコードスニペットは次のような出力を返します

変数dataSetは：undefinedです。

変数が宣言/設定されているかどうかを確認するために、私はこの汚いトリックを行いました。

でも、コードを関数に抽出する方法が見つかりませんeval。

"use strict";

// var someVar;

var declared;
try {
  someVar;
  declared = true;
} catch(e) {
  declared = false;
}

if (declared) {
  console.log("someVar is declared; now has the value: " + someVar);
} else {
  console.log("someVar is not declared");
}

これらの回答（フレッドガントソリューションを除く）はすべて正しくないか不完全です。

値variableName;を運ぶ必要があるため、undefined値がvar variableName;すでに初期化されているという意味で宣言されているとします。-すでに宣言されているかどうかを確認するにはどうすればよいですか？

またはさらに良い-「Book1.chapter22.paragraph37」が単一の呼び出しで存在するかどうかをすぐに確認する方法はありますが、参照エラーは発生しませんか？

それには、最も強力なJasvaScript演算子であるin演算子を使用します。

"[variable||property]" in [context||root] 
>> true||false

AJAXの人気がピークに達したとき、私は（後で名前が付けられた）isNS（）メソッドを記述しました。

しかし、以前に公開されており、非常に重要なため、別のスレッドで公開するに値するので、ここでは投稿しませんが、ソースコードを見つけるのに役立つキーワード（javascript + isNS）を提供します。必要な説明。

質問で概説されている特定の状況では、

typeof window.console === "undefined"

と同じです

window.console === undefined

後者の方が短いので、後者を好みます。

consoleグローバルスコープ（windowすべてのブラウザーのオブジェクト）でのみ検索することに注意してください。この特定の状況では、それが望ましいです。欲しくないconsole他の場所で定義し。

@BrianKelleyは、彼のすばらしい答えの中で、技術的な詳細を説明しています。足りない結論を追加し、読みやすいものにまとめました。

オブジェクトに応じて2つの異なる方法を使用します。

if( !variable ){
  // variable is either
  // 1. '';
  // 2. 0;
  // 3. undefined;
  // 4. null;
  // 5. false;
}

空の文字列を偽として評価したくない場合があるので、このケースを使用します

function invalid( item ){
  return (item === undefined || item === null);
}

if( invalid( variable )){
  // only here if null or undefined;
}

反対が必要な場合は、最初のインスタンスでは！variableが!! variableになり、無効な関数では===が！=になり、関数名がnotInvalidに変わります。

私の好みはtypeof(elem) != 'undefined' && elem != null。

どのように選択しても、そのような関数にチェックを入れることを検討してください

function existy (x) {
    return typeof (x) != 'undefined' && x != null;
}

変数が宣言されていることがわからない場合は、続行します typeof (x) != 'undefined' && x != null;

変数が宣言されているが存在しない可能性があることがわかっている場合は、

existy(elem) && doSomething(elem);

チェックしている変数は、ネストされたプロパティである場合があります。小道具を使うことができます|| {}問題のプロパティへの存在をチェックする行を下に行く：

var exists = ((((existy(myObj).prop1||{}).prop2||{}).prop3||{})[1]||{}).prop4;

各プロパティの後に（... '|| {}'）。nextPropを使用して、欠落しているプロパティがエラーをスローしないようにします。

または、次のような存在を使用できます existy(o) && existy(o.p) && existy(o.p.q) && doSomething(o.p.q)

状況によります。コードの外側でグローバルに定義されているかどうかわからないもの（おそらくjQueryなど）をチェックする場合は、次のようにします。

if (typeof(jQuery) != "undefined")

（そこでは完全に等しい必要はありません。typeofは常に文字列を返します。）ただし、渡された、または渡されなかった関数への引数がある場合、それらは常に定義されますが、省略された場合はnullになります。

function sayHello(name) {
    if (name) return "Hello, " + name;
    else return "Hello unknown person";
}
sayHello(); // => "Hello unknown person"

トライキャッチ

変数がまったく定義されていない場合は、次のようにtry-catchブロックを使用して、ブレークコードを実行せずにこれを確認できます（use strictモードする必要はありません）。

try{
  notDefinedVariable;
} catch(e) {
  console.log('detected: variable not exists');
}

console.log('but the code is still executed');

notDefinedVariable; // without try-catch wrapper code stops here

console.log('code execution stops. You will NOT see this message on console');

ボーナス：（他の回答を参照）（source）===よりも明確である理由==

if（a == b）

if（a === b）

これがまだ言及されていないことに驚いています...

ここにいくつかの追加のバリエーションがあります this['var_name']

このメソッドを使用する利点は、変数が定義される前に使用できることです。

if (this['elem']) {...}; // less safe than the res but works as long as you're note expecting a falsy value
if (this['elem'] !== undefined) {...}; // check if it's been declared
if (this['elem'] !== undefined && elem !== null) {...}; // check if it's not null, you can use just elem for the second part

// these will work even if you have an improper variable definition declared here
elem = null; // <-- no var here!! BAD!

次のようにtry ... catchブロックを使用できます。

var status = 'Variable exists'

try {
	myVar
} catch (ReferenceError) {
	status = 'Variable does not exist'
}

console.log(status)

欠点は、ReferenceErrorをスローするため、関数に配置できないことです。

function variableExists(x) {
  var status = true
  try {
	  x
  } catch (ReferenceError) {
	  status = false
  }
  
  return status
}

console.log(variableExists(x))