Node.js ES6+ imkoniyatlari

ES6+ nima?

ES6 (ECMAScript 2015) va undan keyingi versiyalar JavaScript’ga kodingizni yanada ifodali, ixcham va xavfsiz qiladigan kuchli yangi imkoniyatlarni qo‘shadi.

Node.js zamonaviy JavaScript funksiyalarini mukammal qo‘llab-quvvatlaydi.

Node.js muvofiqligi: Node.js ning barcha zamonaviy versiyalari (10+) ES6+ funksiyalarini mukammal qo‘llab-quvvatlaydi.

Yangi versiyalar ES2020 va undan keyingi JavaScript qo‘shimchalarini qo‘llab-quvvatlaydi.

Ushbu zamonaviy JavaScript xususiyatlari sizga yordam beradi:

Tozaroq, o‘qilishi mumkin bo‘lgan kodni yozing
Umumiy JavaScript tuzoqlaridan qoching
Ko‘proq qo‘llab-quvvatlanadigan ilovalar yarating
Tashqi kutubxonalarga bo‘lgan ehtiyojni kamaytiring

let va const

let va const kalit so‘zlari o‘zgaruvchilarni e’lon qilishning afzal usuli sifatida var o‘rnini egalladi:

let qayta tayinlanishi mumkin bo‘lgan o‘zgaruvchilarni e’lon qilish imkonini beradi
const qayta qiymat berib bo‘lmaydigan o‘zgaruvchilarni e’lon qiladi (lekin obyekt xususiyatlarini baribir o‘zgartirish mumkin)
Har ikkisi ham funksiyaga tegishli var dan farqli ravishda blokli

Misol: let va const

// Using let (can be changed)
let score = 10;
score = 20;
// Using const (cannot be reassigned)
const MAX_USERS = 100;

// Block scope with let
if (true) {
let message = 'Hello';
console.log(message); // Works here
}

O‘zingiz sinab ko‘ring »

Ok funksiyalari

Ok funksiyalari funksiyalarni yozish uchun qisqacha sintaksisni ta’minlaydi va this ni atrofdagi kontekstga avtomatik bog‘laydi.

Ok funksiyalarining asosiy afzalliklari:

Oddiy funksiyalar uchun qisqaroq sintaksis
Bir qatorli ifodalar uchun yashirin qaytish
Leksik this bog‘lash (strelka funksiyalari o‘zlarining this kontekstini yaratmaydi)

Misol: Ok funksiyalari

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

// Arrow function (same as above)
const addArrow = (a, b) => a + b;

// Single parameter (no parentheses needed)

const double = num => num * 2;

// No parameters (parentheses needed)
const sayHello = () => 'Hello!';

// Using with array methods
const numbers = [1, 2, 3];
const doubled = numbers.map(num => num * 2);
console.log(doubled);

O‘zingiz sinab ko‘ring »

Qachon strelka funksiyalaridan foydalanilmasa:

Obyekt usullari (obyektga murojaat qilish uchun "bu" kerak bo‘lganda)
Konstruktor funksiyalari (strelka funksiyalarini “yangi” bilan ishlatib bo‘lmaydi)
`Bu` elementga murojaat qilishi kerak bo‘lgan voqea ishlovchilar

Shablon harflari

