TypeScript'da funksiyalarni tiplash: parametrlar, natija va callback turlari

Qisqacha: Funksiya turi — uning shartnomasi: qanday parametrlar oladi va nima qaytaradi. function total(price: number, qty: number): number. TypeScript argumentlar sonini ham tekshiradi: JavaScript jim o'tkazib yuboradigan total(35000) — xato. Ixtiyoriy parametr — qty?: number, standart qiymatli — qty = 1, qolgan hammasi — ...prices: number[]. Funksiyaning o'z turi strelka bilan yoziladi: (price: number) => number.

Bu darsda

• Argumentlar soni va turini TypeScript qanday tekshirishini ko'rasiz.
• Ixtiyoriy, standart qiymatli (default) va rest parametrlarga tur yozasiz.
• Funksiya turini ((x: number) => string) yozasiz va callback'larni tiplaysiz.
• Kamroq parametrli funksiya nega mos kelishini va void ning callback'lardagi nozik qoidasini tushunasiz.
• TypeScript funksiyalarda nimani ushlamasligini bilasiz (map(parseInt)).

Oldin bilishingiz kerak: any, unknown, never, void va object, Parametrlar, argumentlar va default qiymatlar, Funksiya — qiymat: callback va HOF.

1. Nega bu kerak?

Parametrlar darsida bir jadvalni ko'rgan edik va "keyinroq TypeScript bu ishni siz uchun bajaradi" degan edik:

Ikkalasi ham jim xato. Sardorning kassasida bu shunday ko'rinadi:

function totalPrice(price, qty) {
  return price * qty;
}

console.log(totalPrice(35000)); // NaN
console.log(totalPrice(35000, 2, 10)); // 70000

Birinchi chaqiruvda soni unutilgan — NaN. Ikkinchisida kimdir chegirma foizini (10) uchinchi argument qilib berdi. Funksiya uni olmaydi ham, lekin chaqiruvchi "chegirma qo'llandi" deb o'ylaydi.

Funksiya — kodning eng ko'p qayta ishlatiladigan qismi. Uning shartnomasi aniq bo'lsa, xato chaqiruv joyida, kod ishga tushmasdan topiladi. Bugun shu shartnomaning hamma qismlarini yozishni o'rganamiz.

2. Parametr va natija turlari

2.1 Argumentlar soni

Tur annotatsiyasi darsida parametrlarga tur yozishni o'rgandik. Endi Sardorning chaqiruvlari:

function totalPrice(price: number, qty: number): number {
  return price * qty;
}

totalPrice(35000);
totalPrice(35000, 2, 10);

Kompilyator:

TS2554: Expected 2 arguments, but got 1.
TS2554: Expected 2 arguments, but got 3.

Tarjimasi: "2 ta argument kutilgan edi, lekin 1 ta (3 ta) berildi". Bu xabarni TypeScript'ni o'rnatish darsida bir marta ko'rgansiz. TypeScript'da har parametr standart holatda majburiy, ortiqcha argument esa — xato.

2.2 Natija turi — shartnomaning ikkinchi yarmi

function vat(sum: number): number {
  return Math.round(sum * 0.12);
}

console.log(vat(70000)); // 8400

