JavaScript ES6 (ECMAScript 2015) Updates : JS ES6 Updates

Other Blogs

Blogs ❯❯ JavaScript

If tutorials available on this website are helpful for you, please whitelist this website in your ad blocker😭 or Donate to help us ❤️ pay for the web hosting to keep the website running.

JS ES6 Updates

JavaScript ES6 Updates

JavaScript या ES6 (ECMAScript 2015) एक बड़ा update था, जो इस programming language को और powerful और easy-तो-use बनाता है।

इस blog में हम ES6 के new features के बारे में समझेंगे, और उन्हें किस तरह से अपने projects में use कर सकते हैं, उसका discussion करेंगे।

हालाँकि कुछ मैं updates कुछ इस तर से हैं।

let & const : new तरीके से Variables Declare करना।
Arrow Functions : Functions को Simplify करना।
Template Literals : Strings को Easy बनाना।
Destructuring : Arrays और Objects से Data Extract करना।
Default Parameters : Functions में Default Values देना।
Rest & Spread Operators : Data को Manage करना।
Classes : Object-Oriented JavaScript .
Promises : Asynchronous Code को Handle करना।
Modules : Code को Organize करना।

चलिए अब इन updates को थोड़ा detail में देख लेते हैं।

●●●

1. let & const

पहले JavaScript में variables declare करने के लिए हम सिर्फ var का use करते थे। लेकिन var का scope काफी confusing होता था, और कई बार bugs का cause ban जाता था।

ES6 में let और const introduce किये गए , जो block-scope variable declarations के लिए use होते हैं।


let name = "Rahul";
const pi = 3.14;

let : ये mutable है, मतलब इसकी value change कि जा सकती है।
const : ये immutable है, इसकी value एक बार set करने के बाद change नहीं हो सकती।

2. Arrow Functions

Arrow functions काफी concise syntax देते हैं functions लिखने के लिए। यह anonymous functions को लिखना और easy बनाता है।


// Normal function
function sum(a, b) {
    return a + b;
}

// Arrow function
let sum = (a, b) => a + b;

Arrow functions का benefit है कि ये अपने parent scope का this inherit करते हैं, जो कभी कभी traditional functions में confusion का कारण होता था।

3. Template Literals

ES6 में template literals ने string concatenation को बहुत आसान बना दिया है। Template literals backticks ` का use करके लिखे जाते हैं, जिसमे variables directly string के अंदर inject कर सकते हैं।


let name = "Rahul";
let age = 25;
console.log(`Mera naam ${name} hai aur meri age ${age} hai.`);

4. Destructuring

Destructuring से हम arrays और objects के अंदर से values easily extract कर सकते हैं। यह syntax को और concise बनाता है।


// Array destructuring
let [a, b] = [10, 20];
console.log(a); // 10
console.log(b); // 20

// Object destructuring
let person = { name: "Rahul", age: 25 };
let { name, age } = person;
console.log(name); // "Rahul"
console.log(age); // 25

5. Default Parameters

ES6 में आप functions के parameters के लिए default values define कर सकते हैं। अगर कोई argument pass नहीं किया जाता है, तो default value use कि जाती है।


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

6. Rest & Spread Operators

Rest Operator (...) : यह एक function के arguments को एक array में convert करता है।


function sum(...numbers) {
    return numbers.reduce((acc, curr) => acc + curr);
}
console.log(sum(1, 2, 3)); // 6

Spread Operator (...) : यह एक array या object के elements को spread करता है।


let arr1 = [1, 2, 3];
let arr2 = [...arr1, 4, 5, 6];
console.log(arr2); // [1, 2, 3, 4, 5, 6]

7. Classes : Object-Oriented JavaScript

ES6 में classes introduce हुई, जिससे object-oriented programming का implementation और clean और simple ban गया।


class Animal {
    constructor(name) {
        this.name = name;
    }

    speak() {
        console.log(`${this.name} makes a sound.`);
    }
}

let dog = new Animal("Dog");
dog.speak(); // "Dog makes a sound."

8. Promises

Promises asynchronous operations को handle करने का एक नया तरीका लाती हैं। यह callbacks से better है, क्योंकि यह code को ज़्यादा readable बनाता है।


let promise = new Promise((resolve, reject) => {
    let success = true;
    if (success) {
        resolve("Operation successful");
    } else {
        reject("Operation failed");
    }
});

promise.then(result => {
    console.log(result);
}).catch(error => {
    console.log(error);
});

9. Modules

ES6 में modules का support introduce किया गया, जो code को import/export करने कि facility provide करता है। यह reusability और maintainability को improve करता है।


// Exporting a module
export const PI = 3.14;

// Importing a module
import { PI } from './math.js';
console.log(PI); // 3.14

●●●

Conclusion

ES6 ने JavaScript को एक modern programming language बनाने में एक बड़ा role play किया है। इस update ने language को ज़्यादा powerful, readable, और maintainable बनाया है. अगर आप JavaScript use करते हैं।

इस blog के through हमने ES6 के new features को detail में discuss किया , आपको अच्छे से समझ भी आया होगा।

Keep Learning :)

Recent Blogs

Loading ...

Hey ! I'm Rahul founder of learnhindituts.com. Working in IT industry more than 4.5 years. I love to talk about programming as well as writing technical tutorials and blogs that can help to others .... keep learning :)

Get connected with me - LinkedIn Twitter Instagram Facebook

Your Thought ?

0 Comment(s) found !