Template literallar (shablon stringlar) backtick belgilari (`) yordamida ichiga ifodalar joylashtirilgan stringlarni yaratishning qulay usulini taqdim etadi.

Shablon harflarining asosiy xususiyatlari:

${expression} sintaksisi bilan string interpolyatsiyasi
Escape belgilarsiz ko‘p qatorli stringlar
Kengaytirilgan string ishlov berish uchun teglangan andozalar

Misol: Shablon harflari

// Basic string interpolation
const name = 'Alice';
console.log(`Hello, ${name}!`);

// Multi-line string
const message = `
This is a multi-line
string in JavaScript.
`;
console.log(message);

// Simple expression
const price = 10;
const tax = 0.2;
console.log(`Total: $${price * (1 + tax)}`);

O‘zingiz sinab ko‘ring »

Buzilish

Strukturani buzish massivlardan qiymatlarni yoki obyektlardan xossalarni qisqacha sintaksis bilan alohida o‘zgaruvchilarga chiqarish imkonini beradi.

Tuzilishning asosiy xususiyatlari:

Bitta operatorda bir nechta qiymatlarni ajratib oling
Chiqarilgan xususiyatlarga standart qiymatlarni belgilang
Ekstraksiya paytida xususiyatlarni qayta nomlash
Massivlardagi elementlarni o‘tkazib yuborish
Chuqur joylashtirilgan xususiyatlarni ajratib oling

Misol: Obyektni destrukturizatsiya qilish (Object Destructuring)

// Basic object destructuring
const user = { name: 'Alice', age: 30, location: 'New York' };
const { name, age } = user;
console.log(name, age);

O‘zingiz sinab ko‘ring »

Misol: Massivni destrukturizatsiya qilish (Array Destructuring)

// Basic array destructuring
const colors = ['red', 'green', 'blue'];
const [first, second, third] = colors;
console.log(first, second, third);

// Skipping elements
const [primary, , tertiary] = colors;
console.log(primary, tertiary);

O‘zingiz sinab ko‘ring »

Spread va dam olish operatorlari

Spread va rest operatorlari (ikkalasi ham ... ko‘rinishida yoziladi) bir nechta element bilan samaraliroq ishlash imkonini beradi.

Spread operatori: takrorlanuvchilarni (massivlar, obyektlar, stringlar) alohida elementlarga kengaytiradi
Dam olish operatori: bitta massiv yoki obyektga bir nechta elementlarni to‘playdi

Misol: Spread operatori

// Array spread - combining arrays
const numbers = [1, 2, 3];
const moreNumbers = [4, 5, 6];
const combined = [...numbers, ...moreNumbers];
console.log(combined);

// Array spread - converting string to array of characters
const chars = [...'hello'];
console.log(chars);

O‘zingiz sinab ko‘ring »

Misol: Dam olish operatori

// Rest parameter in functions
function sum(...numbers) {
return numbers.reduce((total, num) => total + num, 0);
}
console.log(sum(1, 2, 3, 4, 5));

O‘zingiz sinab ko‘ring »

Standart parametrlar

ES6+ funksiya parametrlari uchun standart qiymatlarni belgilash imkonini beradi, bu ko‘p hollarda parametrlarni qo‘lda tekshirish zaruriyatini yo‘q qiladi.

Standart parametrlarning asosiy afzalliklari:

Qo‘lda tekshirishsiz tozalovchi funksiya ta’riflari
Aniqroq funksiya imzolari
Standart qiymatlar faqat parametrlar aniqlanmagan yoki taqdim etilmagan hollarda qo‘llaniladi
Standart qiymatlar oddiy qiymatlar emas, balki ifodalar bo‘lishi mumkin

Misol: Standart parametrlar

// Basic default parameter
function greet(name = 'Guest') {
return `Hello, ${name}!`;
}

console.log(greet());
console.log(greet('Kai'));

O‘zingiz sinab ko‘ring »

Sinflar

ES6 JavaScript-ga class sintaksisini kiritdi, bu obyektlarni yaratish va merosni amalga oshirishning aniqroq va qisqaroq usulini taqdim etdi.

Kaput ostida JavaScript sinflari hali ham prototiplarga asoslangan.

JavaScript sinflarining asosiy xususiyatlari:

Konstruktor funksiyalari va usullarini yaratish uchun toza sintaksis
extends yordamida meros uchun o‘rnatilgan yordam
Sinfga biriktirilgan statik usullar, misollar emas
Ko‘proq nazorat qilinadigan mulkka kirish uchun Getter va setter usullari
Yaxshiroq inkapsulyatsiya uchun private maydonlar (ES2022+)

Misol: Class asoslari

// Simple class with constructor and method
class Person {
  constructor(name, age) {
    this.name = name;
    this.age = age;
  }

  greet() {
    return `Hello, I'm ${this.name}!`;
  }
}

