Top 30 Most Common Es6 Interview Questions You Should Prepare For

Preparing for a technical interview can be a daunting task, especially when it comes to modern JavaScript. ECMAScript 2015, commonly known as ES6, introduced a wealth of new features that significantly changed how developers write JavaScript. Understanding these features is crucial for demonstrating your proficiency in modern web development. Interviewers frequently ask es6 interview questions to gauge your familiarity with the latest standards and practices. Whether you are a junior developer or a seasoned engineer, a solid grasp of ES6 concepts will set you apart. This guide covers 30 of the most common es6 interview questions you are likely to encounter, providing concise, answer-ready explanations.

What Are es6 interview questions?

es6 interview questions focus on your knowledge and practical application of features introduced in ECMAScript 2015. This version of JavaScript brought significant enhancements, including new syntax for variable declaration (let, const), function definition (arrow functions), object-oriented programming (classes), handling asynchronous code (Promises), and managing code structure (modules). These es6 interview questions aim to test your understanding of core concepts like block scoping, lexical this binding, syntactic sugar for classes, string manipulation with template literals, data handling with destructuring, and efficient iteration methods. Proficiency in these areas indicates that you can write cleaner, more maintainable, and more efficient JavaScript code, aligning with modern development standards.

Why Do Interviewers Ask es6 interview questions?

Interviewers ask es6 interview questions for several key reasons. First, ES6 is the baseline for most modern JavaScript development. Companies want to hire candidates who can immediately contribute to projects using current language features, rather than relying solely on older syntax and patterns. Secondly, many ES6 features address common JavaScript pitfalls, such as variable hoisting issues with var or convoluted this binding. Demonstrating knowledge of let, const, and arrow functions shows you understand these problems and know how to avoid them. Finally, features like Promises, async/await, and modules are essential for building scalable and performant applications. Your ability to discuss and implement these features effectively is a strong indicator of your skill level and readiness for complex tasks. Preparing for es6 interview questions is therefore essential for any JavaScript developer aiming for a new role.

Preview List

1. What is ES6?

2. What are the key features introduced in ES6?

3. Explain the difference between var, let, and const.

4. Write a function using arrow syntax that takes two numbers and returns their sum.

5. Explain arrow functions in ES6.

6. What is a template literal? Provide an example.

7. Explain tagged template literals and their use cases.

8. Explain destructuring assignment with examples for arrays and objects.

9. How do default parameters work in ES6? Provide an example.

10. What are rest parameters and how do they differ from the arguments object?

11. Write a simple class in ES6 that represents a Car.

12. What is the purpose of the super keyword in ES6 classes?

13. Explain the concept of modules in ES6. How do you export and import?

14. What is the Promise object in ES6? Write a simple example.

15. Explain the difference between synchronous and asynchronous programming in JavaScript.

16. Write a function that returns a promise and resolves after 2 seconds.

17. What is the Temporal Dead Zone?

18. What is an IIFE (Immediately Invoked Function Expression)?

19. Explain hoisting in JavaScript.

20. What are closures?

21. What is memoization?

22. What is a service worker?

23. What are Iterators and Generators in ES6?

24. Explain Symbols in ES6.

25. What are Maps and Sets in ES6? How do they differ from objects and arrays?

26. Describe the Spread and Rest operators in ES6.

27. How does async/await work with Promises in ES6+?

28. What are enhanced object literals in ES6?

29. What is the difference between export default and named export?

30. Explain for...of loops in ES6.

1. What is ES6?

Why you might get asked this:

This is a foundational question to check if you know what ES6 refers to and its significance in JavaScript history. It sets the context for more specific es6 interview questions.

How to answer:

Define ES6 by its full name (ECMAScript 2015) and explain that it was a major update to the JavaScript standard, introducing many new features.

Example answer:

ES6 is the sixth edition of the ECMAScript standard, officially released in June 2015. It's a major update to JavaScript that includes numerous new features like arrow functions, classes, modules, promises, let/const, and destructuring, making the language more powerful and easier to use.

2. What are the key features introduced in ES6?

Why you might get asked this:

Interviewers use this to gauge your overall awareness of the breadth of ES6 changes beyond just one or two features. Essential for es6 interview questions.

How to answer:

List several of the most prominent features like let/const, arrow functions, classes, template literals, destructuring, promises, and modules.

Example answer:

