Features of JavaScript

Analogy categoryAnalogies

1. Introduction

JavaScript combines several language design choices that make it flexible, approachable for beginners, and powerful enough for large-scale applications. These features include dynamic typing, first-class functions, prototype-based object orientation, and built-in support for asynchronous programming.

🏏

Cricket analogy: Like a versatile all-rounder who can bat, bowl, or field depending on the match situation (dynamic typing), pass strategy notes between teammates (first-class functions), inherit technique from a senior mentor (prototypes), and adapt to DRS delays without stopping play (async), JavaScript's features work together.

Knowing these core features up front helps explain many patterns you will encounter later, such as closures, callbacks, and promise chains, because they all build on the same underlying language characteristics.

🏏

Cricket analogy: Understanding basic footwork and grip early on is what later makes advanced shots like the reverse sweep or switch hit make sense -- likewise, grasping JS's core features first makes closures and promise chains click.

2. Syntax

javascript

// Dynamic typing
let value = 42;
value = "now a string";

// First-class functions
const add = function (a, b) { return a + b; };

// Prototype-based objects
function Animal(name) { this.name = name; }
Animal.prototype.speak = function () {
  return `${this.name} makes a sound.`;
};

// Asynchronous support
async function fetchData() {
  return "data loaded";
}

3. Explanation

Dynamic typing means variables are not bound to a fixed type; the same variable can hold a number, then later a string. First-class functions mean functions can be stored in variables, passed as arguments, and returned from other functions, enabling patterns like callbacks and higher-order functions. Prototypal inheritance means objects inherit directly from other objects via a prototype chain, rather than from rigid class blueprints (even though the 'class' keyword exists, it is syntactic sugar over prototypes).

🏏

Cricket analogy: A batter who starts an innings anchoring but later switches to aggressive strokeplay shows dynamic typing; a captain handing the ball to different bowlers mid-over shows first-class functions; a young player copying a senior's technique directly rather than a rigid textbook shows prototypal inheritance.

JavaScript is also single-threaded but non-blocking: it uses an event loop, callback queue, and microtask queue to handle asynchronous work like timers, network requests, and file I/O (in Node.js) without freezing the main thread.

🏏

Cricket analogy: The ground has only one pitch in use at a time (single-threaded), yet the match doesn't freeze while the groundskeeper reviews weather radar or the physio treats an injury off-field -- those results queue up and rejoin play without stopping the over.

A common gotcha: the JavaScript that runs in a browser and the JavaScript that runs in Node.js share the same ECMAScript core language, but their built-in APIs differ. Browsers provide the DOM, window, and fetch; Node.js provides modules like fs and http instead. Code using browser-only or Node-only APIs will not run in the other environment without adaptation.

4. Example

javascript

function Animal(name) {
  this.name = name;
}
Animal.prototype.speak = function () {
  return `${this.name} makes a sound.`;
};

const dog = new Animal("Rex");
console.log(dog.speak());

let mixed = 10;
console.log(typeof mixed);
mixed = "ten";
console.log(typeof mixed);

const double = (n) => n * 2;
console.log([1, 2, 3].map(double));

5. Output

text

Rex makes a sound.
number
string
[ 2, 4, 6 ]

6. Key Takeaways

JavaScript is dynamically typed, so a variable's type can change as new values are assigned.
Functions are first-class citizens: they can be assigned to variables, passed as arguments, and returned.
Object inheritance in JavaScript is prototype-based, even when using the 'class' syntax.
JavaScript is single-threaded but handles concurrency via the event loop and asynchronous APIs.
Browser and Node.js environments share the core language but expose different built-in APIs.
JavaScript is interpreted/JIT-compiled, so code runs without a separate manual compilation step.

Practice what you learned

1. What does it mean that JavaScript functions are 'first-class citizens'?

2. JavaScript's object inheritance model is best described as:

3. How does JavaScript handle asynchronous operations despite being single-threaded?

4. Which statement about browser vs. Node.js JavaScript is accurate?

5. What happens in this code: let x = 5; x = "five";?

Was this page helpful?

History and Evolution of JavaScript

Setting Up a JavaScript Environment

Related Study Notes in Programming

Browse all study notes

Programming

Apache Spark Study Notes

Programming · 30 topics

Programming

Apache Flink Study Notes

Programming · 30 topics

Programming

Hadoop Study Notes

Programming · 30 topics

Programming

Snowflake Study Notes

Programming · 30 topics

Programming

Apache Airflow Study Notes

Programming · 30 topics

Programming

dbt (Data Build Tool) Study Notes

Programming · 30 topics

Topics covered

#JavaScript#JavaScriptProgrammingStudyNotes#Programming#FeaturesOfJavaScript#Features#Syntax#Explanation#Example#StudyNotes#SkillVeris

1. Introduction

2. Syntax

3. Explanation

4. Example

5. Output

6. Key Takeaways

Practice what you learned

You May Also Like

Related Reading

Related Study Notes in Programming

Topics covered