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またはその逆を比較することもできます。その場合、条件は真になります。
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に設定するのが最善の方法です。
未定義のポップアップが表示されるもう1つの例は、delete演算子を使用したときです。私たち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
また、存在しなかった添え字やメンバーを読むと、未定義の値が返されます。
Nullと未定義の違いは、次のとおりです。JavaScriptでは、何もnullに設定されません。通常、これが行われます。変数を未定義に設定することはできますが、nullが優先されます。デバッグしているとき、これはnullに設定されたものはJavaScriptではなくあなた自身のものです。それ以外は、これら2つの特別な値はほぼ同等です。
null は、値がないことを示す特別なキーワードです。
次のように値として考えてください。
- "foo"は文字列です。
- trueはブール値です。
- 1234は数字です、
- nullは未定義です。
未定義 propertyは、変数にnullも含めた値が割り当てられていないことを示します。好き
var foo;
定義された空の変数は、データ型nullのundefinedです
両方とも値のない変数の 値を表しています
ANDnullは値を持たないstringを表しません - 空の文字列 -
好き
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
_ but _
var a;
console.log(a === null); //false
console.log(a === undefined); // true
_ so _ それぞれ独自の使い方があります
未定義 可変データ型の比較に使用
null 変数の値を空にするために使用します
var a = 'javascript';
a = null ; // will change the type of variable "a" from string to object
以下を注意深くお読みください。 JavaScriptのnullとndefinedの違いに関する疑問をすべて取り除きます。また、以下に示すユーティリティ関数を使用して、タイプを正確に決定できます。
JavaScriptでは、次のタイプの変数を使用できます。
- 宣言されていない変数
- 宣言済みだが未割り当ての変数
- リテラルndefinedで割り当てられた変数
- リテラルnullで割り当てられた変数
- ndefinedまたはnull以外で割り当てられた変数
以下では、これらの各ケースを1つずつ説明します
宣言されていない変数：宣言されていない変数については以下が当てはまります
- typeof（）でのみチェックできます。これは文字列を返します'undefined'
- ==または===またはifまたは条件演算子？（参照エラーをスロー）ではチェックできません
宣言済みだが未割り当ての変数
- typeofは文字列を返します'undefined'
- ==nullで確認trueを返します
- ==ndefinedでチェックtrueを返します
- ===nullで確認falseを返します
- ===ndefinedでチェックtrueを返します
- ifまたは条件演算子？はfalseを返します
リテラルで割り当てられた変数undefined：これらの変数は宣言済みしかし、未割り当て変数。
リテラルで割り当てられた変数null
- typeofは文字列を返します'object'
- ==nullで確認trueを返します
- ==ndefinedでチェックtrueを返します
- ===nullでチェックtrueを返します
- ===ndefinedで確認falseを返します
- ifまたは条件演算子？はfalseを返します
変数以外に割り当てられた変数undefinedまたはnull
- typeofは、次の文字列のいずれかを返します。'string'、'number'、'boolean'、'function' =、'オブジェクト'、'シンボル'
以下に、変数の正しい型チェックのアルゴリズムを示します。
- 未宣言/未割り当て/割り当て済みundefinedtypeofを使用します。文字列'undefined'が返された場合に戻ります。
- ===を使用してnullを確認します。 return 'null' if true.
- typeofを使用して実際のタイプを確認します。戻りタイプ 'object'と等しくない場合
- Object.prototype.toString.call（o）を呼び出して、実際のオブジェクトタイプを決定します。すべての組み込みJavascriptに対して'[object ObjectType]'タイプの文字列を返すか、DOM定義済みオブジェクトを返します。ユーザー定義オブジェクトの場合、'[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
}
null ：変数に値がない。 未定義 ：変数自体が存在しない。
..where variableは、値に関連付けられている記号名です。
JSは null で暗黙のうちに宣言された変数を初期化するのに十分親切にすることができますが、そうではありません。
undefined、null、Uncaught ReferenceErrorについて説明します。
1 - Uncaught ReferenceError：variable 宣言されていません あなたのスクリプトでは、この可変変数への参照はありません
2 - undefined：変数は宣言されていますが初期化されていません
3 - null：変数が宣言され、空の値です
未定義とは、変数は宣言されているが値がないことを意味します。
var var1;
alert(var1); //undefined
alert(typeof var1); //undefined
NULLは代入です。
var var2= null;
alert(var2); //null
alert(typeof var2); //object
システムレベル、予期しない、またはエラーのような値の欠如を表すためにundefined、プログラムレベル、通常の、または予想される値の欠如を表すためにnullを考えることができます。
javaScriptを介して：決定的なガイド
null および undefined は、次の2つの共通のオブジェクトタイプです。
- 両方とも単一の値、 null と undefined しか保持できません。
- どちらもプロパティやメソッドを持たず、どちらかのプロパティを読み込もうとすると実行時エラーになります（他のすべてのオブジェクトでは undefined 存在しないプロパティを読み込もうとした場合）。
- 値 null および undefined は、
==および!=演算子によって、互いに等しいとみなされ、他の何もしないと見なされます。
しかし類似点はここで終わります。しばらくの間、キーワード null および undefined の実装方法には根本的な違いがあります。これは明白ではありませんが、次の例を検討してください。
var undefined = "foo";
WScript.Echo(undefined); // This will print: foo
未定義 、 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 と同様に、これは基本的に特殊な "ゼロ"にすぎません。 未定義 一方、数値コンテキストで使用しようとすると、真の「なし」になり、 NaN （「数字ではない」）になります。
null および undefined は==および!=演算子から特別な扱いを受けますが、式(a >= b && a <= b)を使用して a および b の真の数値等価性をテストできます。
tl; dr
Objectであることがわかっている変数を設定するには、nullを使用します。
型が混在する変数を設定するにはundefinedを使用します。
これが私の5つのプリミティブとオブジェクト型の使い方で、undefinedとnullの«ユースケース»の違いを説明しています。
文字列
すべてのライフサイクルの間、変数が文字列のみであることがわかっている場合は、慣例により、それを""に初期化できます。
("") ? true : false; // false
typeof ""; // "string";
("Hello World") ? true : false; // true
typeof "Hello World"; // "string"
番号
すべてのライフサイクルの中で変数が単なる数値であることがわかっている場合は、慣例として、変数を0に初期化できます（または0が使用上重要な値である場合はNaN）。
(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は常にtrueであり、typeof nullはobjectを返すので、nullを無効にしたスマートな使用法は、 falsy バージョンのObjectになります。これはtypeof myVarObjectがObject型とnull型の両方に対して一貫した値を返すことを意味します。
すべて
変数の型が混在していることがわかっている場合（ライフサイクル全体を通して任意の型）、慣例として、変数をundefinedに初期化できます。
（文字が足りないために文字を追加するので、これを投稿できます。）
nullは「値なし」を意味する特別な値です。 typeof nullは「object」を返すので、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つの異なる値nullとundefinedで後者の2つのケースを区別します。これらの値を明示的に使用してこれらの意味を伝えることができます。
それでは、この哲学的基盤のために発生するJavaScript固有の問題のいくつかは何ですか？
初期化指定子なしで宣言された変数は、値
undefinedを取得します。これは、意図した値が何であるかについて何も言っていないためです。let supervisor; assert(supervisor === undefined);一度も設定されていないオブジェクトのプロパティは、そのプロパティについて誰も何も言っていないので、
undefinedと評価されます。const dog = { name: 'Sparky', age: 2 }; assert(dog.breed === undefined);Brendan Eichが言っているので、
nullとundefinedは互いに「似ている」のです。しかし、彼らは強調してお互いに等しくありません。assert(null == undefined); assert(null !== undefined);nullとundefinedはありがたいことに異なる型を持っています。nullはNull型に属し、undefinedはUndefined型に属します。これは仕様の中にありますが、私はここでは繰り返さないtypeofの奇妙さのためにこれを知ることはありません。明示的なreturn文を使わずに本体の終わりに達する関数は、
undefinedを返します。何が返されたかについては何も知らないからです。
ちなみに、JavaScriptには他にも「無」の形があります（哲学を学んだことは良いことです）。
NaN- 一度も宣言されていない変数を使用して
ReferenceErrorを受け取る - 一時的なデッドゾーンで
letまたはconstで定義されたローカル変数を使用し、ReferenceErrorを受け取る スパース配列内の空のセルはい、これらは
undefinedでさえありませんが、===を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値を代入しました
nullとundefinedについて聞くと混乱するかもしれませんが、簡単に始めましょう。これらは両方とも falsy であり、多くの点で似ていますが、JavaScriptの奇妙な部分です。たとえば、 typeof nullは'object'で、 typeof undefinedは'undefined'です。
typeof null; //"object"
typeof undefined; //"undefined";
しかし、以下のように==でチェックすれば、両方とも falsy です。
null==undefined; //true
また、nullはオブジェクトプロパティまたはプリミティブに割り当てることができますが、undefinedは単純に何にも割り当てないことで実現できます。
一目であなたのために違いを示すために私は速いイメージを作成します。
JavaScriptでNullと未定義の両方が価値の欠如を示します。
var a = null; //variable assigned null value var b; // undefined両方とも値がないために存在するという事実にもかかわらず：未定義は実際には変数が初期化されていないことを意味します。何も返さない関数、および値が指定されていない関数パラメータ、未定義の値が返されます。 nullと未定義を区別するには、厳密な等価演算子===を使用してください。
nullとundefinedの微妙な違いを追加したいと思います。これは、Vanilla JavaScript（JS）をゼロから学習しようとしているときに知っておくと便利です。
nullはJSの予約キーワードですが、undefinedは実行環境のグローバルオブジェクトの変数です。
コードを記述している間、nullとundefinedの両方がJavaScriptステートメントのRHSで常に使用されるため、この違いは識別できません。しかし、式のLHSでそれらを使用すると、この違いを簡単に観察できます。そのため、JSインタープリターは以下のコードをエラーとして解釈します。
var null = 'foo'
以下のエラーが発生します：
キャッチされていないSyntaxError：予期しないトークンnull
以下のコードは正常に実行されますが、実際にはそうすることはお勧めしません：
var undefined = 'bar'
これは、undefinedがグローバルオブジェクト（クライアント側JSの場合はブラウザウィンドウオブジェクト）の変数であるため機能します
nullとundefinedはどちらも、値がないことを表すために使用されます。
var a = null;
aは初期化され定義されています。
typeof(a)
//object
nullはJavaScriptのオブジェクトです
Object.prototype.toString.call(a) // [object Object]
var b;
bは未定義かつ未初期化
未定義のオブジェクトプロパティも未定義です。たとえば、 "x"はオブジェクトcに定義されていないため、c.xにアクセスしようとすると、undefinedが返されます。
通常、未定義ではない変数にはnullを割り当てます。
Typeofがundefinedを返すので、undefinedはnullが初期化子として変数がオブジェクトを指していないことを示す型です（Javascriptの実質的にすべてがオブジェクトです）。
undefined型には、undefinedという唯一の値があります。
null型には、nullという唯一の値があります。
そのため、両方とも ラベルはその型と値の両方です。
それらの違い例えば：
nullは空の値ですundefinedが欠損値です
または
undefinedはまだ値を持っていませんnullは値を持っていましたがもはやありません
実際には、nullは 特殊キーワード であり、識別子ではないため、代入する変数として扱うことはできません。
ただし、undefinedは 識別子 です。 non-strictモードとstrictモードのどちらでも、undefinedという名前のローカル変数を作成できます。しかし、これは1つのひどい考えです！
function foo() {
undefined = 2; // bad idea!
}
foo();
function foo() {
"use strict";
undefined = 2; // TypeError!
}
foo();
JavaScriptで変数を宣言すると、その変数に値undefinedが割り当てられます。これは、その変数が変更されていないことを意味し、将来的には任意の値を割り当てることができます。また、宣言時にこの変数が保持する値がわからないことも意味します。
これで、変数nullを明示的に代入できます。つまり、変数には値がありません。たとえば、ミドルネームを持たない人もいます。そのため、そのような場合は、人物オブジェクトのmiddlename変数にnull値を代入することをお勧めします。
今、誰かがあなたのpersonオブジェクトのmiddlename変数にアクセスしていて、それがundefinedという値を持っているとしましょう。開発者がこの変数を初期化するのを忘れたのか、それとも値がないのか、彼は知りませんでした。値がnullであれば、ユーザーはミドルネームに値がなく、手付かずの変数ではないと簡単に推測できます。
基本的に、 未定義 は、値が変数に割り当てられていないことをnullが意味するかどうかにかかわらず、javascriptが実行時に作成するグローバル変数です（実際にはnull自体がオブジェクトです）。
例を見てみましょう。
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 の主な違いです。
null - 代入値であり、変数を使用して値を表しません（オブジェクトです）。
undefined - 値が割り当てられていない変数なので、JavaScriptはundefinedをそれに割り当てます（データ型です）。
undeclared - 変数がまったく作成されない場合、それは未宣言と呼ばれます。
この問題に関するPer Ryan Morrの徹底的な記事...
「一般に、変数やプロパティに値以外の値を代入したり、関数に渡したり、関数から戻す必要がある場合は、ほとんどの場合、nullが最善の選択肢です。 nullを使用してください。」
JavaScriptでは、すべての変数はキーと値のペアとして格納されます。各変数は、 variable_name：variable_value/reference として格納されます。
未定義 は、変数にメモリ内のスペースが割り当てられているが、値が割り当てられていないことを意味します。ベストプラクティスとして、この型を代入として使用しないでください。
その場合、コードの後半で、変数に値がないことを示す方法を示します。タイプ null を使用することもできます。これは、同じものを定義し、値が存在しない場合にも使用されるタイプです。 。その値は null です。
どちらも似ていますが、使い方と意味は異なります。
undefinedとnullの違いは最小限ですが、違いがあります。値がundefinedの変数は初期化されていません。値がnullの変数には、明示的にnullの値が与えられています。これは、変数が明示的に値を持たないように設定されていることを意味します。 null==undefined式を使用してundefinedとnullを比較すると、それらは等しくなります。