Key ES6 features include let and const for block-scoped variables, arrow functions with lexical this, classes for OOP, template literals for easy string formatting, destructuring for object/array unpacking, default/rest parameters, Promises for async operations, and modules for code organization.

3. Explain the difference between var, let, and const.

Why you might get asked this:

This is a fundamental ES6 concept testing your understanding of scoping and mutability, critical for writing modern JavaScript. A very common es6 interview question.

How to answer:

Focus on scope (var is function/global, let/const are block-scoped) and mutability (var/let can be reassigned, const cannot be reassignsd). Mention hoisting differences implicitly.

Example answer:

var is function-scoped or globally-scoped and can be redeclared and reassigned. let is block-scoped and can be reassigned but not redeclared in the same scope. const is also block-scoped and cannot be reassigned or redeclared; its binding is constant.

4. Write a function using arrow syntax that takes two numbers and returns their sum.

Why you might get asked this:

Tests your basic knowledge of arrow function syntax, a cornerstone of modern JavaScript code style and a frequent element in es6 interview questions.

How to answer:

Use the concise arrow function syntax, especially the implicit return for a single expression.

Example answer:

const sum = (a, b) => a + b;
// Example usage:
// console.log(sum(5, 3)); // Output: 8

5. Explain arrow functions in ES6.

Why you might get asked this:

Beyond syntax, this question probes your understanding of arrow functions' key benefit: how they handle this. Vital for understanding es6 interview questions on scope.

How to answer:

Describe their concise syntax and, crucially, explain that they do not have their own this binding; they lexically bind this from the enclosing scope.

Example answer:

Arrow functions provide a shorter syntax for writing function expressions. Unlike traditional functions, they do not create their own this context. Instead, this inside an arrow function refers to the this value in the surrounding lexical scope, making them great for callbacks and methods where you want to preserve the parent's this.

6. What is a template literal? Provide an example.

Why you might get asked this:

Evaluates your knowledge of modern string handling, which significantly improves readability over traditional concatenation. Common in es6 interview questions.

How to answer:

Explain that template literals use backticks ( ) and allow for embedded expressions (${expression}). Provide a simple example.

Example answer:

let name = "Alice";
let greeting = `Hello, ${name}!`; // greeting is "Hello, Alice!"

Template literals are string literals enclosed by backtick ( ) characters. They allow for multi-line strings and string interpolation, where you can embed expressions directly within the string using ${expression}.

7. Explain tagged template literals and their use cases.

Why you might get asked this:

A slightly more advanced topic showing deeper understanding of template literals' capabilities beyond simple interpolation. Good for probing advanced es6 interview questions.

How to answer:

Explain that a tag is a function placed before the template literal. The function receives the string parts and expression values separately, allowing for custom parsing or manipulation.

Example answer:

function highlight(strings, ...values) {
  let str = '';
  strings.forEach((string, i) => {
    str += string + (values[i] ? `<b>${values[i]}</b>` : '');
  });
  return str;
}
let greeting = highlight`Hello ${name}, you are ${age}.`; // 'Hello <b>Alice</b>, you are <b>30</b>.' (assuming name="Alice", age=30)

Tagged template literals are advanced forms of template literals. You place a function name (the "tag") before the backtick string. The tag function receives the string parts as an array and the expression values as individual arguments, enabling custom processing, like sanitization or internationalization.

8. Explain destructuring assignment with examples for arrays and objects.

Why you might get asked this:

Tests your ability to extract data from structures concisely, a common pattern in modern ES6 codebases. Relevant for data manipulation focused es6 interview questions.

How to answer:

Define destructuring as a way to unpack values from arrays or properties from objects into distinct variables using similar syntax to array and object literals. Provide examples for both.

Example answer:

// Array destructuring
const [a, b] = [1, 2]; // a is 1, b is 2

// Object destructuring
const { name, age } = { name: 'Bob', age: 25 }; // name is 'Bob', age is 25

Destructuring assignment allows you to unpack values from arrays or properties from objects into distinct variables using a syntax mirroring array and object literals.

9. How do default parameters work in ES6? Provide an example.

Why you might get asked this:

Evaluates your understanding of function parameter enhancements that simplify function signatures and reduce boilerplate for handling missing arguments.

How to answer:

Explain that you can assign a default value to a parameter directly in the function signature using the assignment operator (=).

Example answer:

function greet(name = 'Guest') {
  console.log(`Hello, ${name}!`);
}
greet();      // Output: Hello, Guest!
greet('Sara');  // Output: Hello, Sara!

