Null and Undefined in JavaScript

Introduction

Null and undefined in JavaScript are two different concepts in JavaScript and this article explains these two terms in detail. In JavaScript, as a dynamically and weakly typed language, the handling of data types is quite different from that in strongly typed languages. When it comes to the differing data types of JavaScript, null and undefined can be quite problematic for developers – specifically, newcomers to JavaScript. This article further discusses null and undefined and be equipped with clarification on their meanings, distinction as well as how to use them properly.

Definitions

Undefined

• They include logical variables that have been declared but are not assigned any value, they are of type undefined.
• The purpose it serves is that it’s a primitively set value by JavaScript.

Example :

let x;
console.log(x); // Output: undefined

Null

• null is a default value that is assigned to a variable when it is clear that it is not currently holding a value on object.
• The null value is used where no other value is appropriate or desirable, and it is specifically assigned by the programmer where the variable is to have no value.
• Null and undefined values need distinction as they are not the same, although they are rather similar in many cases.

Example :

let y = null;
console.log(y); // Output: null

Key Differences Between Null and Undefined

Type of Null and Undefined:

• undefined is a type itself.
• null is an object.

Example :

console.log(typeof undefined); // Output: "undefined"
console.log(typeof null); // Output: "object"

Default Initialization:

• Variables are automatically initialized to undefined unlike arrays which are initialized to null.
• null value has to be assigned by the programmer against any of the variables, explicitly.

Usage Context:

• Undefined is used to represent a variable that has been declared but not assigned to a value yet.
• Utilize null where an object or a value is deliberately missing from the aspects of a project.

Comparison Operators

== (Abstract Equality ) : In JavaScript, using == comes to comparison null and undefined will result in the evaluation of the statement as true.

console.log(null == undefined); // Output: true

=== (Strict Equality): This operator checks for both value and type, hence null and undefined are not considered equal.

console.log(null === undefined); // Output: false

Practical Examples

Example 1: Function Parameters

When a function parameter is not provided, it is undefined by default.

function greet(name) {
  console.log("Hello, " + name);
}
greet(); // Output: "Hello, undefined"

Example 2: Object Properties

Accessing a non-existent property of an object returns undefined.

let person = { name: "Alice" };
console.log(person.age); // Output: undefined

Conclusion

There are similarities between `null` and `undefined`: both are falsy values and represent the absence of values in scripts. Cohort Relations: `undefined` defines a variable declared but yet to be initialized, `null` means the presence of the object has been intentionally left blank. This is good enough for now, because by properly handling these two special values the chances of bugs appearing in your application will be significantly less, and if they do appear, they are going to be easier to predict and debug. Remember, to start always declare your variables and use comparisons like strict equality, in order to get the expected results or behavior out of your code.

Frequently Asked Questions