Funksiya turlari

Funksiya - dasturda turlar eng ko'p foyda keltiradigan joy. U qanday ma'lumot qabul qilishini va nima qaytarishini bir qarashda aytib turadi.

Bu bobda yana bir kutilmagan qoida bor - void bilan bog'liq.

Parametr va qaytish turi #

function chegirma(narx: number, foiz: number): number {
  return narx - (narx * foiz) / 100;
}

console.log(chegirma(50000, 20));

tsx src/asos.ts

40000

(narx: number, foiz: number): number - qavs ichida parametrlar, qavsdan keyin qaytish turi.

Qaytish turini yozish shartmi? #

Yozmasangiz, TypeScript uni o'zi xulosa qiladi:

function sarlavha() {
  return 42;
}

const s: string = sarlavha();

tsc --noEmit 2>&1 | fold -sw 74

src/xulosa.ts(5,7): error TS2322: Type 'number' is not assignable to type
'string'.

Xato 5-qatorda - ishlatilgan joyda. Endi qaytish turini yozib qo'yamiz:

function sarlavha(): string {
  return 42;
}

tsc --noEmit 2>&1 | fold -sw 74

src/xulosa2.ts(2,3): error TS2322: Type 'number' is not assignable to
type 'string'.

Xato 2-qatorda - muammo tug'ilgan joyda.

Ixtiyoriy va standart parametrlar #

function salom(ism: string, unvon?: string): string {
  return unvon ? `${unvon} ${ism}` : ism;
}

function narxla(narx: number, valyuta: string = "som"): string {
  return `${narx} ${valyuta}`;
}

console.log(salom("Husanboy"));
console.log(salom("Husanboy", "Admin"));
console.log(narxla(12000));
console.log(narxla(12000, "USD"));

tsx src/param.ts

Husanboy
Admin Husanboy
12000 som
12000 USD

Standart qiymatli parametrda ? yozilmaydi va turi undefined bo'lmaydi - qiymat doim bor.

Argument soni tekshiriladi #

JavaScript da ortiqcha argument e'tiborsiz qoladi, yetishmagani undefined bo'ladi. TypeScript da ikkalasi ham xato:

function chegirma(narx: number, foiz: number): number {
  return narx;
}

chegirma(50000);
chegirma(50000, 20, 30);

tsc --noEmit 2>&1 | fold -sw 74

src/soni.ts(5,1): error TS2554: Expected 2 arguments, but got 1.
src/soni.ts(6,21): error TS2554: Expected 2 arguments, but got 3.

Ixtiyoriy parametr majburiysidan oldin kelolmaydi - aks holda qaysi argument qayerga tushishini aniqlab bo'lmaydi:

function yomon(a?: number, b: number) {
  return 0;
}

tsc --noEmit 2>&1 | fold -sw 74

src/tartib.ts(1,28): error TS1016: A required parameter cannot follow an
optional parameter.

Qolgan parametrlar #

function jami(...sonlar: number[]): number {
  return sonlar.reduce((a, b) => a + b, 0);
}

console.log(jami());
console.log(jami(1, 2, 3));
console.log(jami(...[10, 20, 30]));

tsx src/qolgan.ts

0
6
60

...sonlar ning turi massiv bo'lishi shart - number[], ya'ni "nechta bo'lsa ham, har biri son".

Funksiya turi ifodasi #

Funksiyaning o'zini ham tur sifatida yozish mumkin:

type Formatla = (narx: number) => string;

const somda: Formatla = (n) => `${n} som`;
const dollarda: Formatla = (n) => `$${(n / 12500).toFixed(2)}`;

function chop(narx: number, f: Formatla): void {
  console.log(f(narx));
}

chop(12000, somda);
chop(12000, dollarda);

tsx src/tur.ts

12000 som
$0.96

(narx: number) => string - "son qabul qilib, satr qaytaradigan funksiya". Bu yerda => tur yozuvi, strelkali funksiya emas.

E'tibor bering: somda va dollarda ichida n ga hech qanday tur yozilmagan.

Kontekstli turlash #

TypeScript funksiyaning qayerga berilayotganini ko'rib, parametr turini o'zi topadi:

const mahsulotlar = ["Olma", "Anor"];
mahsulotlar.forEach((m) => console.log(m.toUpperCase()));

tsx src/kontekst.ts

OLMA
ANOR

m ning string ekanini hech kim yozmadi - forEach ning turi shuni aytib turibdi. Va bu xatoni ham tutadi:

const mahsulotlar = ["Olma", "Anor"];
const x = mahsulotlar.map((m) => m * 2);

tsc --noEmit 2>&1 | fold -sw 74

src/kontekst2.ts(2,34): error TS2362: The left-hand side of an arithmetic
operation must be of type 'any', 'number', 'bigint' or an enum type.

3-bobda ko'rgan TS7006 (yashirin any) aynan kontekst yo'qligida chiqadi. Kontekst bo'lsa - annotatsiya kerak emas.

Kutilmagan qoida: void #

void "hech narsa qaytarmaydi" degani. Lekin qiymat qaytaradigan funksiya ham void turiga mos keladi:

type Ishlov = (nomi: string) => void;

const royxat: string[] = [];
const qosh: Ishlov = (nomi) => royxat.push(nomi);

qosh("Olma");
qosh("Anor");
console.log(royxat.length);

tsc --noEmit && echo "tsc: xato yo_q"
tsx src/void1.ts

tsc: xato yo_q
2

royxat.push(nomi) son qaytaradi. Tur esa void deyapti. Xato yo'q.

Ikkinchi yarmi bundan ham qiziq:

type Ishlov = (nomi: string) => void;

const uzunlik: Ishlov = (nomi) => nomi.length;
const natija = uzunlik("Olma");
console.log(natija);