Default parameters allow you to initialize parameters with default values if no value or undefined is passed during a function call.

10. What are rest parameters and how do they differ from the arguments object?

Why you might get asked this:

Tests your knowledge of modern function parameter handling, highlighting improvements over the older arguments object. Common in es6 interview questions about functions.

How to answer:

Explain that rest parameters (...variableName) collect all remaining arguments into an array. Differentiate from arguments, which is not a real array and includes all arguments, not just the "rest".

Example answer:

function sum(...numbers) {
  return numbers.reduce((total, num) => total + num, 0);
}
sum(1, 2, 3, 4); // Returns 10

Rest parameters (...) collect an indefinite number of arguments passed to a function into a single array. They are a cleaner alternative to the old arguments object, which is not a true array and contains all arguments regardless of position, making rest parameters easier to work with.

11. Write a simple class in ES6 that represents a Car.

Why you might get asked this:

Assesses your understanding of ES6's syntactic sugar for object-oriented programming, a significant addition. A key es6 interview question.

How to answer:

Define a class using the class keyword, include a constructor method, and add at least one other method.

Example answer:

class Car {
  constructor(make, model) {
    this.make = make;
    this.model = model;
  }
  displayDetails() {
    console.log(`Car: ${this.make} ${this.model}`);
  }
}
// Example usage:
// const myCar = new Car('Honda', 'Civic');
// myCar.displayDetails();

12. What is the purpose of the super keyword in ES6 classes? Provide an example.

Why you might get asked this:

Tests your knowledge of inheritance in ES6 classes and how to interact with the parent class. Important for OOP-related es6 interview questions.

How to answer:

Explain that super is used in a subclass to call the constructor of the parent class or to call methods defined on the parent class's prototype.

Example answer:

class ElectricCar extends Car {
  constructor(make, model, batterySize) {
    super(make, model); // Call Car's constructor
    this.batterySize = batterySize;
  }
  displayDetails() {
    super.displayDetails(); // Call Car's displayDetails method
    console.log(`Battery: ${this.batterySize} kWh`);
  }
}

The super keyword is used within a subclass. When used in the constructor, it calls the parent class's constructor to initialize inherited properties. When used in other methods, it calls the corresponding method on the parent class's prototype.

13. Explain the concept of modules in ES6. How do you export and import?

Why you might get asked this:

Evaluates your understanding of how ES6 addresses code organization and reusability, moving away from older module patterns. Crucial for modern development.

How to answer:

Describe modules as reusable code units. Explain the export keyword for making code available from a module and the import keyword for accessing exported code.

Example answer:

ES6 modules allow you to break code into separate files (modules) that can export values (functions, variables, classes) and import values from other modules. export makes something available outside the file, and import brings something into the current file from another module. This promotes code organization and reusability.

// file: math.js
export function add(a, b) { return a + b; }
export const PI = 3.14;

// file: main.js
import { add, PI } from './math.js';
let result = add(10, 5); // result is 15
console.log(PI); // Output: 3.14

14. What is the Promise object in ES6? Write a simple example.

Why you might get asked this:

A core question on handling asynchronous operations in a more structured way than callbacks. Fundamental for many es6 interview questions.

How to answer:

Define Promise as an object representing the eventual completion (or failure) of an asynchronous operation and its resulting value. Explain its states (pending, fulfilled, rejected) and basic usage with .then() and .catch().

Example answer:

const myPromise = new Promise((resolve, reject) => {
  // Simulate an async operation
  setTimeout(() => {
    resolve('Operation successful!');
    // or reject('Operation failed!');
  }, 1000);
});

myPromise.then((result) => {
  console.log(result); // Output: Operation successful!
}).catch((error) => {
  console.error(error);
});

A Promise is an object that represents the eventual result of an asynchronous operation. It can be in one of three states: pending, fulfilled (successful), or rejected (failed). You handle the result using .then() for fulfillment and .catch() for rejection.

15. Explain the difference between synchronous and asynchronous programming in JavaScript.

Why you might get asked this:

Provides context for understanding why Promises and async/await were introduced. Demonstrates understanding of JavaScript's execution model.

How to answer:

Explain that synchronous code runs sequentially, blocking subsequent operations until completed. Asynchronous code allows operations to run in the background without blocking, typically using callbacks, Promises, or async/await.

Example answer:

Synchronous code executes one operation at a time, in order. If an operation takes a long time, the program pauses until it finishes. Asynchronous code allows multiple operations to seemingly run concurrently; non-blocking tasks (like fetching data) are initiated, and the program continues execution, handling the result later via callbacks or Promises.

