Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://www.geeksforgeeks.org/javascript/introduction-to-es6/ below:

Introduction to ES6 - GeeksforGeeks

Last Updated : 05 Aug, 2025

ES6, or ECMAScript 2015, is the 6th version of the ECMAScript programming language. ECMAScript is the standardization of JavaScript, which was released in 2015 and subsequently renamed as ECMAScript 2015.

The let variables are mutable, i.e., their values can be changed. It works similarly to the var keyword with some key differences, like scoping, which makes it a better option when compared to var.

let n = 10;
{
    let n = 2; // Block-scoped variable
    console.log(n);
}
console.log(n);

It prevents variable leakage outside of the intended scope.

const is used to declare variables with a constant value, ensuring the value cannot be reassigned.

const PI = 3.14159;
PI = 3; // Error: Assignment to constant variable

Ideal for declaring configuration constants or fixed values.

Arrow functions provide a concise syntax for writing function expressions and automatically bind this to the surrounding context.

// Traditional function
function add(a, b) { return a + b; }

// Arrow function
const add = (a, b) => a + b;

• Implicit return for single-expression functions.
• Do not have their own 'this' context.

Destructing in JavaScript basically means the breaking down of a complex structure(Objects or arrays) into simpler parts

Object Destructuring

const obj = {
    name : "Raj",
    age : 25
};
const {name, age} = obj;
console.log(name, age);

Array Destructuring

const a = [ "red", "blue", "green" ];
const [first, second] = a;
console.log(first, second);

The spread operator expands an array or object into individual elements or properties.

const n1 = [ 1, 2, 3 ];
const n2 = [...n1, 4, 5 ];
console.log(n2);

The for/of loop allows you to iterate over iterable objects like arrays, strings, Maps, and Sets but in a short syntax as compared to other loops.

Iterating Over an Array

const a = [ "apple", "banana", "cherry" ];
for (const fruit of a) {
    console.log(fruit);
}

apple
banana
cherry

Iterating Over a String

const s = "hello";
for (const char of s) {
    console.log(char);
}

Map: Maps store key-value pairs where keys can be any data type.

const map = new Map();
map.set("a", 1);
map.set("b", 2);
console.log(map.get("a"));

Set: Sets store unique values of any type.

const set = new Set([ 1, 2, 3, 3 ]);
console.log(set);

Set(3) { 1, 2, 3 }

ES6 introduced classes in JavaScript. Classes in javascript can be used to create new Objects with the help of a constructor, each class can only have one constructor inside it.

class Animal {
    speak() { console.log("The animal makes a sound"); }
}

const dog = new Animal();
dog.speak();

The animal makes a sound

• class Animal {}: Defines a simple class named Animal.
• speak(): A method inside the class that logs a message to the console.
• new Animal(): Creates an object dog from the Animal class.
• dog.speak(): Calls the speak method on the dog object.

Promises simplify handling asynchronous operations by providing .then and .catch methods.

const fetch = () => {
    return new Promise((resolve, reject) => {
        setTimeout(() => resolve("Data fetched"), 2000);
    });
};

fetch().then(data => console.log(data));

Allows functions to have default values for parameters.

function greet(name = "Guest") { return `Hello, ${name}!`; }
console.log(greet());

• includes(): Check if a string contains a substring.
• startsWith(): Check if a string starts with a substring.
• endsWith(): Check if a string ends with a substring.
• find(): Locate the first element matching a condition.
• findIndex(): Locate the index of the first element matching a condition.
• from(): Convert an iterable or array-like object into an array.
• Template Literals: Simplify string concatenation and allow embedded expressions.
• Modules: Introduce import and export for better modularity.
• Rest Parameters (...args): Allow functions to accept an indefinite number of arguments as an array.
• Generators and Iterators: Enable custom iteration logic with function* and yield.
• Binary and Octal Literals: Simplify working with binary (0b) and octal (0o) numbers.
• Enhanced Object Literals: Provide shorthand for methods, properties, and dynamic keys.
• WeakMap and WeakSet: Store weakly-referenced objects for specialized use cases.
• Proxy and Reflect: Add interception capabilities and reflection utilities for objects.
• Symbol: Introduces unique, immutable primitive data types useful for property keys.
• Block-scoped Functions: Functions declared inside blocks respect block scope.

ES6 is fully supported in all modern browsers since June 2017:

Chrome
51

Edge
15

Firefox
54

Safari
10

Opera
38

May 2016

Apr 2017

Jun 2017

Sep 2016

Jun 2016

Note: ES6 is not supported in Internet Explorer.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4