JavaScriptのnullとundefinedの違いは何ですか？

JavaScript nullとの違いは何ですか？undefined

JavaScriptではundefined、変数は宣言されていますが、次のような値はまだ割り当てられていません。

var TestVar;
alert(TestVar); //shows undefined
alert(typeof TestVar); //shows undefined

null割り当て値です。値なしの表現として変数に割り当てることができます。

var TestVar = null;
alert(TestVar); //shows null
alert(typeof TestVar); //shows object

前の例から、undefinedとnullが2つの異なる型であることは明らかです。undefinedは、それ自体nullがオブジェクト（未定義）である一方で、です。

null === undefined // false
null == undefined // true
null === null // true

そして

null = 'value' // ReferenceError
undefined = 'value' // 'value'

ここから選びました

未定義の値は、変数に値が割り当てられていないときに使用されるプリミティブ値です。

null値は、null、空、または存在しない参照を表すプリミティブ値です。

varを介して変数を宣言し、それに値を指定しない場合、値は未定義になります。単独で、この値をWScript.Echo（）またはalert（）にしようとした場合、何も表示されません。ただし、空白の文字列を追加すると、突然表示されます。

var s;
WScript.Echo(s);
WScript.Echo("" + s);

変数を宣言してnullに設定すると、「null」と「undefined」が出力されることを除いて、動作は同じです。これは確かに小さな違いです。

未定義の変数をnullと比較したり、その逆を行ったりすることもでき、条件はtrueになります。

undefined == null
null == undefined

ただし、これらは2つの異なるタイプと見なされます。undefinedはそれ自体がすべて型ですが、nullは特別なオブジェクト値と見なされます。これは、変数の一般的なタイプを表す文字列を返すtypeof（）を使用して確認できます。

var a;
WScript.Echo(typeof(a));
var b = null;
WScript.Echo(typeof(b));

上記のスクリプトを実行すると、次の出力が生成されます。

undefined
object

タイプが異なっていても、どちらか一方のメンバーにアクセスしようとすると、同じように動作します。たとえば、例外がスローされます。WSHを使用すると、恐ろしい「 'varname'がnullまたはオブジェクトではない」と表示されます。これは、運が良ければ（ただし、別の記事のトピックです）。

変数を未定義に明示的に設定できますが、お勧めしません。変数をnullに設定し、設定するのを忘れた場合は値を未定義のままにすることをお勧めします。同時に、常にすべての変数を設定することをお勧めします。JavaScriptには、Cスタイルの言語とは異なるスコープチェーンがあり、ベテランプログラマーでも簡単に混乱します。変数にnullを設定することは、それに基づくバグを防ぐための最良の方法です。

未定義のポップアップが表示される別の例は、削除演算子を使用する場合です。Cの世界の人たちは、これをオブジェクトを破壊すると誤って解釈するかもしれませんが、そうではありません。この操作では、配列から添え字を削除するか、オブジェクトからメンバーを削除します。配列の場合、長さに影響はありませんが、その添え字は未定義と見なされます。

var a = [ 'a', 'b', 'c' ];
delete a[1];
for (var i = 0; i < a.length; i++)
WScript.Echo((i+".) "+a[i]);

上記のスクリプトの結果は次のとおりです。

0.) a
1.) undefined
2.) c

また、存在しなかった添え字またはメンバーを読み取ると、undefinedが返されます。

nullとundefinedの違いは次のとおりです。JavaScriptは何もnullに設定しないため、通常はそれを行います。変数を未定義に設定することもできますが、Nullを使用することはできません。デバッグする場合、これは、nullに設定されたものはすべてJavaScriptでなく、自分で行うことを意味します。さらに、これらの2つの特別な値はほぼ同等です。

（キャラクター不足によるキャラクター追加なので投稿させて頂きます。）

nullは、値がないことを示す特別なキーワードです。

次のような値として考えてください。

• 「foo」は文字列です。
• trueはboolean、
• 1234は数値です。
• nullは未定義です。

undefinedプロパティは、変数にnullを含む値も割り当てられていないことを示します。お気に入り

var foo;

定義された空の変数はnullデータ型ですundefined

どちらも値のない変数の値を表している

AND nullは、値のない文字列を表しません-空の文字列-

お気に入り

var a = ''; 
console.log(typeof a); // string 
console.log(a == null); //false 
console.log(a == undefined); // false 