// Create an instance
const person = new Person('Alice', 25);
console.log(person.greet()); // Hello, I'm Alice!

O‘zingiz sinab ko‘ring »

Misol: Class merosi

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

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

// Child class
class Dog extends Animal {
  speak() {
    return `${this.name} barks!`;
  }
}

const dog = new Dog('Rex');
console.log(dog.speak());

O‘zingiz sinab ko‘ring »

Misol: Private Class Fields (ES2022+)

// Class with private field (# prefix)
class Counter {
  #count = 0; // Private field

  increment() {
    this.#count++;
  }

  getCount() {
    return this.#count;
  }
}

const counter = new Counter();
counter.increment();
console.log(counter.getCount());
// console.log(counter.#count); // Error: Private field

Misolni ishga tushirish »

Promiselar va Async/Await

Zamonaviy JavaScript asinxron operatsiyalarni boshqarish uchun kuchli vositalarni taqdim etadi, bu esa kechikishlar, API chaqiruvlari yoki kiritish-chiqarish operatsiyalarini o‘z ichiga olgan kod bilan ishlashni ancha osonlashtiradi.

Promiselar

Promiselar hali mavjud bo‘lmagan qiymatlarni ifodalaydi.

Ular callback funksiyasilarga qaraganda asinxron operatsiyalarni boshqarishning yanada oqlangan usulini ta’minlaydi.

Promise quyidagi shtatlardan birida:

Kutilmoqda: Dastlabki holat, bajarilmagan yoki rad etilmagan
Bajarildi: Amaliyot muvaffaqiyatli yakunlandi
Rad etildi: Amaliyot amalga oshmadi

Misol: Asosiy Promiselar

// Creating a promise
const fetchData = () => {
  return new Promise((resolve, reject) => {
     // Simulating an API call
     setTimeout(() => {
       const data = { id: 1, name: 'Product' };
       const success = true;

       if (success) {
         resolve(data); // Fulfilled with data
       } else {
         reject(new Error('Failed to fetch data')); // Rejected with error
       }
     }, 1000);
  });
};

// Using a promise
console.log('Fetching data...');

fetchData()
  .then(data => {
    console.log('Data received:', data);
    return data.id; // Return value is passed to the next .then()
  })
  .then(id => {
    console.log('Processing ID:', id);
  })
  .catch(error => {
    console.error('Error:', error.message);
  })
  .finally(() => {
    console.log('Operation completed (success or failure)');
  });

console.log('Continuing execution while fetch happens in background');

Misolni ishga tushirish »

Async/Kuting

Async/await (ES2017 da kiritilgan) promise’lar bilan ishlash uchun toza sintaksisni taqdim etadi va asinxron kodni ko‘rinishi hamda ishlashi jihatidan sinxron kodga yaqinlashtiradi.

Misol: Async/Await

// Function that returns a promise
const fetchUser = (id) => {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      if (id > 0) {
        resolve({ id, name: `User ${id}` });
       } else {
        reject(new Error('Invalid user ID'));
       }
     }, 1000);
  });
};

// Using async/await
async function getUserData(id) {
  try {
    console.log('Fetching user...');
    const user = await fetchUser(id); // Waits for the promise to resolve
    console.log('User data:', user);

    // You can use the result directly
    return `${user.name}'s profile`;
  } catch (error) {
     // Handle errors with try/catch
     console.error('Error fetching user:', error.message);
     return 'Guest profile';
   }
}

// Async functions always return promises
console.log('Starting...');
getUserData(1)
  .then(result => console.log('Result:', result))
  .catch(error => console.error('Unexpected error:', error));
console.log('This runs before getUserData completes');

Misolni ishga tushirish »

Umumiy async/await xatolari:

Asenkron funksiyalarni unutish har doim Promiselarni qaytaradi
try/catch bilan xatolarni ko‘rib chiqmaslik
Operatsiyalarni parallel ravishda bajarish mumkin bo‘lganda ketma-ket bajarish
Asinx funksiyasidan tashqari kutishdan foydalanish
Awaiting non-promise values (unnecessary but harmless)

ES modullari

ES Modules (ESM) kodni tartibga solish va ulashishning standartlashtirilgan usulini taqdim etadi. Ular ES2015 da kiritilgan va hozir Node.js’da native tarzda qo‘llab-quvvatlanadi.

ES modullarining asosiy afzalliklari:

Statik modul tuzilmasi (importlar kompilyatsiya vaqtida tahlil qilinadi)
Standart va nomlangan eksport/importlar
Yaxshiroq qaramlikni boshqarish
Tree-shaking (eliminating unused code)

Misol: ES modullari

Fayl: math.js

// Named exports
export const PI = 3.14159;

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

export function multiply(a, b) {
  return a * b;
}

// Default export
export default class Calculator {
  add(a, b) {
    return a + b;
  }

  subtract(a, b) {
    return a - b;
  }
}

Fayl: app.js

// Import default export
import Calculator from './math.js';

// Import named exports
import { PI, add, multiply } from './math.js';

// Import with alias
import { add as mathAdd } from './math.js';

// Import all exports as a namespace
import * as MathUtils from './math.js';

const calc = new Calculator();
console.log(calc.subtract(10, 5)); // 5

console.log(add(2, 3)); // 5
console.log(mathAdd(4, 5)); // 9
console.log(MathUtils.PI); // 3.14159
console.log(MathUtils.multiply(2, 3)); // 6

Misolni ishga tushirish »

Node.js da ES modullaridan foydalanish uchun siz:

Modul fayllari uchun .mjs kengaytmasidan foydalaning
Paketingizga "type": "module" qo‘shing.json
--experimental-modules flagidan foydalaning (eski Node.js versiyalari uchun)

CommonJS modul tizimi (require() va module.exports) Node.js’da hali ham keng qo‘llaniladi. ES Modules va CommonJS bitta loyihada birga ishlashi mumkin, ammo ularning semantikasi turlicha.

Kengaytirilgan obyekt harflari

ES6+ obyektni yaratishni yanada ixcham va ifodali qiladigan obyekt harflariga bir nechta yaxshilanishlarni kiritdi.

Misol: Kengaytirilgan obyekt harflari

// Property shorthand
const name = 'Alice';
const age = 30;

// Instead of {name: name, age: age}
const person = { name, age };
console.log(person);

// Method shorthand
const calculator = {
  // Instead of add: function(a, b) { ... }
  add(a, b) {
    return a + b;
  },
  subtract(a, b) {
    return a - b;
  }
};
console.log(calculator.add(5, 3));

O‘zingiz sinab ko‘ring »

Ixtiyoriy zanjir va nol birlashma

Zamonaviy JavaScript o‘rnatilgan xususiyatlarga xavfsiz kirish va zaxira qiymatlarni ta’minlash uchun sintaksisni taqdim etadi.

Ixtiyoriy zanjirlash (?.)

Ixtiyoriy zanjirlash zanjirdagi nol yoki noaniq qiymatlar haqida qayg‘urmasdan, chuqur joylashtirilgan obyekt xususiyatlariga kirish imkonini beradi.

Misol: ixtiyoriy zanjir

Nullish coalescing operatori (??)

Nullish birlashtiruvchi operator (??) qiymat null yoki noaniq bo‘lganda standart qiymatni beradi (lekin 0 yoki "" kabi boshqa noto‘g‘ri qiymatlar uchun emas).

Misol: Nullish Coalescing

function calculatePrice(price, tax) {
// Only uses default if tax is null or undefined
return price + (tax ?? 0.1) * price;
}