16. Write a function that returns a promise and resolves after 2 seconds with the value "Hello, World!".

Why you might get asked this:

Practical application of Promise creation, showing you can wrap asynchronous operations within a Promise. Useful for es6 interview questions involving timing or async simulation.

How to answer:

Use new Promise() and setTimeout inside the executor function. Call resolve() after the specified delay.

Example answer:

function delayMessage() {
  return new Promise(resolve => {
    setTimeout(() => {
      resolve("Hello, World!");
    }, 2000); // 2000 milliseconds = 2 seconds
  });
}

// Example usage:
// delayMessage().then(msg => console.log(msg));

17. What is the Temporal Dead Zone?

Why you might get asked this:

Tests a deeper understanding of let and const behavior beyond just scope and hoisting. Important for avoiding common pitfalls.

How to answer:

Explain that TDZ is the time period from the start of a variable's block scope until its declaration is processed. Accessing the variable during this period throws a ReferenceError.

Example answer:

The Temporal Dead Zone (TDZ) is the period between entering a scope where let or const variables are declared and when the variable is actually declared. During the TDZ, trying to access the variable results in a ReferenceError. This differs from var, which would result in undefined due to hoisting.

18. What is an IIFE (Immediately Invoked Function Expression)?

Why you might get asked this:

Although less critical since ES6 modules, IIFEs were a pre-ES6 way to achieve scope isolation and are still seen in legacy code or build outputs. Shows historical context.

How to answer:

Define IIFE as a function expression that is defined and executed immediately. Explain its purpose (creating a private scope).

Example answer:

(function() {
  var privateVar = 'I am private';
  console.log(privateVar); // Accessible here
})();
// console.log(privateVar); // ReferenceError: privateVar is not defined

An IIFE (Immediately Invoked Function Expression) is a JavaScript function that runs as soon as it is defined. It's typically used to create a private scope for variables, preventing pollution of the global scope, especially before ES6 modules became standard.

19. Explain hoisting in JavaScript.

Why you might get asked this:

A fundamental concept in JavaScript execution context, relevant to understanding variable behavior, especially with var vs let/const.

How to answer:

Describe hoisting as the JavaScript engine moving declarations (but not initializations) to the top of their containing scope during the compilation phase. Highlight the difference between var (declaration hoisted, initialized to undefined) and let/const (declaration hoisted, but not initialized, leading to TDZ).

Example answer:

Hoisting is JavaScript's behavior of moving declarations to the top of their current scope (script, function, or block) during the compilation phase. var declarations are hoisted and initialized with undefined. let and const declarations are hoisted, but not initialized, leading to the Temporal Dead Zone if accessed before the declaration line is executed.

20. What are closures?

Why you might get asked this:

A core concept in JavaScript that demonstrates a deep understanding of scope and function behavior, often related to callbacks and functional programming patterns.

How to answer:

Define a closure as a function that "remembers" the environment (the variables from its outer scope) in which it was created, even after the outer function has finished executing.

Example answer:

function outer() {
  let outerVar = 'Hello';
  function inner() {
    console.log(outerVar); // inner "closes over" outerVar
  }
  return inner;
}
const closureFn = outer();
closureFn(); // Output: Hello (outer has returned, but inner still remembers outerVar)

A closure is created when a function retains access to variables from its outer (lexical) scope even after the outer function has returned. This allows the inner function to "close over" the outer variables and use them later.

21. What is memoization?

Why you might get asked this:

Tests knowledge of performance optimization techniques, applicable in various programming contexts, including recursive functions or expensive calculations.

How to answer:

Explain memoization as an optimization technique where the result of an expensive function call is cached for specific inputs. If the function is called again with the same inputs, the cached result is returned instead of recomputing.

Example answer:

function memoize(fn) {
  const cache = {};
  return function(...args) {
    const key = JSON.stringify(args); // Create a cache key from arguments
    if (cache[key]) {
      console.log('Fetching from cache...');
      return cache[key];
    } else {
      console.log('Calculating result...');
      const result = fn.apply(this, args);
      cache[key] = result;
      return result;
    }
  };
}

const expensiveFunction = memoize(function(num) {
  // Simulate expensive computation
  for (let i = 0; i < 1000000; i++) {}
  return num * 2;
});

expensiveFunction(5); // Calculating result... -> 10
expensiveFunction(5); // Fetching from cache... -> 10

