Reserved Words in JavaScript

JavaScript, the language that animates web pages and brings them to life, has a well-defined set of reserved words. These words have special meanings within the language and cannot be used for your own variables, functions, or other identifiers. Understanding these reserved words is crucial for writing clean, functional, and error-free JavaScript code.

What are Reserved Words?

Reserved words are keywords pre-defined by JavaScript with specific purposes.
They act as the building blocks of the language, providing essential functionality for control flow, data types, and more.
Using a reserved word as a variable name or function name will result in a syntax error, preventing your code from running correctly.

Core Reserved Words

Here’s a breakdown of some fundamental reserved words in JavaScript:

Data Types:

boolean: Represents true or false values.

				
					let isLoggedIn = true; // Valid

number: Represents numerical values (integers, decimals).

				
					let age = 25; // Valid

string: Represents textual data enclosed in quotes.

				
					let name = "Alice"; // Valid

Control Flow:

if, else, else if: Used for conditional execution based on boolean expressions.

				
					if (age >= 18) {
  console.log("You are eligible to vote");
} else {
  console.log("You are not eligible to vote");
}

for, while: Used for looping through code blocks repeatedly based on conditions.

				
					for (let i = 0; i < 5; i++) {
  console.log(i); // Output: 0, 1, 2, 3, 4
}

break: Used to exit a loop prematurely.
continue: Used to skip to the next iteration of a loop.

Functions:

function: Used to define reusable blocks of code.

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

return: Used to return a value from a function.

number: Represents numerical values (integers, decimals).

				
					let age = 25; // Valid

Statements

var, let, const: Used for variable declaration. While var is the older approach, let and const are generally preferred due to better scoping and block-level declarations

				
					var, let, const: Used for variable declaration. While var is the older approach, let and const are generally preferred due to better scoping and block-level declarations

this: Refers to the current object context within a function.

Others

in, instanceof: Used for type checking and property existence checks.
delete: Used to delete properties from objects.

Advanced Reserved Words (ECMAScript 6 and beyond)

Newer versions of JavaScript (ECMAScript 6+) have introduced additional reserved words:

class: Used for defining object-oriented classes.

				
					class Person {
  constructor(name) {
    this.name = name;
  }

  greet() {
    console.log("Hello, my name is " + this.name);
  }
}

const person1 = new Person("John");
person1.greet(); // Output: Hello, my name is John

extends: Used for inheritance between classes.
super: Used to call methods from a parent class within a child class.
yield: Used for defining generator functions that can pause and resume execution. (More advanced topic)
async, await: Used for asynchronous programming with promises. (More advanced topic)

Future-Proofing with Reserved Words

While the core set of reserved words is unlikely to change drastically, staying updated with the latest JavaScript standards can help you avoid potential conflicts. It’s a good practice to check the official ECMAScript documentation for any additions or changes to the reserved words list.

Reserved Word Table

Reserved Word	Description	Introduced in
break	Exits a loop prematurely.	Core
case	Used within switch statements for conditional branching.	Core
catch	Used for handling exceptions in try...catch blocks.	Core
class	Defines object-oriented classes (ES6+).	ES6
const	Declares constant variables (ES6+).	ES6
continue	Skips to the next iteration of a loop.	Core
debugger	Used for debugging purposes (triggers a breakpoint in development tools).	Core
default	Used within switch statements as the default case.	Core
delete	Deletes a property from an object.	Core
do	Used with while for loop constructs.	Core
else	Used for alternative execution paths in conditional statements.	Core
enum	Defines enumerated data types (not recommended in modern JavaScript).	Core (but discouraged)
export	Used for exporting modules (ES6+).	ES6
extends	Used for inheritance between classes (ES6+).	ES6
	Boolean value representing false.	Core
finally	Used in try...catch blocks to execute code regardless of exceptions (ES6+).	ES6
for	Used for looping through a block of code.	Core
function	Defines reusable blocks of code.	Core
if	Used for conditional execution.	Core
import	Used for importing modules (ES6+).	ES6
in	Checks if a property exists in an object.	Core
instanceof	Checks if an object is an instance of a class (ES6+).	ES6
interface	Defines the structure of an object (not directly used in JavaScript, but a future keyword).	Future
let	Declares block-scoped variables (ES6+).	ES6
null	Represents the absence of a value.	Core
package	(Not used in browser JavaScript, reserved for future use in module systems).	Future
private	Defines private members within classes (not directly used in JavaScript, but a future keyword).	Future
protected	Defines protected members within classes (not directly used in JavaScript, but a future keyword).	Future
public	Defines public members within classes (not directly used in JavaScript, but a future keyword).	Future
return	Exits a function and optionally returns a value.	Core
static	Defines static methods and properties within classes (ES6+).	ES6
super	Used to call methods from a parent class within a child class (ES6+).	ES6
switch	Used for multi-way conditional branching.	Core
this	Refers to the current object context within a function.	Core
throw	Throws an exception to signal an error.	Core
1	Boolean value representing true.	Core
try	Used for code that might throw exceptions (ES6+).	ES6
typeof	Returns the data type of a value.	Core
var	Declares function-scoped variables (older approach, generally discouraged in favor of let and const).	Core
void	(The unary operator void has a special meaning, but the keyword itself is reserved and cannot be used as an identifier).	Core
while	Used for looping as long as a condition is true.	Core
with	Used with caution due to scoping issues (generally discouraged).	Core
yield	Used for defining generator functions that can pause and resume execution (ES6+).	ES6
async	Used for asynchronous programming with promises (ES6+).	ES6
await	Used within async functions to wait for asynchronous operations (ES6+).	ES6

Understanding reserved words forms the foundation for writing clean and maintainable JavaScript code. By familiarizing yourself with these keywords, you can leverage their built-in functionality to create efficient and robust applications. Remember, using a reserved Happy coding !❤️