What is the difference between null and undefined in JavaScript?

Question

What is the difference between null and undefined in JavaScript?

• Muhammad Umer: I always thought: null is you set it to empty, undefined it's empty because it has not been set. Or null is empty on purpose, while undefined is still empty. Basically it shows intent.
• Bergi: See also Why is null an object and what's the difference between null and undefined?
• Ivan: NaN. See for yourself. console.log(null-undefined). The difference between null and undefined is NaN. (Note that this is an attempt at humour, before you flame me for misunderstanding the question.)
• Robert: With null you use it generally to erase the contents of a variable, with undefined it generally comes with input when there hasn't been set a value yet.
• Chris Collett: As a side note, it's worth noting that while the originator of null called it his "billion-dollar mistake" (Tony Hoare), JavaScript happily decided to multiply that mistake by 2. Happy debugging!

Answer 1

undefined means a variable has been declared but has not yet been assigned a value :

var testVar;
console.log(testVar); //shows undefined
console.log(typeof testVar); //shows undefined

null is an assignment value. It can be assigned to a variable as a representation of no value :

var testVar = null;
console.log(testVar); //shows null
console.log(typeof testVar); //shows object

From the preceding examples, it is clear that undefined and null are two distinct types: undefined is a type itself (undefined) while null is an object.

Proof :

console.log(null === undefined) // false (not the same type)
console.log(null == undefined) // true (but the "same value")
console.log(null === null) // true (both type and value are the same)

and

null = 'value' // Uncaught SyntaxError: invalid assignment left-hand side
undefined = 'value' // 'value'

• Captain Sensible: Quote from the book Professional JS For Web Developers (Wrox): "You may wonder why the typeof operator returns 'object' for a value that is null. This was actually an error in the original JavaScript implementation that was then copied in ECMAScript. Today, it is rationalized that null is considered a placeholder for an object, even though, technically, it is a primitive value."
• Nir O.: the variable might as well not be defined at all. for example: console.log(typeof(abc)); undefined
• Wolfgang Adamec: The comment from Nir O. is very important. If I want to have a variable that has no value in the beginning, I write "... = null", eg "myvar = null". This way - when I mistype "if (myxar == null) {...}" - the if block is not executed. I don't have this advantage with undefined: myvar = undefined; myvar = 4; if (typeof myxar == "undefined") { ...}
• Jorge Fuentes González: @Wolfgang Adamec, error-free programming is not about mistypes.
• Muhammad Umer: so basically null value means a variable has been explicitly set as (no value = null) or has been initialized and defined to be nothing. While undefined means. it was probably never initialized or if it was it was never defined.

Answer 2

The difference can be explained with toilet tissue holder:

• A non-zero value is like a holder with roll of toilet tissue and there's tissue still on the tube.

• A zero value is like a holder with an empty toilet tissue tube.

• A null value is like a holder that doesn't even have a tissue tube.

• An undefined value is similar to the holder itself being missing.