今なら

var a;
console.log(a == null); //true
console.log(a == undefined); //true 

だが

var a; 
console.log(a === null); //false 
console.log(a === undefined); // true

だから、それぞれに独自の使い方があります

undefinedを使用して、変数のデータ型を比較します

null変数の値を空にするために使用します

var a = 'javascript';
a = null ; // will change the type of variable "a" from string to object 

null：変数の値がない; undefined：変数自体がない;

..where variableは、値に関連付けられた記号名です。

JSは、新しく宣言された変数をnullで暗黙的に初期化するのに十分親切かもしれませんが、そうではありません。

以下をよくお読みください。JavaScriptでのnullとundefinedの違いに関するすべての疑問が取り除かれます。また、以下に示すユーティリティ関数を使用して、タイプを正確に決定することもできます。

JavaScriptでは、次のタイプの変数を使用できます。

1. 宣言されていない変数
2. 宣言されているが割り当てられていない変数
3. リテラル未定義で割り当てられた変数
4. リテラルnullで割り当てられた変数
5. 未定義またはnull以外で割り当てられた変数

以下では、これらの各ケースを1つずつ説明します

1. 宣言されていない変数：以下は、宣言されていない変数にも当てはまります。

   • 文字列'undefined'を返すtypeof（）でのみ確認できます
   • ==または===で、またはifまたは条件演算子でチェックできませんか？ （参照エラーをスロー）

2. 宣言されているが割り当てられていない変数

   • typeofは文字列'undefined'を返します
   • == nullでチェックするとtrueが返されます
   • == undefinedでチェックするとtrueが返されます
   • === nullでチェックするとfalseが返されます
   • === undefinedでチェックするとtrueが返されます
   • ifまたは条件付き演算子？falseを返します

3. リテラル undefinedで割り当てられた変数：これらの変数は、宣言されているが割り当てられていない変数と同様に扱われます。

4. リテラル nullで割り当てられた変数

   • typeofは文字列'object'を返します
   • == nullでチェックするとtrueが返されます
   • == undefinedでチェックするとtrueが返されます
   • === nullでチェックするとtrueが返されます
   • === undefinedでチェックするとfalseが返されます
   • ifまたは条件付き演算子？falseを返します

5. 未定義またはnull以外で割り当てられた変数

   • typeofは、次の文字列のいずれかを返します： 'string'、'number'、'boolean'、'function'、'object'、'symbol'

次に、変数の正しい型チェックのアルゴリズムを示します。

1. typeofを使用して、未定義 / 未割り当て / 未定義の割り当てを確認してください。文字列'undefined'が返された場合に返されます。
2. ===を使用してnullを確認します。true の場合は'null'を返します。
3. typeofを使用して実際のタイプを確認します。'object'と等しくない場合はタイプを返します
4. Object.prototype.toString.call（o）を呼び出して、実際のオブジェクトタイプを判別します。すべての組み込みのJavaScriptまたはDOMで定義されたオブジェクトのタイプ「[object ObjectType]」の文字列を返します。ユーザー定義オブジェクトの場合、'[object Object]'を返します

タイプを判別するために、次のユーティリティ関数を使用することもできます。現在、すべてのECMA 262 2017タイプをサポートしています。

