A Comprehensive Guide to JavaScript Keywords

Keywords are special reserved words that carry out specific functions in the JavaScript language. Since they are built-in parts of the syntax, you cannot use keywords as identifiers or variable names. This comprehensive guide will explain the most essential JavaScript keywords developers should know.

Why JavaScript Keywords Matter

Keywords provide structure and functionality for JavaScript code. They allow you to give instructions like declaring variables, defining functions, creating loops, and making decisions. Without keywords like var, function, for, and if, your JavaScript would not do anything useful!

Learning the main keywords is therefore vital for properly controlling program flow and logic. As you gain mastery over keywords, you can translate ideas into executable actions within your scripts.

Declaration Keywords

Declaration keywords are used to create or initialize elements in JavaScript code, like variables and functions.

The `var` Keyword

The var keyword declares a variable in JavaScript:

var x = 10;

This statement creates a variable called x and assigns the number 10 as its value. You can later reassign x to something else.

Always use var when first declaring variables! Omitting it creates a global variable, which can cause problems.

The `function` Keyword

The function keyword defines a function in JavaScript:

function greetUser() {
  console.log("Hello!"); 
}

This function is called greetUser(). We can call it anytime using greetUser();.

Functions group reusable code into named blocks. The function keyword is how you define them in JavaScript.

The `class` Keyword

class allows you to create class-based objects with shared characteristics:

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

  greet() {
     console.log(`Hello, my name is ${this.name}!`)
  }
}

let person1 = new Person("John");
person1.greet(); // prints "Hello, my name is John!"

This Person class has a constructor method that gets called when we create new instances like person1. The class also has a reusable greet() method.

The `new` Keyword

We used new in the example above to create person1 from the Person class.

The new keyword:

Creates an empty object
Binds this to refer to it
Calls the constructor method on it

So new Person("John") creates a new object, makes this point to it inside Person, calls the Person constructor to initialize it, then finally returns the initialized object.

Loop Keywords

Loops allow you to repeat code execution. JavaScript has a few keywords to create different types of loops:

The `for` Loop

The for loop runs iteratively until a condition fails:

for (let i = 0; i < 5; i++) {
  console.log("Iteration ", i); 
}

This logs the value of i to the console 5 times (the counter stops when i hits 5).

For loops are ideal when you know exactly how many iterations you need.

The `while` Loop

A while loop runs while a condition remains truthy:

let i = 0;
while (i < 5) {
   console.log("Iteration ", i);
   i++; 
}

With while, the looping stops once i becomes 5.

Use while when you don‘t know exactly how many iterations you need beforehand.

The `do/while` Loop

The do/while loop is similar, but it runs at least once before checking the stop condition:

let i = 0;
do {
   console.log("Iteration ", i);
   i++;
} while (i < 5);

So here the code runs initially, then checks if i < 5 to decide whether to run again.

Conditional Keywords

Conditional keywords allow your code to make decisions and take different paths.

The `if/else` Statement

The if/else statement checks a condition and executes different code blocks based on the boolean result:

let temp = 15;

if (temp > 20) {
  console.log("It‘s hot outside!");
} else {
   console.log("It‘s pleasant today"); 
}

// Prints "It‘s pleasant today"

If temp > 20 evaluated to true, it would print "It‘s hot outside!" instead.

if/else statements let you execute certain code only when certain conditions are met.

The `switch` Statement

The switch keyword evaluates an expression and executes code in different case blocks based on possible matches:

let day = 2; // 1 = Monday, 7 = Sunday  

switch(day) {
  case 1:
    console.log("Monday");
    break;
  case 2:
    console.log("Tuesday"); 
    break;
  // ...
  default:
    console.log("Invalid Day");             
}

// Prints "Tuesday"

The day variable is matched against each case value. When 2 matches 2, that block runs. The default catch-all case runs if nothing else matches.

switch is useful for concise conditional chaining around a single value.

Jump Statewords

Jump statements let you alter control flow more abruptly:

`break`

The break keyword "jumps out" of the nearest loop or switch:

for (let i = 1; i <=5; i++) {
  if (i === 3) break; 
  console.log("Iteration ", i);
}

// Iteration 1 
// Iteration 2

Once i equals 3, break stops the loop entirely. This jumps us down to the code immediately after it.

`continue`

The continue statement skips the rest of the current loop iteration and goes to the next one:

for (let i = 1; i <=5; i++) {
  if (i === 3) continue;
  console.log("Iteration ", i); 
}

// Iteration 1  
// Iteration 2
// Iteration 4
// Iteration 5

Now iteration 3 is skipped, but the loop itself does not terminate.

`return`

In a function, return x exits immediately and returns value x from that function:

function add(a, b) {
  if (typeof a !== "number") {
    return "Error: a must be a number"; // early return 
  }

  return a + b; 
}

add(10, 32); // 42
add("hi"); // "Error: a must be a number"

So return exits and also sends back data to the caller.

Miscellaneous Keywords

Here are a few other noteworthy keywords:

`delete`

The delete operator removes a property from an object:

let person = {
  name: "John",
  age: 20 
};

delete person.age; 

console.log(person); // {name: "John"}

Now the person object no longer has an age property!

`instanceof`

The instanceof operator checks if an object was constructed from a certain class:

let dog = new Animal(); 

dog instanceof Animal; // true
dog instanceof Array; // false

This allows you to determine the type of an object at runtime.

`typeof`

The typeof operator gives back a string indicating the type of a value:

typeof 42; // "number" 
typeof "hi"; // "string"
typeof true; // "boolean" 
typeof undefined; // "undefined"

This is useful for debugging or conditional checks (like in add() earlier).

Putting JavaScript Keywords to Work

Core keywords like var, function, if, for, and return form the backbone of most JavaScript programs. Mastering these keywords empowers you to translate ideas into code.

Keywords handle variable declarations, function definitions, loops, conditionals and more. Understanding them unlocks the ability to control flow and leverage the full JavaScript language.

I hope this guide gave you a solid high-level view of the most essential keywords! Let me know if you have any other questions.

Why JavaScript Keywords Matter

Declaration Keywords

The var Keyword

The function Keyword

The class Keyword

The new Keyword

Loop Keywords

The for Loop

The while Loop

The do/while Loop

Conditional Keywords

The if/else Statement

The switch Statement

Jump Statewords

break

continue

return