JavaScript Features

Introduction

Let's look at the key features that make JavaScript different from other programming languages. These are the things you'll keep running into as you learn, so it helps to get a quick overview now.

Note: If some of these concepts feel unfamiliar, don't worry. We'll explain each one in detail as we go through the course. Feel free to revisit this page anytime.

High Level Language

JavaScript is a high-level language, which means its code reads almost like English. You don't have to worry about hardware details like memory addresses or CPU instructions.

Other high-level languages include Python, Java, and C#. They all share this beginner-friendly trait of being easy to read and write.

JavaScript

Java

Python

Garbage Collected

When your JavaScript code runs, it uses memory. Sometimes, it creates things that are no longer needed. Garbage collection is JavaScript's way of automatically cleaning up that unused memory.

Think of it like a self-cleaning kitchen. You cook (write code), and the leftovers (unused memory) get cleaned up for you. You never have to manually free memory in JavaScript, which saves you from a whole category of bugs called memory leaks.

Interpreted Language (Just In Time Compilation)

JavaScript doesn't need to be compiled (translated into machine code) before running. Instead, it's read and executed line by line by engines like V8 (Chrome), SpiderMonkey (Firefox), or Chakra (Edge).

To make things faster, these engines use Just-In-Time (JIT) compilation. Right before a piece of code runs, it gets translated into machine code on the fly. This gives JavaScript the flexibility of an interpreted language with near-compiled speed.

Multi Paradigm

JavaScript supports multiple programming styles (called "paradigms"). You're not locked into one way of writing code.

You can write event-driven code ("when this button is clicked, do this"), object-oriented code (organizing code into reusable objects), or functional code (using small, reusable functions). This flexibility is one of JavaScript's biggest strengths.

Prototype Based Function

In JavaScript, objects can inherit properties and behaviors from other objects through something called a prototype. Think of a prototype as a template that an object can look up to.

Every object has a hidden link to its prototype (accessed via __proto__). When you try to use a property that doesn't exist on an object, JavaScript automatically checks its prototype, then that prototype's prototype, and so on. This chain is called "prototype-based inheritance." We'll cover this in detail later.

First Class Function

In JavaScript, functions are treated like any other value. You can store a function in a variable, pass it as an argument, or return it from another function. This is what "first-class functions" means.

This makes powerful patterns possible, like higher-order functions and closures. Don't worry about those terms yet. We'll explore them in detail in the functions tutorial.

javascript

// Define a function
function greet(name) {
  return "Hello, " + name + "!";
}

// Assign the function to a variable
var myFunction = greet;

// Call the function using the variable
var result = myFunction("John");

// Output the result
console.log(result);

Dynamically Typed

In JavaScript, you don't have to declare what type a variable is. A variable can hold a number now and a string later. The type is determined while the program runs, not when you write the code. This is called dynamic typing.

In languages like Java or C, once you say a variable is a number, it's always a number. In JavaScript, the same variable can change types freely. This gives you flexibility, but it also means you need to be careful about unexpected type changes.

javascript

let x = 10; // type will be number 
x = "SimplyJavascript"; //type will be string 
x = false; //type will be boolean

Single Threaded

JavaScript is single-threaded, which means it does one thing at a time. Think of it as a single-lane road: only one car moves at any moment.

This is different from multi-threaded languages where multiple tasks run at the same time. But what happens when JavaScript gets a slow task? It uses Web Workers and asynchronous programming to handle heavy work in the background, so the main thread doesn't get blocked.

Non-Blocking Event Loop

Even though JavaScript is single-threaded, it doesn't freeze when it encounters a slow task (like fetching data from a server). This is thanks to the event loop.

The event loop works like a queue system. When a slow task comes in, JavaScript puts it aside and keeps running other code. When the slow task finishes, its result goes back into the queue, and the event loop picks it up. This is called "asynchronous programming", and it's what makes JavaScript feel fast and responsive.

Platform Independent

JavaScript runs inside web browsers, and browsers exist on every platform: Windows, Mac, Linux, Android, iOS. That means your JavaScript code works everywhere without changes. Write it once, and it runs on any device that has a browser.

Summary

High-level: Reads like English. No need to manage hardware details.
Garbage collected: Automatically frees unused memory for you.
Interpreted with JIT: Code runs line by line, but gets optimized into machine code on the fly for speed.
Multi-paradigm: Supports object-oriented, functional, and event-driven coding styles.
Prototype-based: Objects can inherit from other objects through a prototype chain.
First-class functions: Functions can be stored in variables, passed around, and returned like any other value.
Dynamically typed: Variables can change type at runtime. Flexible but requires care.
Single-threaded: Does one thing at a time, but uses async tools to avoid blocking.
Non-blocking event loop: Keeps the program responsive by handling slow tasks in the background.
Platform independent: Runs on any device with a browser.

What's next? Now that you know what makes JavaScript special, let's start writing actual code in the next tutorial.