function add(a: number, b: number): number {
  return a + b;
}
add("2", 3); // TS не даст передать строку вместо числа

class Animal {
  move() {
    console.log('Moving');
  }
}

class Dog extends Animal {
  bark() {
    console.log('Woof!');
  }
}

const dog = new Dog();
dog.move(); // Moving
dog.bark(); // Woof!

interface Flyable {
  fly(): void;
}

class Bird implements Flyable {
  fly() {
    console.log('Flying');
  }
}

async function getFastestData() {
  try {
    const api1 = fetch('https://api1.example.com/data');
    const api2 = fetch('https://api2.example.com/data');
    const api3 = fetch('https://api3.example.com/data');

    const winner = await Promise.race([api1, api2, api3]);
    console.log('Самый быстрый API:', await winner.json());
  } catch (error) {
    console.error('Ошибка:', error);
  }
}

function timeout(ms) {
  return new Promise((_, reject) => {
    setTimeout(() => reject(new Error('Время ожидания истекло!')), ms);
  });
}

async function getDataWithTimeout() {
  try {
    const dataPromise = fetch('https://api.example.com/data');
    const result = await Promise.race([dataPromise, timeout(5000)]);
    console.log('Данные:', await result.json());
  } catch (error) {
    console.error('Ошибка:', error.message);
  }
}

getDataWithTimeout();

Объекты базового класса должны быть заменяемыми объектами производного класса без нарушения корректности программы.

class Payment {
  process(amount) {
    return `Обработка платежа на ${amount} рублей`;
  }
}

class CreditCardPayment extends Payment {
  process(amount) {
    return `Оплата ${amount} рублей картой`;
  }
}

class CashPayment extends Payment {
  process(amount) {
    throw new Error("Оплата наличными онлайн не поддерживается!");
  }
}

// Использование
function makePayment(payment, amount) {
  console.log(payment.process(amount));
}

const creditCard = new CreditCardPayment();
const cash = new CashPayment();

makePayment(creditCard, 100); // "Оплата 100 рублей картой"
makePayment(cash, 100);       // Ошибка: Оплата наличными онлайн не поддерживается!

class Payment {
  process(amount) {
    throw new Error("Метод должен быть переопределён");
  }
}

class OnlinePayment extends Payment {
  process(amount) {
    return `Онлайн-оплата на ${amount} рублей`;
  }
}

class CreditCardPayment extends OnlinePayment {
  process(amount) {
    return `Онлайн-оплата картой на ${amount} рублей`;
  }
}

class OfflinePayment extends Payment {
  process(amount) {
    return `Офлайн-оплата на ${amount} рублей`;
  }
}

class CashPayment extends OfflinePayment {
  process(amount) {
    return `Оплата наличными в кассе на ${amount} рублей`;
  }
}

// Использование
function makePayment(payment, amount) {
  console.log(payment.process(amount));
}

const creditCard = new CreditCardPayment();
const cash = new CashPayment();

makePayment(creditCard, 100); // "Онлайн-оплата картой на 100 рублей"
makePayment(cash, 100);       // "Оплата наличными в кассе на 100 рублей"

const arr = [1, [2, 3], [4, [5]]];
console.log(arr.flat()); // [1, 2, 3, 4, [5]]

const arr = [1, [2, 3], [4, [5, [6]]]];
console.log(arr.flat(2)); // [1, 2, 3, 4, 5, [6]]

const arr = [1, [2, [3, [4, [5]]]]];
console.log(arr.flat(Infinity)); // [1, 2, 3, 4, 5]

string.padStart(targetLength, padString)

const num = '42';
console.log(num.padStart(5, '0')); // "00042"

const day = '7';
const month = '3';
console.log(day.padStart(2, '0')); // "07"
console.log(month.padStart(2, '0')); // "03"
// Получаем: "03.07"

interface Device {
  print(doc: string): void;
  scan(doc: string): void;
  fax(doc: string): void;
}

class SimplePrinter implements Device {
  print(doc: string): void {
    console.log(`Печатаю: ${doc}`);
  }
  scan(doc: string): void {
    throw new Error('Не поддерживает сканирование');
  }
  fax(doc: string): void {
    throw new Error('Не поддерживает факс');
  }
}

interface Printable {
  print(doc: string): void;
}
interface Scannable {
  scan(doc: string): void;
}
interface Faxable {
  fax(doc: string): void;
}