• Vega: Could you include the attribution for the image source, please?
• Sebastian Norr: @Vega Unfortunately no, I don't remember where I got it from other than somewhere on imgur.com and that's probably from a repost, not the ORIGINAL source. Not even the embedded link here gives any clue of who posted this version, so I can't really search for it either.
• MandarineBleue: @SebastianNorr "I don't remember where I got it from other than somewhere on imgur.com" -> so is it undefined or null in that case?
• Rain: let toiletPaperIn2020 = undefined;
• Stefaan Vandevelde: undefined cannot be an empty wall if the holder represents the variable. In this representation, undefined is an empty holder while null is an empty holder with post-it note empty. (so the unfortunate user knows it's useless to ask the cleaning lady for toilet paper). That also show why many developers are confused : should I put an empty post-it note on an uninitialized variable or will everyone understand that empty means empty ? e.g. is the lack op toilet paper intentional or not ?

Answer 3

I picked this from here

The undefined value is a primitive value used when a variable has not been assigned a value.

The null value is a primitive value that represents the null, empty, or non-existent reference.

When you declare a variable through var and do not give it a value, it will have the value undefined. By itself, if you try to WScript.Echo() or alert() this value, you won't see anything. However, if you append a blank string to it then suddenly it'll appear:

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

You can declare a variable, set it to null, and the behavior is identical except that you'll see "null" printed out versus "undefined". This is a small difference indeed.

You can even compare a variable that is undefined to null or vice versa, and the condition will be true:

undefined == null
null == undefined

They are, however, considered to be two different types. While undefined is a type all to itself, null is considered to be a special object value. You can see this by using typeof() which returns a string representing the general type of a variable:

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

Running the above script will result in the following output:

undefined
object

Regardless of their being different types, they will still act the same if you try to access a member of either one, e.g. that is to say they will throw an exception. With WSH you will see the dreaded "'varname' is null or not an object" and that's if you're lucky (but that's a topic for another article).

You can explicitely set a variable to be undefined, but I highly advise against it. I recommend only setting variables to null and leave undefined the value for things you forgot to set. At the same time, I really encourage you to always set every variable. JavaScript has a scope chain different than that of C-style languages, easily confusing even veteran programmers, and setting variables to null is the best way to prevent bugs based on it.

Another instance where you will see undefined pop up is when using the delete operator. Those of us from a C-world might incorrectly interpret this as destroying an object, but it is not so. What this operation does is remove a subscript from an Array or a member from an Object. For Arrays it does not effect the length, but rather that subscript is now considered undefined.

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

The result of the above script is:

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

You will also get undefined returned when reading a subscript or member that never existed.

The difference between null and undefined is: JavaScript will never set anything to null, that's usually what we do. While we can set variables to undefined, we prefer null because it's not something that is ever done for us. When you're debugging this means that anything set to null is of your own doing and not JavaScript. Beyond that, these two special values are nearly equivalent.

• wOlVeRiNe: Really a good answer. But just to point out, when u checked "undefined == null" the type checking was not strict. Hence it returned "true". If you check "undefined === null", it would return false.
• 0x24a537r9: It's worth noting that while this comment was true in '11, with the advent of optional function params, emergence of type-checking systems like Flow, and pervasiveness of React (all of which treat undefined and null very differently), the old wisdom of generally using null rather than undefined no longer holds so strictly. undefined is actually preferable to null in many cases where you want to explicitly use the default value (e.g. for an optional param or optional React prop).
• Michael Freidgeim: From blog.devgenius.io/… "in my point of view, better not to use null at all and prefer undefined."

Answer 4

Please read the following carefully. It should remove all your doubts regarding the difference between null and undefined in JavaScript. Also, you can use the utility function at the end of this answer to get more specific types of variables.

In JavaScript we can have the following types of variables:

1. Undeclared Variables
2. Declared but Unassigned Variables
3. Variables assigned with literal undefined
4. Variables assigned with literal null
5. Variables assigned with anything other than undefined or null

The following explains each of these cases one by one:

1. Undeclared Variables

   • Can only be checked with the typeof operator which returns string 'undefined'
   • Cannot be checked with the loose equality operator ( == undefined ), let alone the strict equality operator ( === undefined ),
     as well as if-statements and ternary operators ( ? : ) — these throw Reference Errors

2. Declared but Unassigned Variables

   • typeof returns string 'undefined'
   • == check with null returns true
   • == check with undefined returns true
   • === check with null returns false
   • === check with undefined returns true
   • Is falsy to if-statements and ternary operators ( ? : )

3. Variables assigned with literal undefined
   These variables are treated exactly the same as Declared But Unassigned Variables.

4. Variables assigned with literal null

   • typeof returns string 'object'
   • == check with null returns true
   • == check with undefined returns true
   • === check with null returns true
   • === check with undefined returns false
   • Is falsy to if-statements and ternary operators ( ? : )

5. Variables assigned with anything other than undefined or null

   • typeof returns one of the following strings: 'bigint', 'boolean', 'function', 'number', 'object', 'string', 'symbol'

Following provides the algorithm for correct type checking of a variable:

1. Get the typeof our variable and return it if it isn't 'object'
2. Check for null, as typeof null returns 'object' as well
3. Evaluate Object.prototype.toString.call(o) with a switch statement to return a more precise value. Object's toString method returns strings that look like '[object ConstructorName]' for native/host objects. For all other objects (user-defined objects), it always returns '[object Object]'
4. If that last part is the case (the stringified version of the variable being '[object Object]') and the parameter returnConstructorBoolean is true, it will try to get the name of the constructor by toString-ing it and extracting the name from there. If the constructor can't be reached, 'object' is returned as usual. If the string doesn't contain its name, 'anonymous' is returned

(supports all types up to ECMAScript 2020)

function TypeOf(o, returnConstructorBoolean) {
 const type = typeof o
 if (type !== 'object') return type
 if (o === null) return 'null'
 const toString = Object.prototype.toString.call(o)
 switch (toString) {
 // Value types: 6
 case '[object BigInt]': return 'bigint'
 case '[object Boolean]': return 'boolean'
 case '[object Date]': return 'date'
 case '[object Number]': return 'number'
 case '[object String]': return 'string'
 case '[object Symbol]': return 'symbol'
 // Error types: 7
 case '[object Error]': return 'error'
 case '[object EvalError]': return 'evalerror'
 case '[object RangeError]': return 'rangeerror'
 case '[object ReferenceError]': return 'referenceerror'
 case '[object SyntaxError]': return 'syntaxerror'
 case '[object TypeError]': return 'typeerror'
 case '[object URIError]': return 'urierror'
 // Indexed Collection and Helper types: 13
 case '[object Array]': return 'array'
 case '[object Int8Array]': return 'int8array'
 case '[object Uint8Array]': return 'uint8array'
 case '[object Uint8ClampedArray]': return 'uint8clampedarray'
 case '[object Int16Array]': return 'int16array'
 case '[object Uint16Array]': return 'uint16array'
 case '[object Int32Array]': return 'int32array'
 case '[object Uint32Array]': return 'uint32array'
 case '[object Float32Array]': return 'float32array'
 case '[object Float64Array]': return 'float64array'
 case '[object ArrayBuffer]': return 'arraybuffer'
 case '[object SharedArrayBuffer]': return 'sharedarraybuffer'
 case '[object DataView]': return 'dataview'
 // Keyed Collection types: 2
 case '[object Map]': return 'map'
 case '[object WeakMap]': return 'weakmap'
 // Set types: 2
 case '[object Set]': return 'set'
 case '[object WeakSet]': return 'weakset'
 // Operation types: 3
 case '[object RegExp]': return 'regexp'
 case '[object Proxy]': return 'proxy'
 case '[object Promise]': return 'promise'
 // Plain objects
 case '[object Object]':
 if (!returnConstructorBoolean)
 return type
 const _prototype = Object.getPrototypeOf(o)
 if (!_prototype) 
 return type
 const _constructor = _prototype.constructor
 if (!_constructor) 
 return type
 const matches = Function.prototype.toString.call(_constructor).match(/^function\s*([^\s(]+)/)
 return matches ? matches[1] : 'anonymous'
 default: return toString.split(' ')[1].slice(0, -1)
 }
}

Answer 5

null is a special keyword that indicates an absence of value.

think about it as a value, like:

• "foo" is string,
• true is boolean ,
• 1234 is number,
• null is undefined.

---

undefined property indicates that a variable has not been assigned a value including null too . Like

var foo;

---

defined empty variable is null of datatype undefined

---

Both of them are representing a value of a variable with no value

AND null doesn't represent a string that has no value - empty string-

---

Like

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

Now if

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 each one has it own way to use

undefined use it to compare the variable data type

null use it to empty a value of a variable

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

• danwellman: null is also a data type. Both undefined and null are data types and values
• danwellman: null Absolutely IS a data type: msdn.microsoft.com/en-us/library/ie/7wkd9z69(v=vs.94).aspx . The fact that typeof null returns object is a well known and documented bug in early versions of ECMAScript that has remained for backwards-compatibility. The link that you actually posted in your comment says halfway down the page "typeof null // object (bug in ECMAScript, should be null)" ! So please, show some search effort before commenting on down-votes
• Zon: Definitions contradict: "absence of value" vs "has not been assigned a value". Isn't it the same?
• alaboudi: I disagree with this answer. Null and undefined are both distinct datatypes. null is of type null and undefined is of type undefined. Only when using a truthy operator (==) may we see that javascript says its true but a strict comparison (===) is produces a false.
• Sebastian Simon: To this day "null is undefined" remains wrong.

Answer 6

null: absence of value for a variable; undefined: absence of variable itself;

..where variable is a symbolic name associated with a value.

JS could be kind enough to implicitly init newly declared variables with null, but it does not.

• Muhammad Umer: var a = {}; a.n = undefined;' then ..a.hasOwnProperty('n') == true` ...so saying absence of variable itself isn't correct anymore
• Steve Bennett: That's a really pithy definition, but it's not really accurate - for the reason you give. A defined variable starts with the value undefined.
• Aman Godara: Even after these many years of this answer being posted, I think I agree with this answer. The intent of undefined is that the variable doesn't exist and the intent of null is that variable exists but has no value. Peeps are going into the implementation-specific details by checking typeof variables but missed to understand one of the most powerful term of CS called "abstraction".

Answer 7

A lot of "technical" answers have been given, all of them mostly correct from the limited point of view of JS as a mere programming language.

However, I would like to add the following thoughts, especially when you're writing TypeScript code as part of a bigger project / (enterprise) application:

• When talking with a Backend of some kind you'll most probably receive JSON
• While some backends correctly avoid the use of "null" in their JSON (removing those properties), others do not
• Now, while "null" may mean that the value is missing deliberately, more often it does not convey this meaning. Most databases use "null" just because they don't have an "undefined" type. But the meaning really just is "undefined".
• Because of that, you can never know if a "null" value really means deliberate absence. Therefore "null" cannot really mean the deliberate choice of "missing value". It is undecidable in general.
• As a consequence, semantically, "null" and "undefined" are exactly the same thing in practice.

Therefore, in an effort to harmonize things I'm strictly against using "null" and want to encourage you to stop using "null" in your code. It's far easier than you might think. Don't get me wrong. I'm not talking about not handling "null" values, only to avoid explicitly using them in your code. Put differently: your code should still be able to work with accidentally passed "null" values coming from outside your application, e.g. via a 3rd party lib like Angular, or a 3rd party backend.

Here are the guidelines that make it possible:

• avoid direct undefined type guards (e.g. if (value === undefined) { ... }.
• Instead, use indirect type guards (aka truthiness checks) e.g. if (value) { ... }
  • Whenever 0 or empty strings are meaningful, use either
    • an explicit helper method like Lodash's isNil
    • or include the meaningful value in the comparison (e.g. if (!value && value !== 0) { ... })
• Consider using a lint rule that disallows the usage of null

• Steven Coco: This is an interesting perspective, and I think it could be expanded; and that's why I'm just posting this comment. Now that C# has implemented non-nullable types, there's a kind of "progress", if you want to call it that, towards understanding something that I'd phrase like: if you request a database for a key that it doesn't have, then you return undefined, because the key is undefined; but if you request a key that it does have, you return null for any value that's not null — you don't return undefined there. So just wondering if fails are picking up on some trend or whatever you call it?
• jdmneon: I agree with this completely. It's more important to look at this in the context of the ecosystem, you generally cannot garuntee your datasource is differentiating between Unknown and Null in the same way that Javascript the programming language does. In fact this is rarely true. Therefore you cannot assume null is intentional for this reason you must treat them same. This is especially true when we are discussing a program that gets data from multiple sources or you don't have control of the structure of the datasource. Javascripts actual implementation is unimportant in this context.
• Nagev: Agree that if (value) is better than if (value == null). But what would a function return instead of an object, when it encounters an error? I would think that return null is the obvious choice, but it's not clear what you're suggesting with 'stop using "null" in your code' in this case.
• spender: I completely agree with the main sentiment of this post. The difference between null and undefined is just the opinion of the person who used it in the first place. Looking through some of the other answers here, it is clear that many people have different ideas about what each means. The only way of silencing those ambiguous opinions is to accept that, at a conceptual level, they are the same thing. As such, the safe way to check for both null and undefined is if(value == null){.... Airbnb ESLINT rules specifically make an exception to the "always use ===" to allow for == null.
• Mikko Rantalainen: I think it's much better to use null or undefined instead of coming up with some OOP crap to create new classes like Option or Some to copy some Haskell or Rust style code. Also, I'd much rather see if (x === null || x === undefined) instead of having just one more dependency.

Answer 8

You might consider undefined to represent a system-level, unexpected, or error-like absence of value and null to represent program-level, normal, or expected absence of value.

via JavaScript:The Definitive Guide

• Arad: I really like this description.
• Stevenfowler16: This is what I think I'm going to use as well. If I receive a null I know the value was set to null on purpose

Answer 9

The best way to understand the difference is to first clear your mind of the inner workings of JavaScript and just understand the differences in meaning between:

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.

There is a difference in meaning between these three cases, and JavaScript distinguishes the latter two cases with two different values, null and undefined. You are free to use those values explicitly to convey those meanings.

So what are some of the JavaScript-specific issues that arise due to this philosophical basis?

1. A declared variable without an initializer gets the value undefined because you never said anything about the what the intended value was.

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

2. A property of an object that has never been set evaluates to undefined because no one ever said anything about that property.

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

3. null and undefined are "similar" to each other because Brendan Eich said so. But they are emphatically not equal to each other.

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

4. null and undefined thankfully have different types. null belongs to the type Null and undefined to the type Undefined. This is in the spec, but you would never know this because of the typeof weirdness which I will not repeat here.

5. A function reaching the end of its body without an explicit return statement returns undefined since you don't know anything about what it returned.

By the way, there are other forms of "nothingness" in JavaScript (it's good to have studied Philosophy....)

• NaN
• Using a variable that has never been declared and receiving a ReferenceError
• Using a let or const defined local variable in its temporal dead zone and receiving a ReferenceError

• Empty cells in sparse arrays. Yes these are not even undefined although they compare === to undefined.

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

• J. Bruni: Best answer! Most of the answers ignore the fact that you can define the value of a variable as undefined, like in the let supervisor = undefined case.
• Ray Toal: Thank you, and yes, that misconception that something is undefined only if it has not been declared or has not yet been given a value is so rampant and it is really hard to get across to people (though I keep trying). So many people trash JavaScript for having both null and undefined but these values do have completely distinct meanings and for the most part they work well with their intended meanings (IMHO of course).

Answer 10

null is a special value meaning "no value". null is a special object because typeof null returns 'object'.

On the other hand, undefined means that the variable has not been declared, or has not been given a value.

• Yura: It is important to note, that while undefined may mean that a variable has not been declared, but does not guarantee that. A variable can be declared as var thing; and it will be equal to undefined.

Answer 11

null and undefined are two distinct object types which have the following in common:

• both can only hold a single value, null and undefined respectively;
• both have no properties or methods and an attempt to read any properties of either will result in a run-time error (for all other objects, you get value undefined if you try to read a non-existent property);
• values null and undefined are considered equal to each other and to nothing else by == and != operators.

The similarities however end here. For once, there is a fundamental difference in the way how keywords null and undefined are implemented. This is not obvious, but consider the following example:

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

undefined, NaN and Infinity are just names of preinitialized "superglobal" variables - they are initialized at run-time and can be overridden by normal global or local variable with the same names.

Now, let's try the same thing with null:

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

Oops! null, true and false are reserved keywords - compiler won't let you use them as variable or property names

Another difference is that undefined is a primitive type, while null is an object type (indicating the absense of an object reference). Consider the following:

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

Also, there is an important difference in the way null and undefined are treated in numeric context:

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 becomes 0 when used in arithmetic expressions or numeric comparisons - similarly to false, it is basically just a special kind of "zero". undefined, on the other hand, is a true "nothing" and becomes NaN ("not a number") when you try to use it in numeric context.

Note that null and undefined receive a special treatment from == and != operators, but you can test true numeric equality of a and b with the expression (a >= b && a <= b).

Answer 12

I'll explain undefined, null and Uncaught ReferenceError:

1 - Uncaught ReferenceError : variable has not been declared in your script, there is no reference to this varaible
2 - undefined: Variable declared but does not initialised
3 - null : Variable declared and is an empty value

Answer 13

Undefined means a variable has been declared but has no value:

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

Null is an assignment:

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

Answer 14

In addition to a different meaning there are other differences:

1. Object destructuring works differently for these two values:

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

2. JSON.stringify() keeps null but omits undefined

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

3. typeof operator

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

• FaniX: HTMLElement.style property setters also treat null and undefined differently. setting .style[prop]=null will clear the property, while setting .style[prop]=undefined has no effect.

Answer 15

tl;dr

Use null for set a variable you know it is an Object.

Use undefined for set a variable whose type is mixed.

---

This is my usage of both 5 primitives and Object type, and that explain the difference between « use case » of undefined or null.

String

If you know a variable is only a string while all lifecycle, by convention, you could initialize it, to "":

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

Number

If you know a variable is only a number while all lifecycle, by convention, you could initialize it, to 0 (or NaN if 0 is an important value in your usage):

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

or

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

Boolean

If you know a variable is only a boolean while all lifecycle, by convention, you could initialize it, to false:

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

Object

If you know a variable is only an Object while all lifecycle, by convention, you could initialize it, to null:

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

Note: the smart usage off null is to be the falsy version of an Object because an Object is always true, and because typeof null return object. That means typeof myVarObject return consistent value for both Object and null type.

All

If you know a variable has a mixed type (any type while all lifecycle), by convention, you could initialize it, to undefined.

Answer 16

In JavasScript there are 5 primitive data types: String, Number, Boolean, null and undefined. I will try to explain with some simple examples.

Let's say we have a simple function

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

Also, in above function if(a == null) is the same as if(!a).

Now when we call this function without passing the parameter a

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

also

var a;
alert(typeof a);

This will give undefined; we have declared a variable but we have not asigned any value to this variable;

but if we write

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

so null is an object. In a way we have assigned a value null to 'a'

• Alexander Mills: Symbol is a new primitive type :)
• jimmyfever: In your a == null example above, it's only true because null and undefined are both truthily equal (null === undefined is false.) If you call test() without an argument, it will be undefined.
• Ray Toal: Update for 2020: There are now seven primitives types. Symbol and BigInt were added since this answer was written.
• Simon Dell: Nitpick: String and Number are complex types: they have Object as their prototype. The primitive types return string and number from the typeof command. e.g typeof 'foo'; // => "string" and typeof (new String('foo')); // => "object".

Answer 17

When you declare a variable in javascript, it is assigned the value undefined. This means the variable is untouched and can be assigned any value in future. It also implies that you don't know the value that this variable is going to hold at the time of declaration.

Now you can explicitly assign a variable null. It means that the variable does not have any value. For example - Some people don't have a middle name. So in such a case its better to assign the value null to the middlename variable of a person object.

Now suppose that someone is accessing the middlename variable of your person object and it has the value undefined. He wouldn't know if the developer forgot to initialize this variable or if it didn't have any value. If it has the value null, then the user can easily infer that middlename doesn't have any value and it is not an untouched variable.

Answer 18

OK, we may get confused when we hear about null and undefined, but let's start it simple, they both are falsy and similar in many ways, but weird part of JavaScript, make them a couple of significant differences, for example, typeof null is 'object' while typeof undefined is 'undefined'.

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

But if you check them with == as below, you see they are both falsy:

null==undefined; //true

Also you can assign null to an object property or to a primitive, while undefined can simply be achieved by not assigning to anything.

I create a quick image to show the differences for you at a glance.

Null and Undefined

Answer 19

For the undefined type, there is one and only one value: undefined.

For the null type, there is one and only one value: null.

So for both of them, the label is both its type and its value.

The difference between them. For example:

• null is an empty value
• undefined is a missing value

Or:

• undefined hasn't had a value yet
• null had a value and doesn't anymore

Actually, null is a special keyword, not an identifier, and thus you cannot treat it as a variable to assign to.

However, undefined is an identifier. In both non-strict mode and strict mode, however, you can create a local variable of the name undefined. But this is one terrible idea!

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

Answer 20

I want to add a knowledge point which pertains to a subtle difference between null and undefined. This is good to know when you are trying to learn Vanilla JavaScript(JS) from ground up:

null is a reserved keyword in JS while undefined is a property on the global object of the run-time environment you're in.

While writing code, this difference is not identifiable as both null and undefined are always used in right hand side (RHS) of a JavaScript statement. But when you use them in left hand side (LHS) of an expression then you can observe this difference easily. So JS interpreter interprets the below code as error:

var null = 'foo'

It gives below error:

Uncaught SyntaxError: Unexpected token null

At the same time, below code runs successfully although I won't recommend doing so in real life:

var undefined = 'bar'

This works because undefined is a property on the global object (window object in case of JavaScript running in a browser)

• Dmitri Zaitsev: undefined='bar' does not really assign any value to undefined (which is immutable), it just doesn't throw an error confusingly.

Answer 21

null and undefined are both are used to represent the absence of some value.

var a = null;

a is initialized and defined.

typeof(a)
//object

null is an object in JavaScript

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

b is undefined and uninitialized

undefined object properties are also undefined. For example "x" is not defined on object c and if you try to access c.x, it will return undefined.

Generally we assign null to variables not undefined.

• Paul S.: Object.prototype.toString.call(null); // "[object Null]"

Answer 22

Per Ryan Morr's thorough article on this subject...

"Generally, if you need to assign a non-value to a variable or property, pass it to a function, or return it from a function, null is almost always the best option. To put it simply, JavaScript uses undefined and programmers should use null."

See Exploring the Eternal Abyss of Null and Undefined

Answer 23

In javascript all variables are stored as key value pairs. Each variable is stored as variable_name : variable_value/reference.

undefined means a variable has been given a space in memory, but no value is assigned to it. As a best practice, you should not use this type as an assignment.

In that case how to denote when you want a variable to be without value at a later point in the code? You can use the type null ,which is also a type that is used to define the same thing, absence of a value, but it is not the same as undefined, as in this case you actually have the value in memory. That value is null

Both are similar but usage and meaning are different.

Answer 24

The difference in meaning between undefined and null is an accident of JavaScript’s design, and it doesn’t matter most of the time. In cases where you actually have to concern yourself with these values, I recommend treating them as mostly interchangeable.

From the Eloquent Javascript book

Answer 25

As typeof returns undefined, undefined is a type where as null is an initializer indicates the variable points to no object(virtually everything in Javascript is an object).

Answer 26

null - It is an assignment value, which is used with variable to represent no value (it's an object).

undefined - It is a variable which does not have any value assigned to it, so JavaScript will assign an undefined to it (it's a data type).

undeclared - If a variable is not created at all, it is known as undeclared.

Answer 27

Check this out. The output is worth thousand words.

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>

See also:

• 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

Cheers!

• J. Bruni: From this I actually learned that isNaN(null) returns false - which surprised me.

Answer 28

Generally – don't use null to avoid confusion.

1. Standard library methods return undefined, not null

let a = [10];
console.log(a[1]) //=> undefined
console.log(a.find(value => value === 5)) //=> undefined

2. I see often in people's code that some variable was undefined at first, then assigned to some value, then cleared by setting to null. That's not consistent, better to set back to undefined.

Still, null makes sense if framework uses it, or for json serialization.

Answer 29

The difference between undefined and null is minimal, but there is a difference. A variable whose value is undefined has never been initialized. A variable whose value is null was explicitly given a value of null, which means that the variable was explicitly set to have no value. If you compare undefined and null by using the null==undefined expression, they will be equal.

• Guy: This answer is misleading... see the discussion in the accepted answer. Bottom line - null==undefined is true only because of implicit casting (or the equivalent term in JS). Evidently, null===undefined is false because using when you use === it compares the type as well.

Answer 30

Basically, Undefined is a global variable that javascript create at the run time whether null means that no value has assigned to the variable (actually null is itself an object).

Let's take an example:

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

Undefined that's what you will get as output.

Now,

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

and you will get 5 as output. That's the main difference between the Undefined and null