Memoization is a technique to speed up computer programs by storing the results of expensive function calls and returning the cached result when the same inputs occur again. It works by trading space (for the cache) for time (by avoiding redundant computations).

22. What is a service worker?

Why you might get asked this:

Related to modern web capabilities and progressive web apps (PWAs), showing knowledge of browser APIs beyond basic JavaScript.

How to answer:

Define a service worker as a type of web worker (a script that runs in the background) that acts as a programmable proxy between the browser and the network, enabling features like offline support and push notifications.

Example answer:

A service worker is a script that runs in the background of the browser, separate from the webpage. It can intercept network requests, manage a cache of assets, and enable features like offline support, push notifications, and background synchronization for web applications, forming a key part of Progressive Web Apps.

23. What are Iterators and Generators in ES6?

Why you might get asked this:

Tests understanding of new protocols for traversing data structures and creating easily iterable sequences, relevant for advanced data handling.

How to answer:

Explain the Iterator protocol (an object with a next() method returning { value, done }) and Generators (functions using function* and yield that simplify implementing the Iterator protocol).

Example answer:

In ES6, an Iterator is an object that defines a sequence and potentially a return value upon its termination. It must have a next() method which returns an object with value (the next item) and done (boolean indicating completion). Generators are functions declared with function* that use the yield keyword to pause execution and return a value, making it easy to create custom iterators.

24. Explain Symbols in ES6.

Why you might get asked this:

Evaluates your knowledge of a new primitive data type used for unique property keys, important for avoiding naming collisions.

How to answer:

Define Symbol as a unique and immutable primitive value, primarily used as an object property key to avoid name clashes. Explain they are guaranteed to be unique.

Example answer:

const mySymbol = Symbol('description');
const obj = {};
obj[mySymbol] = 'unique value';
console.log(obj[mySymbol]); // Output: unique value
console.log(Object.keys(obj)); // Output: [] (Symbols are not enumerable by default)

Symbols are a new primitive data type introduced in ES6. They are unique and immutable. Their primary use case is to create unique object property keys that won't conflict with other keys, even those with the same string name. This is useful for adding metadata or private properties to objects without modifying the object's original structure.

25. What are Maps and Sets in ES6? How do they differ from objects and arrays?

Why you might get asked this:

Tests knowledge of new data structures that offer advantages over traditional objects/arrays for specific use cases (key-value pairs with any key type, unique collections).

How to answer:

Describe Map as a collection of key-value pairs where keys can be any data type (unlike object keys which are strings/Symbols). Describe Set as a collection of unique values. Highlight their key differences from objects and arrays.

Example answer:

Map is a collection of key-value pairs, similar to Objects, but keys can be any data type (including objects or functions), and insertion order is remembered. Set is a collection of unique values, similar to an array but duplicates are automatically removed, and insertion order is remembered. Objects and arrays have limitations (string keys, non-unique values) that Maps and Sets overcome.

26. Describe the Spread and Rest operators in ES6.

Why you might get asked this:

Tests your understanding of these highly versatile operators used for array/object copying, merging, and function arguments, common in modern code.

How to answer:

Explain the ... syntax. Describe Spread as expanding an iterable (like an array) into individual elements or copying object properties. Describe Rest as collecting multiple elements into an array (often in function parameters or destructuring).

Example answer:

The ... syntax in ES6 is used for both the Spread and Rest operators. The Spread operator expands an iterable (like an array) into its individual elements or copies properties from an object. It's used for copying/merging arrays/objects. The Rest operator collects multiple elements into a single array. It's commonly used in function parameters or destructuring assignments to gather remaining values.

27. How does async/await work with Promises in ES6+?

Why you might get asked this:

Evaluates knowledge of the modern syntax for handling asynchronous code, built on Promises, which significantly improves readability. A key modern JavaScript question.

How to answer:

Explain that async/await is syntactic sugar on top of Promises. An async function always returns a Promise. await pauses execution within an async function until a Promise resolves, returning its value or throwing its error.

Example answer:

async and await provide a cleaner syntax for writing asynchronous code that looks synchronous, built on Promises. An async function is a function that returns a Promise. The await keyword can only be used inside an async function to pause execution until a Promise is settled (fulfilled or rejected), returning the resolved value or propagating the rejection.

28. What are enhanced object literals in ES6?

Why you might get asked this:

Tests awareness of syntax improvements that make defining objects more concise, especially when property keys match variable names or for defining methods.

