Note

JavaScript was created by Brendan Eich at Netscape in 1995. Though initially rushed, it survived to become a cornerstone of the modern web, maturing with the ECMAScript 6 (ES6) standard into an elegant, multi-paradigm language. This summary covers its fundamental concepts, from variables and scope to its powerful implementation of functions and classes.

Fundamental Concepts

JavaScript's core is built on a few essential concepts that govern how code is written and executed.

Variables: `let` vs. `const`

Variables are declared using let for mutable (changeable) values and const for immutable variables, whose values cannot be reassigned after their initial declaration. It is recommended to use let and const over the older var keyword.

Expressions vs. Statements

An expression is any code that evaluates to a value (e.g., 1 + 1 evaluates to 2). A statement performs an action and evaluates to undefined, such as a variable declaration or a code block defined with {}. Statements must have a side effect to be useful.

Types and Scope

JavaScript has primitive types like number, string, and boolean. It is loosely typed, meaning a variable's type can change during execution. A variable's scope is the region where it is visible, which can be limited by declaring it inside a code block {...}.

---

The Power of Functions in JavaScript

Functions in JavaScript are first-class objects, leading to a progression of powerful concepts and patterns.

Basic Declaration & Purity

Functions are declared with the function keyword and can use control flow like if-else, while, and for. Recursive functions written in a declarative style can be pure , exhibiting referential transparency by avoiding side effects.

Step 1

First-Class Citizens

Functions are objects, meaning they can be bound to variables and passed around just like any other value.

Step 2

Anonymous & Arrow Functions

Functions can be defined without a name (anonymous functions ). ES6 introduced compact arrow syntax (=>), which is ideal for passing functions as parameters to higher-order functions like array.map().

Step 3

Closures & Currying

A closure is a function that captures variables from its enclosing scope, allowing those variables to persist. This enables patterns like currying , where a function taking multiple arguments is transformed into a sequence of functions that each take one argument.

Step 4

---

Working with Data Structures

JavaScript provides flexible ways to work with collections of data using arrays and objects.

Objects & Classes

• In JavaScript, objects are essentially property bags indexed by a hashtable. When an object is declared with const, the reference is immutable, but the object's properties remain mutable (weakly immutable ). ES6 introduced a class syntax that is more familiar to Java or Python programmers, supporting constructors, methods, getters, and single inheritance.

Arrays & Methods

• JavaScript arrays have a simple literal syntax ([1, 2, 3]) and come with powerful, pure methods for data transformation. Key Methods:
  • map(f): Applies function f to each element, returning a new array.
  • filter(f): Returns a new array containing only elements for which predicate f returns true.
  • reduce(f, initial): Applies function f to combine all elements into a single aggregated value.

Polymorphism & Dependency Injection

• JavaScript supports subtyping polymorphism through classes and inheritance. It also allows for informal polymorphism known as “Duck Typing”. This can be contrasted with a more functional approach, dependency injection, where behavior is customized by passing functions into an object's constructor. Many modern languages also support parametric polymorphism for creating generic, type-safe code.

Changelog

8/8/25, 4:17 AM

View All Changelog

• 2aa48-web-deploy(Auto): Update base URL for web-pages branchon 8/8/25

Copyright

Copyright Ownership:WARREN Y.F. LONG

License under:Attribution-NonCommercial-NoDerivatives 4.0 International (CC-BY-NC-ND-4.0)