const son: number = uzunlik("Olma");

tsx src/void2.ts
echo "--- tsc ---"
tsc --noEmit 2>&1 | fold -sw 74

4
--- tsc ---
src/void2.ts(7,7): error TS2322: Type 'void' is not assignable to type
'number'.

Ish vaqtida 4 qaytdi. Tur tizimi esa "bu void" deb turibdi va uni songa berishga ruxsat bermadi.

E'lon qilingan void da esa return qiymat bilan kelolmaydi:

function hech(): void {
  return 42;
}

tsc --noEmit 2>&1 | fold -sw 74

src/void3.ts(2,3): error TS2322: Type 'number' is not assignable to type
'void'.

const yangi: string[] = [];
eski.forEach((m) => yangi.push(m));

Parametr soni: kam bo'lishi mumkin, ko'p bo'lishi yo'q #

type Ishlov = (nomi: string, indeks: number) => void;

const oddiy: Ishlov = (nomi) => console.log(nomi);
oddiy("Olma", 0);

tsx src/kam.ts

Olma

Ikkita parametr kutilayotgan joyga bitta parametrli funksiya berildi - va bu to'g'ri. Aynan shu sabab forEach((m) => ...) deb yozganda indeks va massivni tashlab ketish mumkin.

Teskarisi esa ishlamaydi:

type Bir = (nomi: string) => void;

const kop: Bir = (nomi: string, indeks: number) => {
  console.log(nomi, indeks);
};

tsc --noEmit 2>&1 | fold -sw 74

src/kop.ts(3,7): error TS2322: Type '(nomi: string, indeks: number) =>
void' is not assignable to type 'Bir'.
  Target signature provides too few arguments. Expected 2 or more, but
got 1.

Mantiq oddiy: chaqiruvchi bitta argument beradi, funksiya esa ikkitasini kutadi - ikkinchisi doim undefined bo'lardi.

Ortiqcha yuklash #

Bir funksiya turli argumentlarda turli natija qaytarsa:

function qidir(id: number): string;
function qidir(nomi: string): number;
function qidir(x: number | string): string | number {
  return typeof x === "number" ? "Olma" : 12000;
}

const a = qidir(1);
const b = qidir("Olma");
console.log(a, b);

tsx src/yukla.ts

Olma 12000

a ning turi string, b niki number - aralash string | number emas. Uchinchi qator - amalga oshirish imzosi, u tashqaridan chaqirilmaydi:

function qidir(id: number): string;
function qidir(nomi: string): number;
function qidir(x: number | string): string | number {
  return typeof x === "number" ? "Olma" : 12000;
}

qidir(true);

tsc --noEmit 2>&1 | fold -sw 74

src/yukla2.ts(7,7): error TS2769: No overload matches this call.
  Overload 1 of 2, '(id: number): string', gave the following error.
    Argument of type 'boolean' is not assignable to parameter of type
'number'.
  Overload 2 of 2, '(nomi: string): number', gave the following error.
    Argument of type 'boolean' is not assignable to parameter of type
'string'.

boolean amalga oshirish imzosiga mos kelmasa ham, TypeScript faqat ikkita e'lon qilingan variantni tekshiradi.

never qaytaruvchi funksiya #

function xatoBer(xabar: string): never {
  throw new Error(xabar);
}

function tekshir(n: number): string {
  if (n < 0) xatoBer("manfiy son");
  return "yaxshi";
}

console.log(tekshir(5));

tsx src/never.ts

yaxshi

never - "bu funksiya hech qachon normal tugamaydi". U yo xato tashlaydi, yo abadiy ishlaydi. void bilan aralashtirmang: void funksiya tugaydi, shunchaki qiymat qaytarmaydi.

Obyekt ichidagi funksiyalar #

type Dokon = {
  nomi: string;
  narxla(mahsulot: string): number;
  chegirma: (narx: number) => number;
};

const d: Dokon = {
  nomi: "Dokon",
  narxla(m) {
    return m.length * 1000;
  },
  chegirma: (n) => n * 0.9,
};

console.log(d.narxla("Olma"), d.chegirma(10000));

tsx src/metod.ts

4000 9000

Ikkala yozuv ham ishlaydi:

Farqi deyarli yo'q; metod yozuvi obyekt metodlariga ko'proq mos tushadi. narxla(m) da m ning turi yana kontekstdan olindi.

Xulosa #

• Funksiyada parametr turlari qavs ichida, qaytish turi qavsdan keyin yoziladi.
• Qaytish turini yozib qo'yish xatoni manbada ko'rsatadi, ishlatilgan joyda emas.
• ? ixtiyoriy parametrni belgilaydi; standart qiymatli parametrda ? kerak emas va turi undefined bo'lmaydi.
• Ixtiyoriy parametr majburiysidan oldin kelolmaydi (TS1016).
• Argument soni qat'iy tekshiriladi - kam ham, ko'p ham xato (TS2554).
• ...qolgan: T[] cheksiz argument qabul qiladi; uning turi massiv bo'lishi shart.
• (a: number) => string - funksiya turi ifodasi; bu yerdagi => tur yozuvi.
• Kontekstli turlash: funksiya qayerga berilayotgani parametr turlarini o'zi aniqlaydi - forEach((m) => ...).
• void turiga qiymat qaytaradigan funksiyani berish mumkin, lekin natijani qiymat sifatida olish mumkin emas.
• void deb e'lon qilingan funksiyaning o'zi esa qiymat qaytarolmaydi.
• Kam parametrli funksiya ko'p parametrli turga mos keladi; teskarisi yo'q.
• Ortiqcha yuklashda amalga oshirish imzosi tashqaridan chaqirilmaydi; never esa normal tugamaydigan funksiya.