How to answer:

Describe shorthand property names (if key matches variable name), shorthand method names (omit function keyword), and computed property names (use [expression] for keys).

Example answer:

let name = 'Book';
let price = 20;
let book = {
  name,           // Shorthand property name
  price,
  getDetails() {  // Shorthand method name
    return `${this.name} costs $${this.price}`;
  },
  [ 'id_' + name.toLowerCase() ]: 123 // Computed property name
};
// console.log(book.getDetails()); // Output: Book costs $20
// console.log(book.id_book); // Output: 123

ES6 enhanced object literals include shorthand property names (if variable name and property key are the same), shorthand method names (defining methods without the function keyword), and computed property names (using an expression [expression] for the key name). These features make object creation more concise.

29. What is the difference between export default and named export?

Why you might get asked this:

Important for understanding module patterns and how to structure code for reusability, frequently appearing in es6 interview questions about modules.

How to answer:

Explain that a module can have only one export default, which is the main thing the module provides and can be imported with any name. A module can have multiple named exports, which must be imported using their exact name (often within curly braces).

Example answer:

export default is used to export a single main value from a module. It can be imported with any name using import myValue from './module.js'. Named exports (export const name = ... or export function func() {}) allow exporting multiple values from a module. They must be imported using their exact names, typically with destructuring like import { name, func } from './module.js'.

30. Explain for...of loops in ES6.

Why you might get asked this:

Tests knowledge of a new iteration construct specifically designed for iterable objects, offering a cleaner way to loop over values.

How to answer:

Describe for...of as a loop that iterates over the values of an iterable object (like Arrays, Strings, Maps, Sets, etc.), as opposed to for...in which iterates over property keys.

Example answer:

const arr = [1, 2, 3];
for (const element of arr) {
  console.log(element); // Output: 1, 2, 3
}

The for...of loop iterates over the values of iterable objects (such as Arrays, Strings, Maps, Sets, and more). This provides a simpler way to loop directly over the elements of a collection, unlike for...in which iterates over the keys or property names.

Other Tips to Prepare for a es6 interview questions

Mastering es6 interview questions requires more than just memorizing definitions; it involves understanding the underlying concepts and knowing how to apply them. Practice writing code using these features. Build small projects or refactor existing JavaScript code to use ES6 syntax. As the legendary computer scientist Donald Knuth said, "Premature optimization is the root of all evil (or at least most of it) in programming." While optimization isn't the direct goal of learning ES6 features like let/const or arrow functions, understanding why they were introduced (e.g., fixing scope issues, cleaner syntax) helps you internalize their correct usage. For behavioral es6 interview questions, think about scenarios where you've used a specific ES6 feature to solve a problem or improve code readability.

Consider using AI-powered tools designed for interview preparation. Verve AI Interview Copilot (https://vervecopilot.com) can offer practice questions tailored to specific roles and technologies, including JavaScript and ES6. Using a tool like Verve AI Interview Copilot allows you to simulate interview conditions, get instant feedback on your answers, and identify areas where you need more practice with es6 interview questions. "The only way to do great work is to love what you do," according to Steve Jobs. While job interviews might not always feel like "great work," approaching the preparation process with enthusiasm for learning modern JavaScript, perhaps with assistance from Verve AI Interview Copilot, can make it less stressful and more effective. Focus on understanding why these features exist and how they make JavaScript development better. Good luck with your es6 interview questions!

Frequently Asked Questions

Q1: Is ES6 the same as JavaScript?
A1: ES6 (ECMAScript 2015) is a version of the standard that JavaScript implements. JavaScript is the language, ECMAScript is the specification.

Q2: Do I need to know all ES6 features for an interview?
A2: Focus on core features like let/const, arrow functions, classes, promises, and modules, as these are most commonly asked in es6 interview questions.

Q3: How is async/await related to Promises?
A3: async/await is syntactic sugar built on top of Promises, making asynchronous code look and behave more like synchronous code.

Q4: Are ES6 features supported in all browsers?
A4: Modern browsers have excellent support for most ES6 features. Transpilers like Babel are used for compatibility with older environments.

Q5: What's the main benefit of let/const over var?
A5: Block scoping. let and const limit variables to the block they're declared in, preventing common hoisting and scope issues associated with var.

Q6: Why use modules instead of separate script files?
A6: Modules provide true scope isolation, dependency management, and cleaner code organization compared to simply including multiple scripts globally.