1. Arrow Functions: Arrow functions provide a more concise syntax for writing functions in JavaScript. They have a shorter syntax and automatically bind the context of the surrounding code.
Example: ``` const add = (a, b) => a + b; ```
2. Template Literals: Template literals allow for easier string interpolation and multiline strings in JavaScript. They use backticks (`) instead of single or double quotes.
Example:
“`
const name = ‘John’;
console.log(`Hello, ${name}!`);
“`
3. Destructuring Assignment: Destructuring assignment allows you to extract values from arrays or objects and assign them to variables in a more concise way.
Example:
“`
const [a, b] = [1, 2];
console.log(a); // 1
console.log(b); // 2
“`
4. Default Parameters: Default parameters allow you to specify default values for function parameters, which will be used if no value or undefined is passed.
Example:
“`
function greet(name = ‘World’) {
console.log(`Hello, ${name}!`);
}
greet(); // Hello, World!
greet(‘John’); // Hello, John!
“`
5. Spread Operator: The spread operator allows you to expand elements of an array or object into individual elements. It can be used for array concatenation, object merging, and function arguments.
Example:
“`
const arr1 = [1, 2, 3];
const arr2 = [4, 5, 6];
const mergedArray = […arr1, …arr2];
console.log(mergedArray); // [1, 2, 3, 4, 5, 6]
“`
6. Rest Parameters: Rest parameters allow you to represent an indefinite number of arguments as an array. They are useful when you want to pass a variable number of arguments to a function.
Example:
“`
function sum(…numbers) {
return numbers.reduce((acc, curr) => acc + curr, 0);
}
console.log(sum(1, 2, 3)); // 6
console.log(sum(4, 5, 6, 7)); // 22
“`
7. Object Literal Enhancements: ES6 introduced shorthand syntax for defining object literals. It allows you to omit the key and value if they have the same name.
Example:
“`
const name = ‘John’;
const age = 30;
const person = { name, age };
console.log(person); // { name: ‘John’, age: 30 }
“`
8. Modules: ES6 introduced native support for modules in JavaScript. Modules allow you to split your code into separate files and import/export functionality between them.
Example:
“`
// math.js
export function add(a, b) {
return a + b;
}
// main.js
import { add } from ‘./math.js’;
console.log(add(1, 2)); // 3
“`
9. Promises: Promises provide a cleaner way to handle asynchronous operations in JavaScript. They represent the eventual completion or failure of an asynchronous operation and allow you to chain multiple asynchronous operations together.
Example:
“`
function fetchData() {
return new Promise((resolve, reject) => {
setTimeout(() => {
resolve(‘Data fetched successfully’);
}, 2000);
});
}
fetchData()
.then((data) => {
console.log(data);
})
.catch((error) => {
console.error(error);
});
“`
10. Classes: ES6 introduced class syntax for creating objects with a constructor and methods. It provides a more familiar and structured way to define objects and their behavior.
Example:
“`
class Person {
constructor(name) {
this.name = name;
}
greet() {
console.log(`Hello, ${this.name}!`);
}
}
const john = new Person(‘John’);
john.greet(); // Hello, John!
“`
These are just a few of the many features introduced in ES6. Learning and understanding these features will greatly enhance your JavaScript development skills.