Qavsdan keyingi : number — natija turi. Qachon yozish kerakligini Tur annotatsiyasi darsida aniqlagan edik: boshqa fayllar ishlatadigan (export) funksiyada — doim, ichki yordamchida — ixtiyoriy. Natija turi yozilsa, funksiya ichidagi noto'g'ri return darhol ushlanadi. Hech narsa qaytarmasa — void (o'tgan dars).

Tekshirib ko'ring: function tip(sum: number, percent: number) { return sum * percent / 100; } — tip(70000, "10") va tip(70000) uchun tsc nima deydi?

3. Ixtiyoriy, standart va rest parametrlar

3.1 Ixtiyoriy parametr: ?

Obyekt turlaridagi kabi, parametr nomidan keyingi ? — "berilmasligi mumkin":

function orderLine(dish: string, note?: string): string {
  if (note === undefined) {
    return dish;
  }
  return `${dish} (${note})`;
}

console.log(orderLine("Osh")); // Osh
console.log(orderLine("Manti", "piyozsiz")); // Manti (piyozsiz)

Funksiya ichida note — string | undefined. Tekshiruvsiz ishlatsangiz — o'tgan darslardan tanish TS18048: 'note' is possibly 'undefined'.

Ixtiyoriy parametr faqat majburiylardan keyin turadi:

function orderLine(dish: string, note?: string, qty: number) {
  return `${dish} x${qty} ${note}`;
}

Kompilyator:

TS1016: A required parameter cannot follow an optional parameter.

Tarjimasi: "majburiy parametr ixtiyoriydan keyin kela olmaydi". Argumentlar tartib bilan beriladi: orderLine("Osh", 2) da 2 qaysi parametrga tushishini aniqlab bo'lmasdi.

3.2 Standart qiymat (default)

Ko'pincha "berilmasa — mana bu qiymat" kerak. JavaScript'dagi default qiymat TypeScript'da ham ishlaydi va turni o'zi beradi:

function orderLine(dish: string, qty = 1): string {
  return `${dish} x${qty}`;
}

console.log(orderLine("Osh")); // Osh x1
console.log(orderLine("Somsa", 4)); // Somsa x4

Hover: function orderLine(dish: string, qty?: number): string. Chaqiruvchi uchun qty ixtiyoriy (?), funksiya ichida esa u doim number — undefined bo'lmaydi. Turni 1 qiymatidan TypeScript o'zi chiqardi, shuning uchun qty: number = 1 deb yozish shart emas.

Standart qiymatning turi argument turini ham belgilaydi:

function orderLine(dish: string, qty = 1) {
  return `${dish} x${qty}`;
}

orderLine("Osh", "ikki");

Kompilyator:

TS2345: Argument of type 'string' is not assignable to parameter of type 'number'.

3.3 Rest parametr: "qolgan hammasi"

Spread va rest darsidagi ... — "nechta bo'lsa ham". Rest parametr har doim massiv, uning turi ham massiv turi:

function sum(...prices: number[]): number {
  return prices.reduce((total, p) => total + p, 0);
}

const order = [35000, 5000];
console.log(sum(), sum(28000), sum(...order)); // 0 28000 40000

...prices: number[] — "qolgan hamma argumentlar sonlar". Har argument tekshiriladi: sum(1, "2") — TS2345. Rest parametr faqat oxirida turadi.

3.4 Parametr — obyekt: destructuring bilan

Parametr ko'p va ularning ko'pi ixtiyoriy bo'lsa, bitta obyekt parametr qulayroq. Tur — butun obyektga, destructuring'dan keyin yoziladi:

function bookingText({
  guest,
  people = 2,
  note,
}: {
  guest: string;
  people?: number;
  note?: string;
}): string {
  const extra = note === undefined ? "" : `, ${note}`;
  return `${guest}: ${people} kishi${extra}`;
}

console.log(bookingText({ guest: "Malika" })); // Malika: 2 kishi

Tuzilishiga e'tibor bering: { guest, people = 2, note } — qiymatlar (destructuring), : { guest: string; … } — tur. Ikkalasini aralashtirib, { guest: string } ni destructuring ichiga yozsangiz, bu JavaScript'da qayta nomlash bo'lib qoladi (guest o'rniga string degan o'zgaruvchi). Shuning uchun tur doim yopuvchi qavsdan keyin.

Tekshirib ko'ring: function greet(name: string, title = "aka") — greet("Dilshod", undefined) qanday natija beradi va tsc nima deydi?

4. Funksiya turi

4.1 Strelka bilan yoziladi

Funksiya ham qiymat — uni o'zgaruvchiga, massivga, parametrga berish mumkin. Demak, uning ham turi bor. U strelka funksiyaga o'xshab yoziladi:

type PriceRule = (price: number) => number;

const halfPrice: PriceRule = (price) => price / 2;
const plusService: PriceRule = (price) => price * 1.1;

console.log(halfPrice(35000), plusService(30000)); // 17500 33000

(price: number) => number — "bitta son oladi, son qaytaradi". Bu yerdagi => — funksiya emas, tur: o'ng tomonda natija turi turadi. Tur yozilgan o'zgaruvchiga berilgan funksiyada price ga tur yozmadik — u turdan chiqarildi (kontekstli tiplash).

Parametr nomi turda faqat hujjat uchun: (p: number) => number ham o'sha tur. Mos kelmaydigan funksiya esa ushlanadi:

type PriceRule = (price: number) => number;

const byName: PriceRule = (price: string) => price.length;

Kompilyator:

TS2322: Type '(price: string) => number' is not assignable to type 'PriceRule'.
  Types of parameters 'price' and 'price' are incompatible.
    Type 'number' is not assignable to type 'string'.

Zanjirni pastdan o'qing: "sonni satrga berib bo'lmaydi" — PriceRule chaqiruvchisi son beradi, funksiya esa satr kutyapti.

4.2 Callback turi

Funksiya turining eng ko'p joyi — callback parametri (HOF darsi):

function applyToMenu(
  prices: readonly number[],
  rule: (price: number) => number,
): number[] {
  return prices.map((price) => rule(price));
}

const menu = [35000, 28000, 30000];
const cheaper = applyToMenu(menu, (p) => p - 5000);
console.log(cheaper); // [ 30000, 23000, 25000 ]

rule: (price: number) => number — parametrning turi — funksiya. Chaqiruvda (p) => p - 5000 ga tur yozmadik: TypeScript uni parametr turidan oldi. Callback'larga tur yozish deyarli hech qachon kerak emas — kontekst yetadi.

4.3 Callback'ni alohida yozsangiz — kontekst yo'qoladi

Kontekst faqat funksiya shu joyda yozilganda ishlaydi. Uni oldindan o'zgaruvchiga olsangiz:

const menu = [35000, 28000];
const minus = (p) => p - 5000;
console.log(menu.map(minus));

Kompilyator:

TS7006: Parameter 'p' implicitly has an 'any' type.

TypeScript aytyapti: «p parametrining turi yashirincha any bo'lib qoldi» — tur yozilmagan, chiqarib ham bo'lmadi, strict rejimi esa bunga ruxsat bermaydi.

const minus = (p) => … qatorida TypeScript hali minus qayerda ishlatilishini bilmaydi. U qatorma-qator, yuqoridan pastga turni chiqaradi va keyingi qatordagi map ga qaramaydi. Ikki tuzatish bor: parametrga tur yozish — (p: number) => p - 5000, yoki o'zgaruvchiga funksiya turini berish — const minus: PriceRule = (p) => p - 5000. Ikkinchisi qulay, agar bir xil shakldagi funksiyalar ko'p bo'lsa: tur bir marta yoziladi, hamma qoidalar unga moslanadi.

4.4 Kamroq parametr — mos

Bu qoida boshida g'alati tuyulishi tabiiy:

type PriceRule = (price: number, index: number) => number;

const free: PriceRule = () => 0;
const half: PriceRule = (price) => price / 2;
console.log(free(35000, 0), half(35000, 1)); // 0 17500

PriceRule ikki parametr beradi, free esa birortasini ham olmaydi — va bu xato emas. Sababi: JavaScript'da ortiqcha argument jim tashlanadi va funksiyaga zarar qilmaydi. [1, 2].forEach((x) => …) — forEach callback'ka uchta argument beradi (element, index, massiv), siz esa bittasini olasiz. TypeScript bu odatni buzmaydi.

Teskarisi — ko'proq parametr kutgan funksiya — xato:

type PriceRule = (price: number) => number;

const withExtra: PriceRule = (price: number, extra: number) =>
  price + extra;

Kompilyator:

TS2322: Type '(price: number, extra: number) => number' is not assignable to type 'PriceRule'.
  Target signature provides too few arguments. Expected 2 or more, but got 1.

Tarjimasi: "Maqsad imzosi juda kam argument beradi: kamida 2 kutilgan, 1 ta berildi". PriceRule ni chaqiradigan kod faqat bitta argument beradi — extra doim undefined bo'lardi.

4.5 void callback: natija e'tiborga olinmaydi

O'tgan darsda aytgan nozik joy. Natija turi void bo'lgan funksiya turi qiymat qaytaradigan funksiyani ham qabul qiladi:

type Logger = (message: string) => void;

const lengthLogger: Logger = (message) => message.length;
const result = lengthLogger("Osh tayyor");
console.log(result); // 10

const saved: number[] = [];
[35000, 5000].forEach((price) => saved.push(price));
console.log(saved); // [ 35000, 5000 ]

Ikkinchi qism — kundalik holat. forEach callback'ining turi void qaytaradi, saved.push(price) esa son (yangi uzunlik) qaytaradi. Agar void "qaytarmaslik shart" degani bo'lsa, bu oddiy kod xato bo'lardi. Shuning uchun funksiya turidagi void — "natijaga qaramayman" degani, "natija bo'lmasin" emas. result ning turi esa void — result.length deb yozib bo'lmaydi, garchi ichida 10 turgan bo'lsa ham.

Funksiya e'lonida natija turi void deb yozilsa — qoida qat'iy:

function logPrice(price: number): void {
  return price;
}

Kompilyator:

TS2322: Type 'number' is not assignable to type 'void'.

TypeScript aytyapti: «number turini void turiga berib bo'lmaydi» — funksiya "hech narsa qaytarmayman" degan, lekin son qaytaryapti.

flowchart TD
  A["Funksiyani funksiya turiga<br/>berish mumkinmi?"] --> B{"Parametrlar turi mosmi?"}
  B -- "yo'q" --> X1["TS2322: Types of parameters<br/>are incompatible"]
  B -- "ha" --> C{"Funksiya turda berilgandan<br/>ko'p parametr kutyaptimi?"}
  C -- "ha" --> X2["TS2322: provides too few<br/>arguments"]
  C -- "yo'q, teng yoki kam" --> D{"Turdagi natija void mi?"}
  D -- "ha" --> OK["Mos — natija e'tiborsiz"]
  D -- "yo'q" --> E{"Natija turi mosmi?"}
  E -- "ha" --> OK2["Mos"]
  E -- "yo'q" --> X3["TS2322"]

Tekshirib ko'ring: type OnPaid = (sum: number, method: string) => void; — const notify: OnPaid = (sum) => console.log(sum); xato beradimi? (sum, method, time) => … chi?

5. TypeScript nimani ushlamaydi

5.1 map(parseInt)

Mashhur JavaScript tuzog'i — TypeScript'da ham jim:

const inputs = ["35", "28", "30"];
console.log(inputs.map(parseInt)); // [ 35, NaN, NaN ]

tsc — xatosiz. Nima bo'ldi? map callback'ka ikki argument beradi: element va indeks. parseInt(text, radix) ikkinchi argumentni sanoq tizimi deb oladi (Matn ↔ son): parseInt("28", 1) — NaN, parseInt("30", 2) — NaN (ikkilikda 3 raqami yo'q). Turlar esa mos: parseInt ning ikkinchi parametri ixtiyoriy son, indeks ham son. TypeScript niyatingizni bilmaydi. Tuzatish: inputs.map((text) => Number(text)) — callback'ni aniq yozing.

5.2 Ixtiyoriy parametr shablon satrda

function formatSum(sum: number, currency?: string): string {
  return `${sum} ${currency}`;
}

console.log(formatSum(35000)); // 35000 undefined

Shablon satrga (${…}) TypeScript istalgan qiymatni, undefined ni ham qo'yishga ruxsat beradi. Chekda "35000 undefined" chiqdi. Tuzatish: ixtiyoriy o'rniga standart qiymat — currency = "so'm". typescript-eslint'ning restrict-template-expressions qoidasi buni ushlaydi, lekin u tur ma'lumotli qoidalar to'plamida (Async kod va xatolarni tiplash darsida ulaymiz).

6. Ko'p uchraydigan xatolar

6.1 Ixtiyoriy parametrni boshiga qo'yish

(note?: string, dish: string) — TS1016. Tuzatish: ixtiyoriylar oxirida yoki bitta obyekt parametr.

6.2 Destructuring ichida tur yozish

function f({ guest: string }) — bu guest ni string deb qayta nomlash, tur emas. strict da TS7031 ("Binding element … implicitly has an 'any' type") chiqadi. Tuzatish: function f({ guest }: { guest: string }).

6.3 ? va default'ni birga yozish

function f(qty?: number = 1) — TS1015: Parameter cannot have question mark and initializer. Default allaqachon parametrni ixtiyoriy qiladi. Tuzatish: qty = 1 yetarli.

6.4 Callback'ka ortiqcha parametr qo'shish

(price, extra) => … ni bitta argument beradigan joyga — TS2322 … provides too few arguments. Tuzatish: qo'shimcha qiymatni closure orqali bering — discount(10) kabi funksiya funksiya qaytarsin (mashqda).

7. Mashqlar

1-mashq (oson): Qaysi chaqiruv to'g'ri?

function reserve(guest: string, people = 2, ...tables: number[]) {
  return `${guest}: ${people} kishi, stollar ${tables.join(", ")}`;
}
const text = reserve("Bobur", 4, 3, 5);
console.log(text); // Bobur: 4 kishi, stollar 3, 5

reserve("Malika") — xato bormi (ha/yo'q): [:yo'q]. reserve() xatosining kodi: TS[:2555]. tables parametrining element turi: .

2-mashq (o'rta): Callback turini yozing

Funksiya buyurtmalarni shart bo'yicha sanaydi. Parametrlarga tur yozing: orders — o'zgarmas massiv, test — buyurtma oladigan va boolean qaytaradigan funksiya.

type Order = { dish: string; price: number; done: boolean };

function countWhere(orders, test) {
  let n = 0;
  for (const order of orders) {
    if (test(order)) n++;
  }
  return n;
}

Kompilyator:

TS7006: Parameter 'orders' implicitly has an 'any' type.
TS7006: Parameter 'test' implicitly has an 'any' type.

type Order = { dish: string; price: number; done: boolean };

function countWhere(
  orders: readonly Order[],
  test: (order: Order) => boolean,
): number {
  let n = 0;
  for (const order of orders) {
    if (test(order)) n++;
  }
  return n;
}

const today: Order[] = [
  { dish: "Osh", price: 35000, done: true },
  { dish: "Manti", price: 30000, done: false },
  { dish: "Lag'mon", price: 28000, done: true },
];
console.log(countWhere(today, (o) => o.done)); // 2
console.log(countWhere(today, (o) => o.price > 29000)); // 2

3-mashq (qiyin): Amaliy tajriba — narx qoidalari

Mashq kurs/mashqlar/15/ da. «Bahor» kassasida narx qoidalari bor: chegirma, yaxlitlash. JavaScript'dan ko'chirilgan 09-funksiyalar/pricing.ts:

// 09-funksiyalar/pricing.ts — «Bahor» narx qoidalari (JS'dan)
export function discount(percent) {
  return (price) => price - (price * percent) / 100;
}

export function applyRules(price, ...rules) {
  return rules.reduce((current, rule) => rule(current), price);
}

export function formatSum(sum, currency) {
  return `${sum.toLocaleString("ru-RU")} ${currency}`;
}

1. npx tsc --pretty false — xatolarni o'qing. Rest parametrning xabari boshqacha — nimasi bilan?
2. export type PriceRule = (price: number) => number; e'lon qiling va hamma funksiyalarga tur yozing. discount natijasi — PriceRule.
3. roundTo(step) qoidasini qo'shing: narxni step ga karrali qilib yaxlitlaydi (Math.round(price / step) * step).
4. formatSum da valyuta ixtiyoriy bo'lsin va berilmasa "so'm" chiqsin. «Ixtiyoriy parametr shablon satrda» bo'limidagi tuzoqqa tushmang.
5. 09-funksiyalar/pricing.test.ts: qoidalar alohida; qoidasiz applyRules; qoidalar tartibi natijani o'zgartirishi; formatSum standart va boshqa valyuta bilan.

09-funksiyalar/pricing.ts(2,26): error TS7006: Parameter 'percent' implicitly has an 'any' type.
09-funksiyalar/pricing.ts(3,11): error TS7006: Parameter 'price' implicitly has an 'any' type.
09-funksiyalar/pricing.ts(6,28): error TS7006: Parameter 'price' implicitly has an 'any' type.
09-funksiyalar/pricing.ts(6,35): error TS7019: Rest parameter 'rules' implicitly has an 'any[]' type.
09-funksiyalar/pricing.ts(10,27): error TS7006: Parameter 'sum' implicitly has an 'any' type.
09-funksiyalar/pricing.ts(10,32): error TS7006: Parameter 'currency' implicitly has an 'any' type.

// 09-funksiyalar/pricing.ts — «Bahor» narx qoidalari
export type PriceRule = (price: number) => number;

// Qoida yasaydigan funksiyalar: natijasi — boshqa funksiya
export function discount(percent: number): PriceRule {
  return (price) => price - (price * percent) / 100;
}

export function roundTo(step: number): PriceRule {
  return (price) => Math.round(price / step) * step;
}

// Qoidalar chapdan o'ngga, ketma-ket qo'llanadi
export function applyRules(
  price: number,
  ...rules: PriceRule[]
): number {
  return rules.reduce((current, rule) => rule(current), price);
}

export function formatSum(sum: number, currency = "so'm"): string {
  return `${sum.toLocaleString("ru-RU")} ${currency}`;
}

// 09-funksiyalar/pricing.test.ts
import { test } from "node:test";
import assert from "node:assert/strict";
import {
  discount,
  roundTo,
  applyRules,
  formatSum,
} from "./pricing.ts";

test("discount va roundTo: qoida — funksiya", () => {
  assert.equal(discount(10)(35000), 31500);
  assert.equal(roundTo(1000)(31500), 32000);
});

test("applyRules: qoidasiz — narx o'zgarmaydi", () => {
  assert.equal(applyRules(35000), 35000);
});

test("applyRules: tartib muhim", () => {
  assert.equal(applyRules(35000, discount(10), roundTo(1000)), 32000);
  assert.equal(applyRules(35000, roundTo(1000), discount(10)), 31500);
});

test("formatSum: standart va boshqa valyuta", () => {
  // ru-RU guruhlash belgisi — uzilmas bo'sh joy, \s uni ham tutadi
  assert.match(formatSum(31500), /^31\s500 so'm$/);
  assert.match(formatSum(5, "UZS"), /^5 UZS$/);
});

✔ discount va roundTo: qoida — funksiya (2.0771ms)
✔ applyRules: qoidasiz — narx o'zgarmaydi (0.4112ms)
✔ applyRules: tartib muhim (0.3209ms)
✔ formatSum: standart va boshqa valyuta (44.7433ms)
ℹ tests 4
ℹ suites 0
ℹ pass 4
ℹ fail 0
ℹ cancelled 0
ℹ skipped 0
ℹ todo 0
ℹ duration_ms 428.7857

git add 15/09-funksiyalar 15/XATOLAR.md
git commit -m "15/09: pricing.ts — funksiya turlari, rest, default"

8. Real ishda

• Hodisa ishlovchilari — callback turlarining kundalik joyi: button.addEventListener("click", (event) => …) — event ning turini (PointerEvent — MouseEvent ning kengaytmasi) TypeScript o'zi biladi (TypeScript va DOM darsida).
• Sozlama obyektli funksiyalar — createOrder({ guest, items, note }): ixtiyoriy parametrlar ko'p bo'lsa, ommaviy kutubxonalar (fetch, Intl) aynan shunday qiladi.
• Funksiya turlari — "strategiya" uslubi: PriceRule, Validator, Formatter kabi turlar qoidalarni almashtiriladigan qiladi. React'da (17-qismdan) komponentga beriladigan onClick, onChange — ham funksiya turlari.
• Intervyu: "Nega kamroq parametrli funksiya mos keladi?", "void callback qiymat qaytarsa nima bo'ladi?", "["1","2","3"].map(parseInt) nima beradi?" — mashhur savollar.

Xulosa

• Parametr va natija turlari — funksiya shartnomasi. Argumentlar soni ham tekshiriladi (TS2554).
• x?: T — ixtiyoriy (ichkarida T | undefined), x = qiymat — standart (ichkarida doim T), ...xs: T[] — rest. Ixtiyoriylar majburiylardan keyin.
• Funksiya turi: (price: number) => number. Callback parametrlariga tur odatda kontekstdan keladi.
• Kamroq parametrli funksiya mos keladi, ko'prog'i — yo'q. Funksiya turidagi void — "natijaga qaramayman".
• TypeScript niyatni bilmaydi: map(parseInt) va shablon satrdagi undefined jim o'tadi.

Keyingi dars: Strukturaviy tiplash — TypeScript'da tur nomi emas, shakli muhim: nega Vazifa klassi VazifaMalumoti kutilgan joyga bemalol beriladi.

Manbalar

• TypeScript Handbook: "More on Functions" (Function Type Expressions, Optional Parameters, Rest Parameters, Assignability of Functions) — typescriptlang.org/docs/handbook/2/functions.html
• TypeScript FAQ: "Why are functions with fewer parameters assignable to functions that take more parameters?" — github.com/microsoft/TypeScript/wiki/FAQ
• MDN: parseInt va Array.prototype.map — developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/parseInt
• typescript-eslint: restrict-template-expressions — typescript-eslint.io/rules/restrict-template-expressions