console.log(calculatePrice(100, 0)); // 100 (correct! tax of 0 was used)
console.log(calculatePrice(100, null)); // 110 (using default)

Zamonaviy asinxron naqshlar

Zamonaviy JavaScript asinxron operatsiyalarni boshqarish uchun kuchli naqshlarni taqdim etadi. Ketma-ket va parallel bajarishdan qachon foydalanishni tushunish ilovangiz unumdorlikni sezilarli darajada yaxshilashi mumkin.

Parallel va ketma-ket bajarilishi:

ketma-ket: Amallar birin-ketin bajariladi, har biri oldingi tugashini kutadi
Parallel: Operatsiyalar bir vaqtning o‘zida ishlaydi, bu operatsiyalar mustaqil bo‘lganda samaraliroq bo‘ladi

Misol: Ketma-ket bajarish

// Helper function to simulate an API call
function fetchData(id) {
  return new Promise(resolve => {
    setTimeout(() => resolve(`Data for ID ${id}`), 1000);
  });
}

// Sequential execution (~3 seconds total)
async function fetchSequential() {
  console.time('sequential');
  const data1 = await fetchData(1);
  const data2 = await fetchData(2);
  const data3 = await fetchData(3);
  console.timeEnd('sequential');
  return [data1, data2, data3];
}

// Run the sequential example
fetchSequential().then(results => {
  console.log('Sequential results:', results);
});

Misolni ishga tushirish »

Misol: Parallel bajarish

// Parallel execution (~1 second total)
async function fetchParallel() {
  console.time('parallel');
  const results = await Promise.all([
    fetchData(1),
    fetchData(2),
    fetchData(3)
  ]);
  console.timeEnd('parallel');
  return results;
}

// Run the parallel example
fetchParallel().then(results => {
  console.log('Parallel results:', results);
});

Misolni ishga tushirish »

Har bir naqshdan qachon foydalanish kerak:

Amallar oldingi natijalarga bog‘liq bo‘lsa, ketma-ketdan foydalaning
Operatsiyalar mustaqil va bir vaqtning o‘zida ishlashi mumkin bo‘lganda paralleldan foydalaning
Parallel API chaqiruvlarini amalga oshirishda so‘rovlar chastotasi cheklovlarini (rate limit) yodda tuting
Boshqariladigan parallellik uchun p-queue kabi kutubxonalardan foydalanishni ko‘rib chiqing

Xulosa

ES6+ JavaScript dasturlashni o‘zgartirib, kodni yanada o‘qilishi, xizmat ko‘rsatishi va mustahkamligini ta’minlovchi ko‘plab xususiyatlarni taqdim etdi:

let/const: Aniqroq semantikaga ega bloklangan o‘zgaruvchilar
Arrow funksiyalari: qisqa sintaksis va leksik this bog‘lanishi
Shablon literallari: String interpolyatsiyasi va ko‘p qatorli stringlar
Destrukturizatsiya: Obyektlar va massivlardan qiymatlarni osongina ajratib oling
Spread/dam olish operatorlari: To‘plamlar bilan samaraliroq ishlang
Standart parametrlar: Funksiyaning sodda ta’riflari
Sinflar: Obyektga yo‘naltirilgan dasturlash uchun toza sintaksis
Promiselar va async/await: yaxshiroq asinxron kod boshqaruvi
ES modullari: standartlashtirilgan kod tashkiloti
Kengaytirilgan obyekt literallari: yanada ixcham obyekt sintaksisi
Ixtiyoriy zanjir va nol birlashtirish: mulkka xavfsiz kirish va standart sozlamalar

Ushbu zamonaviy xususiyatlar joriy Node.js versiyalarida to‘liq qo‘llab-quvvatlanadi, bu sizga JavaScript-ning keng tarqalgan tuzoqlaridan qochib, yanada toza va ifodali kod yozish imkonini beradi.

W3Schools Pathfinder

Yutuqlaringizni kuzating – bu bepul!

Ro'yxatdan o'tish Kirish