1)ES6 features:
ES6 (ECMAScript 2015) introduced many new features and syntax improvements to JavaScript. Here are some notable ES6 features along with examples:
1. Arrow Functions:
Arrow functions provide a more concise syntax for writing anonymous functions.
javascript
Copy code
// ES5
function add(a, b) {
return a + b;
}
// ES6
const add = (a, b) => a + b;
2. Template Literals:
Template literals allow embedding expressions inside strings using backticks (`).
javascript
Copy code
// ES5
var message = "Hello, " + name + "!";
// ES6
let message = `Hello, ${name}!`;
3. Destructuring Assignment:
Destructuring allows extracting values from objects or arrays and assigning them to variables.
javascript
Copy code
// ES5
var person = { name: 'John', age: 30 };
var name = person.name;
var age = person.age;
// ES6
const { name, age } = { name: 'John', age: 30 };
4. Spread Syntax:
The spread syntax (...) allows expanding iterable objects (e.g., arrays) into individual elements.
javascript
Copy code
// ES5
var arr1 = [1, 2, 3];
var arr2 = [4, 5, 6];
var combined = arr1.concat(arr2);
// ES6
let arr1 = [1, 2, 3];
let arr2 = [4, 5, 6];
let combined = [...arr1, ...arr2];
5. Default Parameters:
Default parameters allow specifying default values for function parameters.
javascript
Copy code
// ES5
function greet(name) {
name = name || 'Guest';
console.log('Hello, ' + name + '!');
}
// ES6
const greet = (name = 'Guest') => {
console.log(`Hello, ${name}!`);
};
6. Classes:
ES6 introduced a more convenient syntax for defining classes in JavaScript.
javascript
Copy code
// ES5
function Person(name, age) {
this.name = name;
this.age = age;
}
Person.prototype.greet = function() {
console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`);
};
// ES6
class Person {
constructor(name, age) {
this.name = name;
this.age = age;
}
greet() {
console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`);
}
}
These are just a few examples of ES6 features. ES6 introduced many more enhancements such as let and const for variable declarations, for...of loops, Promises, and more, which have become standard in modern JavaScript development.
2)Output:
setTimeout(() => {
console.log("Inside setTimeout callback");
}, 0);
const myPromise = new Promise((resolve, reject) => {
resolve("Resolved");
});
process.nextTick(() => {
console.log("Inside process.nextTick callback");
});
myPromise.then((result) => {
console.log("Promise resolved with:", result);
}).catch((error) => {
console.error("Promise rejected with:", error);
}).finally(() => {
console.log("finally");
});
process.nextTick()
callbacks are executed before any other I/O events or timers, so "Inside process.nextTick callback" is logged first.Promise.then()
andPromise.catch()
handlers are executed asynchronously after the current execution context is empty. Since the Promise resolves immediately, the.then()
handler is invoked next, logging "Promise resolved with: Resolved".- The
finally()
block is executed after the Promise settles, logging "finally". setTimeout()
callbacks are executed after a minimum of the specified delay (in this case, 0 milliseconds), but after the current execution context is empty. Therefore, "Inside setTimeout callback" is logged last.
Comments
Post a Comment