🚀 JavaScript’ning 100 ta Eng Zo‘r Xususiyati

const API_URL = 'https://api.example.com';
let count = 0;
count++;

const double = x => x * 2;
const greet = (name, age) => `Salom, ${name}! Siz ${age} yoshdasiz.`;

const name = "John";
const message = `Salom, ${name}! Bugun ${new Date().toLocaleDateString()}`;

const { name, age, city = 'Noma\'lum' } = user;
const [first, second, ...rest] = arr;

const newArr = [...oldArr, 4, 5];
const newObj = { ...oldObj, newKey: 'value' };
const merged = { ...obj1, ...obj2 };

function sum(...numbers) {
    return numbers.reduce((acc, n) => acc + n, 0);
}
sum(1, 2, 3, 4, 5); // 15

function greet(name = 'Mehmon', age = 18) {
    return `${name}, ${age} yosh`;
}

const name = 'John', age = 30;
const user = { name, age }; // { name: 'John', age: 30 }

const key = 'status';
const obj = {
    [key]: 'active',
    ['user_' + Date.now()]: 'value'
};

const obj = {
    getName() {
        return this.name;
    }
};

class Animal {
    constructor(name) {
        this.name = name;
    }
    speak() {
        console.log(`${this.name} ovoz chiqaradi`);
    }
}

class User {
    get fullName() {
        return `${this.firstName} ${this.lastName}`;
    }
    set age(value) {
        if (value < 0) throw new Error('Yosh manfiy bo‘lishi mumkin emas');
        this._age = value;
    }
}

class MathUtils {
    static PI = 3.14159;
    static circleArea(radius) {
        return this.PI * radius * radius;
    }
}

class BankAccount {
    #balance = 0;
    deposit(amount) {
        this.#balance += amount;
    }
    getBalance() {
        return this.#balance;
    }
}

const city = user?.address?.city ?? 'Noma\'lum';
const result = obj?.method?.();

const doubled = [1, 2, 3].map(x => x * 2); // [2, 4, 6]

const evens = [1, 2, 3, 4, 5].filter(x => x % 2 === 0); // [2, 4]

const sum = [1, 2, 3, 4].reduce((acc, x) => acc + x, 0); // 10

const result = ['a', 'b', 'c'].reduceRight((acc, x) => acc + x); // 'cba'

const found = users.find(user => user.id === 5);

const index = users.findIndex(user => user.id === 5);

const hasAdults = users.some(user => user.age >= 18);

const allAdults = users.every(user => user.age >= 18);

const flattened = [1, [2, [3, 4]]].flat(2); // [1, 2, 3, 4]

const result = arr.flatMap(x => [x, x * 2]);

const sorted = numbers.sort((a, b) => a - b);

const exists = arr.includes(3);

const last = arr.at(-1); // Oxirgi element

const sorted = arr.toSorted((a, b) => a - b);

const reversed = arr.toReversed();

const promise = new Promise((resolve, reject) => {
    setTimeout(() => resolve('Done'), 1000);
});

async function getData() {
    const data = await fetch('/api/data');
    return data.json();
}

const results = await Promise.all([fetch1(), fetch2(), fetch3()]);

const results = await Promise.allSettled([fetch1(), fetch2()]);

const result = await Promise.race([fetch1(), fetch2()]);

const result = await Promise.any([fetch1(), fetch2()]);

const { promise, resolve, reject } = Promise.withResolvers();

for await (const item of asyncIterable) {
    console.log(item);
}

const controller = new AbortController();
fetch('/api/data', { signal: controller.signal });
controller.abort(); // Bekor qilish

// modul.js
const data = await fetch('/api/data');
export default data;

const value = input ?? 'default';

const bigNumber = 9007199254740991n;
const result = bigNumber + 10n;

console.log(globalThis); // Brauzer: window, Node: global

const matches = 'test1 test2'.matchAll(/test(\d)/g);

const weakRef = new WeakRef(obj);
const registry = new FinalizationRegistry(heldValue => {
    console.log('Obyekt o‘chirildi', heldValue);
});

x ??= defaultValue; // x = x ?? defaultValue

'hello world'.replaceAll('o', '0'); // 'hell0 w0rld'

const million = 1_000_000;
const bytes = 0xFF_FF_FF_FF;

const module = await import('./module.js');

console.log(import.meta.url); // Modul URL

export * as utils from './utils.js';

class MyClass {
    static {
        this.API_KEY = process.env.API_KEY;
        this.CONFIG = this.loadConfig();
    }
}

class User {
    #validate() {
        return this.#password.length > 6;
    }
    get #id() { return this._id; }
}

try {
    await fetch('/api');
} catch (error) {
    throw new Error('API xatosi', { cause: error });
}

const sorted = arr.toSorted(); // arr o‘zgarmaydi
const updated = arr.with(2, 10); // 2-indeksni 10 ga o‘zgartirish

const lastEven = arr.findLast(x => x % 2 === 0);

if (Object.hasOwn(obj, 'property')) {
    // ...
}

#!/usr/bin/env node
console.log('Hello');

const regex = /[\p{Emoji}]/v;

await using resource = await getResource();

import data from './data.json' assert { type: 'json' };

const grouped = people.group(person => person.age);

const people = [
    { name: 'Ali', age: 25 },
    { name: 'Vali', age: 30 },
    { name: 'Hasan', age: 25 }
];

const groupedByAge = people.group(person => person.age);
// { 25: [...], 30: [...] }

const { promise, resolve, reject } = Promise.withResolvers();
setTimeout(resolve, 1000, 'Done');
await promise;

const str = 'Hello\uD800';
console.log(str.isWellFormed()); // false
console.log(str.toWellFormed()); // 'Hello�'

const base64 = Uint8Array.from([72, 101, 108, 108, 111]).toBase64();

const format = new Intl.DurationFormat('uz');
console.log(format.format({ hours: 5, minutes: 30 }));

const now = Temporal.Now.plainDateTimeISO();
const future = now.add({ hours: 24 });

@logged
class MyClass {
    @readonly
    property = 10;
}

const point = #[1, 2]; // Tuple
const user = #{ name: 'Ali', age: 25 }; // Record

const result = 10 |> double |> addFive |> toString;

const value = input ?? throw new Error('Input required');

const clone = structuredClone(complexObject);

const realm = new ShadowRealm();
const result = await realm.importValue('./module.js', 'fn');

const iter = [1, 2, 3, 4].values();
const result = iter.filter(x => x % 2 === 0).map(x => x * 2).toArray();

const context = new AsyncContext();
context.runWith({ user: 'Ali' }, async () => {
    const user = context.get('user');
});

const price = Decimal('0.1 + 0.2'); // Decimal('0.3')

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

using file = await openFile('data.txt');
// Avtomatik yopiladi

const set1 = new Set([1, 2, 3]);
const set2 = new Set([2, 3, 4]);
console.log(set1.intersection(set2)); // Set(2) {2, 3}
console.log(set1.union(set2)); // Set(4) {1, 2, 3, 4}
console.log(set1.difference(set2)); // Set(1) {1}
console.log(set1.symmetricDifference(set2)); // Set(2) {1, 4}
console.log(set1.isSubsetOf(set2)); // false
console.log(set1.isSupersetOf(set2)); // false
console.log(set1.isDisjointFrom(set2)); // false

const map = new Map();
map.emplace('key', (existing) => {
    if (existing) return existing + 1;
    return 1;
});