class SimplePrinter implements Printable {
  print(doc: string): void {
    console.log(`Печатаю: ${doc}`);
  }
}

const users = [
  { name: "Аня", age: 25, city: "Москва" },
  { name: "Иван", age: 30, city: "Москва" },
  { name: "Оля", age: 22, city: "Казань" },
  { name: "Петя", age: 30, city: "Казань" },
];

const byCity = Object.groupBy(users, user => user.city);
console.log(byCity);
// {
//   "Москва": [ { name: "Аня", age: 25 }, { name: "Иван", age: 30 } ],
//   "Казань": [ { name: "Оля", age: 22 }, { name: "Петя", age: 30 } ]
// }

const byAge = Map.groupBy(users, user => user.age);
console.log(byAge);
// Map(3) {
//   25 => [ { name: "Аня", age: 25 } ],
//   30 => [ { name: "Иван", age: 30 }, { name: "Петя", age: 30 } ],
//   22 => [ { name: "Оля", age: 22 } ]
// }

{condition && <div>Component</div>}

{condition || secondCondition && <div>Component</div>}

{condition || (secondCondition && <div>Component</div>)}

{(condition || secondCondition) && <div>Component</div>}

{condition || secondCondition ? <div>Component</div> : null}

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

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

const ws = new WebSocket('wss://example.com');
ws.onmessage = event => resolve(event.data);
ws.onerror = error => reject(error);

promise
.then(data => console.log('Получено:', data))
.catch(error => console.error('Ошибка:', error));

let resolve, reject;
const promise = new Promise((res, rej) => {
  resolve = res;
  reject = rej;
});

function App() {
  const [count, setCount] = useState(0);

  useEffect(() => {
    console.log("Effect:", count);
  }, [count]);

  const handleClick = () => {
    setCount(count + 1);
    setCount(count + 1);
    setCount(count + 1);
  };

  return (
    <div>
      <p>Count: {count}</p>
      <button onClick={handleClick}>+3</button>
    </div>
  );
}

function App() {
  const [count, setCount] = useState(0);

  useEffect(() => {
    console.log("Effect:", count);
  }, [count]);

  const handleClick = () => {
    setCount(prev => prev + 1);
    setCount(prev => prev + 1);
    setCount(prev => prev + 1);
  };

  return (
    <div>
      <p>Count: {count}</p>
      <button onClick={handleClick}>+3</button>
    </div>
  );
}

<style>
  .wrapper {
    display: grid;
    grid-template-columns: 1fr 1fr;
    gap: 16px;
  }

  .inner {
    display: contents;
  }

  p {
    background: lightblue;
    padding: 10px;
  }
</style>

<div class="wrapper">
  <div class="inner">
    <p>Привет</p>
    <p>Мир</p>
  </div>
</div>

class Database {
  save(data: string): void {
    console.log(`Сохранено в базе: ${data}`);
  }
}

class UserService {
  private db = new Database();

  saveUser(user: string): void {
    this.db.save(user);
  }
}

const service = new UserService();
service.saveUser("Alice"); // Сохранено в базе: Alice

interface Storage {
  save(data: string): void;
}

class Database implements Storage {
  save(data: string): void {
    console.log(`Сохранено в базе: ${data}`);
  }
}

class FileStorage implements Storage {
  save(data: string): void {
    console.log(`Сохранено в файл: ${data}`);
  }
}

class UserService {
  constructor(private storage: Storage) {}

  saveUser(user: string): void {
    this.storage.save(user);
  }
}

const dbService = new UserService(new Database());
dbService.saveUser("Alice"); // Сохранено в базе: Alice

const fileService = new UserService(new FileStorage());
fileService.saveUser("Bob"); // Сохранено в файл: Bob

const users = [
  { name: 'Алиса', age: 21 },
  { name: 'Макс', age: 25 },
  { name: 'Ваня', age: 21 },
];

groupBy(users, user => user.age);
// Результат:
// {
//   21: [{ name: 'Алиса', age: 21 }, { name: 'Ваня', age: 21 }],
//   25: [{ name: 'Макс', age: 25 }]
// }

function groupBy(array, fn) {
  return array.reduce((acc, item) => {
    const key = fn(item);
    (acc[key] ||= []).push(item);
    return acc;
  }, {});
}