function TypeOf(o,bReturnConstructor)
 {
   if(typeof o==='undefined') return 'undefined'
   if(o===null) return 'null'   
   if(typeof o!=='object') return typeof o

   var type=Object.prototype.toString.call(o)
  switch(type)
  {
     //Value types:4
     case '[object Number]': type='number';break;
     case '[object String]': type='string';break;
     case '[object Boolean]': type='boolean';break;
     case '[object Date]': type='date';break;


   //Error Types:7
     case '[object Error]': type='error';break;
     case '[object EvalError]': type='evalerror';break;
     case '[object RangeError]': type='rangeerror';break;
     case '[object ReferenceError]': type='referenceerror';break;
     case '[object SyntaxError]': type='syntaxerror';break;
     case '[object TypeError]': type='typeerror';break;
     case '[object URIError]': type='urierror';break;


    //Indexed Collection and Helper Types:13
     case '[object Array]': type='array';break;
     case '[object Int8Array]': type='int8array';break;
     case '[object Uint8Array]': type='uint8array';break;
     case '[object Uint8ClampedArray]': type='uint8clampedarray';break;
     case '[object Int16Array]': type='int16array';break;
     case '[object Uint16Array]': type='uint16array';break;
     case '[object Int32Array]': type='int32array';break;
     case '[object Uint32Array]': type='uint32array';break;
     case '[object Float32Array]': type='float32array';break;
     case '[object Float64Array]': type='float64array';break;
     case '[object ArrayBuffer]': type='arraybuffer';break;
     case '[object SharedArrayBuffer]': type='sharedarraybuffer';break;
     case '[object DataView]': type='dataview';break;

    //Keyed Collection Types:2
     case '[object Map]': type='map';break;
     case '[object WeakMap]': type='weakmap';break;

    //Set Types:2
     case '[object Set]': type='set';break;
     case '[object WeakSet]': type='weakset';break;

    //Operation Types
    case '[object RegExp]': type='regexp';break;
    case '[object Proxy]': type='proxy';break;
    case '[object Promise]': type='promise';break;

    case '[object Object]': type='object';
             if(bReturnConstructor && o.constructor) type=o.constructor.toString().match(/^function\s*([^\s(]+)/)[1];
         break;
    default:
        type=type.split(' ')[1]
        type=type.substr(0,type.length-1)   

   }
    return type 
}

undefinedは、システムレベルの、予期しない、またはエラーのような値の不在を表すと見なすことができ、nullは、プログラムレベル、通常、または予期される値の不在を表すと見なすことができます。

JavaScript経由：決定的なガイド

私が説明しようundefined、nullとUncaught ReferenceError。

1 - Uncaught ReferenceError：変数が宣言されていないこのvaraibleへの参照が存在しない、あなたのスクリプトで
2 - undefined：変数が宣言されていますが初期化されていない
3 - null：変数が宣言され、空の値であります

未定義は、変数が宣言されているが値がないことを意味します。

var var1;
alert(var1); //undefined
alert(typeof var1); //undefined

ヌルは割り当てです：

var var2= null;
alert(var2); //null
alert(typeof var2); //object

nullとundefinedは、2つの異なるオブジェクトタイプであり、以下に共通しています。

• どちらも、それぞれnullとundefinedの 1つの値しか保持できません。
• どちらにもプロパティまたはメソッドがなく、どちらかのプロパティを読み取ろうとすると、ランタイムエラーが発生します（他のすべてのオブジェクトでは、存在しないプロパティを読み取ろうとすると、値が未定義になります）。
• 値はnullと未定義のは、お互いにおよびによって何もないに等しいと考えられている==と!=オペレータ。

ただし、類似点はここで終わります。一応、キーワードnullとundefinedの実装方法には根本的な違いがあります。これは明らかではありませんが、次の例を検討してください。

var undefined = "foo";
WScript.Echo(undefined); // This will print: foo

undefined、NaNおよびInfinityは、事前に初期化された「スーパーグローバル」変数の名前です。これらは実行時に初期化され、同じ名前の通常のグローバル変数またはローカル変数でオーバーライドできます。

次に、同じことをnullで試してみましょう：

var null = "foo"; // This will cause a compile-time error
WScript.Echo(null);

おっとっと！null、true、およびfalseは予約済みキーワードです-コンパイラーはこれらを変数名またはプロパティ名として使用できません

もう1つの違いは、undefinedはプリミティブ型であり、nullはオブジェクト型（オブジェクト参照がないことを示す）です。以下を検討してください。

WScript.Echo(typeof false); // Will print: boolean
WScript.Echo(typeof 0); // Will print: number
WScript.Echo(typeof ""); // Will print: string
WScript.Echo(typeof {}); // Will print: object
WScript.Echo(typeof undefined); // Will print: undefined
WScript.Echo(typeof null); // (!!!) Will print: object

また、nullとundefinedが数値コンテキストで処理される方法にも重要な違いがあります。

var a; // declared but uninitialized variables hold the value undefined
WScript.Echo(a === undefined); // Prints: -1

var b = null; // the value null must be explicitly assigned 
WScript.Echo(b === null); // Prints: -1

WScript.Echo(a == b); // Prints: -1 (as expected)
WScript.Echo(a >= b); // Prints: 0 (WTF!?)

WScript.Echo(a >= a); // Prints: 0 (!!!???)
WScript.Echo(isNaN(a)); // Prints: -1 (a evaluates to NaN!)
WScript.Echo(1*a); // Prints: -1.#IND (in Echo output this means NaN)

WScript.Echo(b >= b); // Prints: -1 (as expected)
WScript.Echo(isNaN(b)); // Prints: 0 (b evaluates to a valid number)
WScript.Echo(1*b); // Prints: 0 (b evaluates to 0)

WScript.Echo(a >= 0 && a <= 0); // Prints: 0 (as expected)
WScript.Echo(a == 0); // Prints: 0 (as expected)
WScript.Echo(b >= 0 && b <= 0); // Prints: -1 (as expected)
WScript.Echo(b == 0); // Prints: 0 (!!!)

nullはなり0同様に-算術式または数値の比較に使用した場合はfalse、それは基本的に「ゼロ」のちょうど特別な種類です。一方、undefinedは真の「何もない」であり、数値コンテキストで使用しようとするとNaN（「数ではない」）になります。

その注意ヌルをし、未定義の特別な治療を受ける==と!=、オペレータが、あなたは本当の数値の平等をテストすることができますし、Bの式とを。(a >= b && a <= b)

tl; dr

nullオブジェクトであることがわかっている変数を設定するために使用します。

undefinedタイプが混在する変数を設定するために使用します。

これは、5つのプリミティブとオブジェクトタイプの両方の私の使用法であり、undefinedまたはの「使用例」の違いを説明していnullます。

ストリング

すべてのライフサイクルで変数が文字列のみであることがわかっている場合は、慣例により、次のように初期化できます""。

("") ? true : false; // false
typeof ""; // "string";
("Hello World") ? true : false; // true
typeof "Hello World"; // "string"

数

あなたは変数はすべてのライフサイクルは、慣例により、あなたが、それを初期化することができながら、唯一の数であることがわかっている場合0（またはNaN場合は0、使用状況における重要な値です）：

(0) ? true : false; // false
typeof 0; // "number";
(16) ? true : false; // true
typeof 16; // "number"

または

(NaN) ? true : false; // false
typeof NaN; // "number";
(16) ? true : false; // true
typeof 16; // "number"

ブール

変数がブール値のみであることがわかっている場合、すべてのライフサイクルで、慣例により、次のように初期化できますfalse。

(false) ? true : false; // false
typeof false; // "boolean";
(true) ? true : false; // true
typeof true; // "boolean"

オブジェクト

すべてのライフサイクルで変数がオブジェクトにすぎないことがわかっている場合は、慣例により、次のように初期化できますnull。

(null) ? true : false; // false
typeof null; // "object";
({}) ? true : false; // true
typeof {}; // "object"

注：Objectは常にであり、returnであるため、nullをオフにしてスマートに使用すると、オブジェクトの偽バージョンになります。つまり、Object型とnull型の両方に一貫した値を返します。truetypeof nullobjecttypeof myVarObject

すべて

変数に混合型（すべてのライフサイクル中の任意の型）があることがわかっている場合、慣例により、それをに初期化できますundefined。

null「値なし」を意味する特別な値です。'object'を返すnullため、特別なオブジェクトtypeof nullです。

一方、undefined変数が宣言されていないか、値が指定されていないことを意味します。

違いを理解する最良の方法は、最初にJavaScriptの内部動作を理解し、次の意味の違いを理解することです。

let supervisor = "None"
    // I have a supervisor named "None"

let supervisor = null
    // I do NOT have a supervisor. It is a FACT that I do not.

let supervisor = undefined
    // I may or may not have a supervisor. I either don't know
    // if I do or not, or I am choosing not to tell you. It is
    // irrelevant or none of your business.

そここれら3例の間の意味の違いがある、とJavaScriptは2つの異なる値と後の2つの場合を区別し、nullそしてundefined。これらの値を明示的に使用して、それらの意味を伝えることができます。

では、この哲学的根拠が原因で発生するJavaScript固有の問題にはどのようなものがあるでしょうか。

1. 初期化子なしで宣言された変数undefinedは、意図した値が何であるかについて何も言わなかったため、値を取得します。

   let supervisor;
   assert(supervisor === undefined);

2. 一度も設定されていないオブジェクトのプロパティは、undefinedだれもそのプロパティについて何も言わなかったため、と評価されます。

   const dog = { name: 'Sparky', age: 2 };
   assert(dog.breed === undefined);

3. nullそしてundefinedブレンダン・アイクがそう言ったので、お互いに「類似」しています。しかし、それらは互いに等しくはありません。

   assert(null == undefined);
   assert(null !== undefined);

4. nullそしてundefinedありがたいことに、異なるタイプを持っています。null型に属するNullとundefinedタイプしますUndefined。これは仕様にありますが、typeofここでは繰り返さない奇妙さのため、これを知ることは決してありません。

5. 関数undefinedが何を返したかについて何も知らないので、明示的なreturnステートメントなしで本体の終わりに達した関数は戻ります。

ちなみに、JavaScriptには「無」の形式が他にもあります（哲学を研究したのは良いことです...）。

• NaN
• 宣言されたことのない変数を使用し、 ReferenceError
• 一時的なデッドゾーンで、letまたはconst定義されたローカル変数を使用し、ReferenceError

• スパース配列の空のセル。はい、これらは未定義undefinedと比較さ===れていますが、そうではありません。

  $ node
  > const a = [1, undefined, 2]
  > const b = [1, , 2]
  > a
  [ 1, undefined, 2 ]
  > b
  [ 1, <1 empty item>, 2 ]

JavasSriptには、String、Number、Boolean、null、およびundefinedの5つのプリミティブデータ型があります。簡単な例で説明してみます

簡単な関数があるとしましょう

 function test(a) {

     if(a == null){
        alert("a is null");
     } else {
        alert("The value of a is " + a);
     }
  }

上記の関数でもif（a == null）はif（！a）と同じです

パラメータaを渡さずにこの関数を呼び出すと、

   test(); it will alert "a is null";
   test(4); it will alert "The value of a is " + 4;

また

var a;
alert(typeof a); 

これは未定義になります。変数を宣言しましたが、この変数に値を割り当てていません。でも書けば

var a = null;
alert(typeof a); will give alert as object

nullはオブジェクトです。「a」に値nullを割り当てた方法で

以下のためにundefinedタイプ、唯一つの値があります：undefined。

以下のためにnullタイプ、唯一つの値があります：null。

したがって、どちらの場合も、ラベルはそのタイプと値の両方です。

それらの違い。例えば：

• null 空の値です
• undefined 欠損値です

または：

• undefined まだ価値がありません
• null 価値があり、もうありません

実際にnullは、は識別子ではなく特別なキーワードであるため、割り当てる変数として扱うことはできません。

ただし、undefinedは識別子です。ただし、non-strictモードとstrictモードの両方で、名前がundefinedのローカル変数を作成できます。しかし、これはひどい考えです！

function foo() {
    undefined = 2; // bad idea!
}

foo();

function foo() {
    "use strict";
    undefined = 2; // TypeError!
}

foo();

JavaScriptで変数を宣言すると、変数に値が割り当てられますundefined。つまり、変数は変更されず、将来は任意の値を割り当てることができます。また、この変数が宣言時に保持する値がわからないことも意味します。

これで、変数を明示的に割り当てることができますnull。これは、変数に値がないことを意味します。例-一部の人々はミドルネームを持っていません。したがって、そのような場合は、値nullを人物オブジェクトのミドルネーム変数に割り当てる方が適切です。

ここで、誰かがあなたの人物オブジェクトのミドルネーム変数にアクセスしていて、それに値があると仮定しますundefined。開発者がこの変数を初期化するのを忘れているのか、それとも値がなかったのか、彼は知りませんでした。値がの場合null、ユーザーはミドルネームに値がなく、変更されていない変数ではないことを簡単に推測できます。

nullとundefinedはどちらも、値がないことを表すために使用されます。

var a = null;

aが初期化され、定義されます。

typeof(a)
//object

nullはJavaScriptのオブジェクトです

Object.prototype.toString.call(a) // [object Object]

var b;

bは未定義であり、初期化されていません

未定義のオブジェクトプロパティも未定義です。たとえば、「x」はオブジェクトcで定義されておらず、cxにアクセスしようとすると、未定義が返されます。

通常、未定義ではない変数にnullを割り当てます。

この主題に関するライアン・モーの徹底的な記事によると...

「一般的に、変数やプロパティに非値を割り当てたり、関数に渡したり、関数から返す必要がある場合、ほとんどの場合nullが最適なオプションです。簡単に言えば、JavaScriptは未定義を使用し、プログラマはnullを使用してください。」

ヌルと未定義の永遠の深淵を探索するを参照してください

JavaScriptでNullとundefinedの両方が値がないことを示しています。

var a = null; //variable assigned null value
var b;  // undefined

両方とも値がないために存在するという事実にも関わらず、：未定義は実際には変数が初期化されていないことを意味します。何も返さない関数と、値が指定されていない関数パラメーターの場合、未定義の値が返されます。厳密な等価演算子===を使用して、nullと未定義を区別します。

リファレンス：http : //www.thesstech.com/javascript/null-and-undefined

OK、我々は我々が聞いたときに混乱するnullとundefined、しかし、聞かせてのは、それが簡単で、彼らの両方がある起動falsyそれらの有意差のカップル作り、多くの点で類似したが、JavaScriptの奇妙な部分、例えば、typeof演算が nullある'object'一方、typeof演算が undefinedあります'undefined'。

typeof null; //"object"
typeof undefined; //"undefined";

しかし、==以下のようにそれらをチェックすると、それらは両方とも偽であることがわかります：

null==undefined; //true

またnull、オブジェクトプロパティまたはプリミティブにundefined割り当てることもできますが、何も割り当てないことで簡単に実現できます。

違いを一目でわかるようにすばやくイメージを作成します。

typeofがundefinedを返すので、undefinedは、nullが初期化子であるため、変数がオブジェクトを指し示さないことを示します（Javascriptの実質的にすべてがオブジェクトです）。

JavaScriptでは、すべての変数がキーと値のペアとして保存されます。各変数は、variable_name：variable_value / referenceとして保管されます。

undefinedは、変数にメモリ内のスペースが割り当てられているが、値が割り当てられていないことを意味します。ベストプラクティスとして、このタイプを割り当てとして使用しないでください。

その場合、コードの後の時点で変数に値がないようにしたい場合はどのように指示しますか？null型を使用することもでき ます。これは、値がないことと同じことを定義するために使用される型ですが、この場合は実際に値がメモリにあるため、undefinedとは異なります。その値はnullです

どちらも似ていますが、使用方法と意味が​​異なります。

Vanilla JavaScript（JS）をゼロから学習しようとしているときに、nullとの微妙な違いを追加したいと思いundefinedます。

• nullはJSの予約済みキーワードですが、は、undefined現在のランタイム環境のグローバルオブジェクトの変数です。

コードを書いている間、この差は、両方として識別ではありませんnullし、undefined常にJavaScriptステートメントのRHSに使用されています。しかし、それらを式のLHSで使用すると、この違いを簡単に観察できます。したがって、JSインタープリターは以下のコードをエラーとして解釈します。

var null = 'foo'

以下のエラーが発生します：

キャッチされないSyntaxError：予期しないトークンnull

以下のコードは正常に実行されますが、実際にはそうすることはお勧めしません。

var undefined = 'bar'

これundefinedは、グローバルオブジェクト（クライアント側のJSの場合はブラウザウィンドウオブジェクト）の変数であるため機能します。

違いundefinedとはnull最小限ですが、違いがあります。値がundefined初期化されていない変数。値がの値nullが明示的nullに指定された変数は、変数が明示的に値を持たないように設定されたことを意味します。比較して式を使用するundefinedと、それらは等しくなります。nullnull==undefined

基本的に、Undefinedは、nullが変数に値が割り当てられていないことを意味する（実際にはnull自体がオブジェクトである）かどうかをJavaScriptが実行時に作成するグローバル変数です。

例を見てみましょう：

        var x;  //we declared a variable x, but no value has been assigned to it.
        document.write(x) //let's print the variable x

未定義の場合、出力として取得されます。

さて、

        x=5;
        y=null;
        z=x+y;

出力として5が得られます。それが未定義とnullの主な違いです

ヌルこれは代入値であり、値を表すために変数と共に使用されます（オブジェクトです）。

未定義これは値が割り当てられていない変数であるため、JavaScriptはundefinedを割り当てます（データ型です）。

undeclared-変数がまったく作成されていない場合、その変数はundeclaredと呼ばれます。

これをチェックしてください。出力は千語の価値があります。

var b1 = document.getElementById("b1");

checkif("1, no argument"                        );
checkif("2, undefined explicitly",     undefined);
checkif("3, null explicitly",               null);
checkif("4, the 0",                            0);
checkif("5, empty string",                    '');
checkif("6, string",                    "string");
checkif("7, number",                      123456);

function checkif (a1, a2) {
	print("\ncheckif(), " + a1 + ":");
	if (a2 == undefined) {
		print("==undefined:    YES");
	} else {
		print("==undefined:    NO");
	}
	if (a2 === undefined) {
		print("===undefined:   YES");
	} else {
		print("===undefined:   NO");
	}
	if (a2 == null) {
		print("==null:         YES");
	} else {
		print("==null:         NO");
	}
	if (a2 === null) {
		print("===null:        YES");
	} else {
		print("===null:        NO");
	}
	if (a2 == '') {
		print("=='':           YES");
	} else {
		print("=='':           NO");
	}
	if (a2 === '') {
		print("==='':          YES");
	} else {
		print("==='':          NO");
	}
	if (isNaN(a2)) {
		print("isNaN():        YES");
	} else {
		print("isNaN():        NO");
	}
	if (a2) {
		print("if-?:           YES");
	} else {
		print("if-?:           NO");
	}
		print("typeof():       " + typeof(a2));
}

function print(v) {
	b1.innerHTML += v + "\n";
}

<!DOCTYPE html>
<html>
<body>
<pre id="b1"></pre>
</body>
</html>

以下も参照してください。

• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined
• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/NaN
• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/null
• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators

乾杯！

両方の特別な値は、空の状態を意味します。

主な違いは、undefinedはまだ初期化されていない変数の値を表し、nullはオブジェクトが意図的に存在しないことを表します。

変数番号は定義されていますが、初期値は割り当てられていません。

let number;
number; // => undefined

数値変数は未定義であり、初期化されていない変数を明確に示します

存在しないオブジェクトプロパティにアクセスすると、同じ初期化されていない概念が発生します。

const obj = { firstName: 'Dmitri' };
obj.lastName; // => undefined

lastNameプロパティはobjに存在しないため、JavaScriptはobj.lastNameを未定義に正しく評価します。

他の場合では、変数がオブジェクトまたはオブジェクトを返す関数を保持することを期待していることを知っています。しかし、何らかの理由で、オブジェクトをインスタンス化することはできません。このような場合、nullは欠落しているオブジェクトの意味のあるインジケーターです。

たとえば、clone（）はプレーンなJavaScriptオブジェクトを複製する関数です。関数はオブジェクトを返すことが期待されています：

function clone(obj) {
  if (typeof obj === 'object' && obj !== null) {
    return Object.assign({}, obj);
  }
  return null;
}
clone({name: 'John'}); // => {name: 'John'}
clone(15);             // => null
clone(null);           // => null

ただし、clone（）は非オブジェクト引数で呼び出される場合があります：15またはnull（または通常、プリミティブ値、nullまたは未定義）。このような場合、関数はクローンを作成できないため、nullを返します-存在しないオブジェクトのインジケーター。

typeof演算子は、2つの値を区別します。

typeof undefined; // => 'undefined'
typeof null;      // => 'object'

厳密な品質演算子===は、undefinedとnullを正しく区別します。

let nothing = undefined;
let missingObject = null;
nothing === missingObject; // => false

異なる意味に加えて、他の違いがあります：

1. オブジェクトの分解は、これらの2つの値に対して異なる働きをします。

   const { a = "default" } = { a: undefined }; // a is "default"
   const { b = "default" } = { b: null };      // b is null

2. JSON.stringify（）は保持されますnullが省略されますundefined

   const json = JSON.stringify({ undefinedValue: undefined, nullValue: null });
   console.log(json); // prints {"nullValue":null}

3. typeof演算子

   console.log(typeof undefined); // "undefined"
   console.log(typeof null);      // "object" instead of "null"

変数が初期化されていない場合、その変数は未定義です。undefinedはオブジェクトではありません。例：var MyName; console.log（typeof MyName）;

開発ツールのコンソールログを確認してください。未定義として出力されます。

nullはオブジェクトです。一部の変数をnullにする場合はnullが使用されます。null変数は存在しますが、値は不明です。プログラムで変数に割り当てる必要があります。nullは自動的に初期化されません。

例：var MyName = null; console.log（typeof MyName）; 開発ツールのcsoleログを確認してください。これはオブジェクトになります。