ECMAScript 2015 (ES6) represents a foundational shift in JavaScript, introducing structural patterns and syntactic improvements that streamline modern application development. By standardizing common developer workflows, it enhances code maintainability, reduces boilerplate, and provides native tools for modular architecture across client and server environments.

Block Scoping and Declarations

The transition from var to let and const eliminates function-scope leakage and establishes predictable block-level boundaries. const creates a read-only reference to a value, preventing accidental reassignment while allowing mutation of object properties. let supports reassignment but remains strictly confined to its containing block, loop, or conditional structure.

const MAX_ATTEMPTS = 5;
let retryCount = 0;

const pipelineTasks = ['validate', 'transform', 'publish'];
for (const stage of pipelineTasks) {
  console.log(`Executing phase: ${stage}`);
  if (retryCount < MAX_ATTEMPTS) {
    retryCount++;
  }
}

Modern Function Definitions

Arrow functions provide a concise syntax and lexically capture the this context from the surrounding scope, removing the need for traditional binding workarounds. ES2015 also introduces default parameter values, rest parameters for varible-length arguments, and the spread operator for array expansion.

const computeTotal = (base, taxRate = 0.09) => base + (base * taxRate);

const mergeArrays = (...collections) => [].concat(...collections);

console.log(mergeArrays([1, 2], [3, 4])); // [1, 2, 3, 4]

Template Literals and Destructuring

Backticks enable multi-line string construction and inline expression evaluation via ${}. Destructuring assignment extracts nested data from objects and arrays into standalone variables, drastically reducing accessor chains and improving readability.

const serverConfig = {
  host: 'localhost',
  ports: [8080, 8443],
  auth: { type: 'OAuth2', tokenExpiry: 3600 }
};

const { host, ports: [primaryPort], auth: { type } } = serverConfig;
const connectionStr = `Connecting to ${host}:${primaryPort} using ${type}`;

Enhanced Objects and Classes

Object literals now support method shorthand, dynamic property keys computed at runtime, and direct prototype assignment. The class keyword offers a declarative syntax for constructor functions, supporting inheritance via extends, super-constructor calls, and accessor properties.

class BaseProcessor {
  constructor(id, priority) {
    this.id = id;
    this.priority = priority;
  }
  execute() {
    return `Processing ${this.id} at level ${this.priority}`;
  }
}

class PriorityQueue extends BaseProcessor {
  constructor(id, priority, capacity) {
    super(id, priority);
    this.capacity = capacity;
  }
  get isFull() {
    return this.currentLoad >= this.capacity;
  }
}

const worker = new PriorityQueue('node-1', 'high', 100);
console.log(worker.execute());

Structured Collections: Set and Map

Set manages unique values and provides efficient membership testing. Map stores ordered key-value pairs where keys can be of any data type, preserving insertion order and offering explicit size tracking. Both integrate seamlessly with for...of iteration.

const registeredDevices = new Set(['deviceA', 'deviceB', 'deviceC']);
registeredDevices.add('deviceA'); // Ignored

const telemetryCache = new Map();
telemetryCache.set('temp_01', { value: 22.5, status: 'nominal' });
telemetryCache.set('temp_02', { value: 24.1, status: 'nominal' });

for (const [sensorId, reading] of telemetryCache) {
  console.log(`Sensor ${sensorId}: ${reading.value}°C`);
}

Asynchronous Control with Promises

Promise objects replace deeply nested callbacks with a state machine representing asynchronous operations: Pending, Fulfilled, or Rejected. Chaining via .then() and .catch() creates linear execution flows. Static methods like Promise.all() and Promise.race() manage parallel execution and conditional completion.

const fetchReport = (reportId) => new Promise((resolve, reject) => {
  setTimeout(() => {
    if (reportId.startsWith('RPT')) {
      resolve({ id: reportId, generatedAt: Date.now() });
    } else {
      reject(new Error('Malformed Report ID'));
    }
  }, 50);
});

Promise.all([fetchReport('RPT-101'), fetchReport('RPT-102')])
  .then(batch => console.log('Batch ready:', batch))
  .catch(error => console.error('Generation failed:', error.message));

Native Module System

ES2015 formalizes dependency management through static import and export declarations. Modules support named exports, default exports, and aliasing to prevent naming collisions. This architecture enables static analysis, tree-shaking, and strict encapsulation of public interfaces.

// auth.js
export const validateToken = (token) => token.length > 0;
export default class SessionManager {
  /* implementation */
}

// main.js
import SessionManager, { validateToken } from './auth';

Symbol Type and Well-Known Symbols

Symbols generate primitive values guaranteed to be unique across the runtime. They serve as ideal identifiers for hidden object properties, preventing accidental overwrites. Well-known symbols like Symbol.iterator, Symbol.hasInstance, and Symbol.toStringTag expose internal language behaviors, allowing developers to customize iteration, type checking, and string conversion logic.

const INTERNAL_KEY = Symbol('internalState');
const systemObj = { publicFlag: true };
systemObj[INTERNAL_KEY] = { version: '2.0', flags: ['beta'] };

console.log(Object.keys(systemObj)); // ['publicFlag']
console.log(systemObj[INTERNAL_KEY].flags); // ['beta']