Sertifikat olingYANGIW3Schools ilovasiiOS va AndroidSarguzashtni boshlang

TypeScript tip tekshiruvlari (type guards)

ULASHISH

TypeScript-da turdagi himoyachilarni tushunish

TypeScript Type Guards ma’lum bir doirada o‘zgaruvchining turini toraytirish imkonini beruvchi kuchli konstruktsiyalardir.

Ular ish vaqtida o‘zgaruvchining o‘ziga xos turini aniqlaydigan aniq tekshiruvlarni taqdim etish orqali TypeScript-ga turdagi xavfsizligini tushunish va qo‘llashga yordam beradi.

Nima uchun turdagi himoya vositalaridan foydalanish kerak?

  • Type Safety : Operatsiyalar faqat tegishli turlarda bajarilishiga ishonch hosil qiling
  • Code Clarity : Turni tekshirishni aniq va o‘z-o‘zidan hujjatlashtirish
  • Yaxshiroq vositalar: aniq IntelliSense va kodni avtomatik to‘ldirish
  • Error Prevention : Kompilyatsiya vaqtida turga bog‘liq xatolarni aniqlang
  • Runtime Safety : Ishlash vaqtida turdagi tekshiruvning qo‘shimcha qatlamini qo‘shing

Himoya naqshlarini yozing

  • typeof tipidagi soqchilar
  • instanceof Soqchilar turi
  • Turi predikatlari bilan foydalanuvchi tomonidan belgilangan turdagi himoyachilar
  • Literal turlarga ega bo‘lgan diskriminatsiyalangan uyushmalar
  • in operator tipidagi qo‘riqchilar
  • Tasdiqlash funksiyalarini yozing

typeof tipidagi soqchilar

typeof operatori ish vaqtida ibtidoiy qiymat turini tekshiradigan o‘rnatilgan turdagi himoyachidir.

Bu, ayniqsa, stringlar, raqamlar, mantiqiy va boshqalar kabi ibtidoiy turlarni toraytirish uchun foydalidir.

Asosiy foydalanish

Shartli novdalar ichidagi ibtidoiy birlashmalarni toraytirish uchun typeof cheklardan foydalaning.

Misol

// Simple type guard with typeof
function formatValue(value: string | number): string {
  if (typeof value === 'string') {
    // TypeScript knows value is string here
    return value.trim().toUpperCase();
  } else {
    // TypeScript knows value is number here
    return value.toFixed(2);
  }
}

// Example usage
const result1 = formatValue('  hello  ');  // "HELLO"
const result2 = formatValue(42.1234);      // "42.12"
O‘zingiz sinab ko‘ring »

Yuqoridagi misolda TypeScript if operatorining turli tarmoqlaridagi value turini tushunadi.

instanceof Soqchilar turi

instanceof operatori obyekt muayyan class yoki konstruktor funksiyasining namunasi ekanligini tekshiradi.

Bu maxsus classlar yoki o‘rnatilgan obyektlar bilan turlarni toraytirish uchun foydalidir.

Sinfga asoslangan turdagi himoya

Konstruktorni instanceof bilan tekshirish orqali class misollarining tor birlashmalari.

Misol

class Bird {
  fly() {
    console.log("Flying...");
   }
}

class Fish {
  swim() {
    console.log("Swimming...");
   }
}

function move(animal: Bird | Fish) {
  if (animal instanceof Bird) {
    // TypeScript knows animal is Bird here
    animal.fly();
  } else {
    // TypeScript knows animal is Fish here
    animal.swim();
  }
}
O‘zingiz sinab ko‘ring »

Foydalanuvchi tomonidan belgilangan turdagi qo‘riqchilar

Turni yanada murakkab tekshirish uchun siz turdagi predikatlar yordamida maxsus turdagi himoya funksiyalarini yaratishingiz mumkin.

Bular parameterName is Type ko‘rinishidagi turdagi predikatni qaytaruvchi funksiyalardir.

Predikat funksiyalarini yozing

value is Type kabi predikatni qaytaring, shunda TypeScript haqiqiy novdada torayadi.

Misol

interface Car {
  make: string;
  model: string;
  year: number;
}

interface Motorcycle {
  make: string;
  model: string;
  year: number;
  type: "sport" | "cruiser";
}

// Type predicate function
function isCar(vehicle: Car | Motorcycle): vehicle is Car {
  return (vehicle as Motorcycle).type === undefined;
}

function displayVehicleInfo(vehicle: Car | Motorcycle) {
  console.log(`Make: ${vehicle.make}, Model: ${vehicle.model}, Year: ${vehicle.year}`);

  if (isCar(vehicle)) {
    // TypeScript knows vehicle is Car here
    console.log("This is a car");
  } else {
    // TypeScript knows vehicle is Motorcycle here
    console.log(`This is a ${vehicle.type} motorcycle`);
  }
}
O‘zingiz sinab ko‘ring »

Funksiya imzosi vehicle is Car - bu funksiya rost bo‘lganda, TypeScript-ga turni toraytirishni bildiruvchi turdagi predikatdir.

Diskriminatsiyalangan uyushmalar

Ajratiladigan union’lar (discriminated unions, tegli union’lar deb ham ataladi) union ichidagi turli obyekt tiplarini farqlash uchun umumiy xususiyatdan (diskriminantdan) foydalanadi.

Ushbu naqsh, ayniqsa, turdagi himoyachilar bilan birlashganda kuchli.

Asosiy diskriminatsiyalangan union

Umumiy literal xususiyat (masalan, kind) bo‘yicha switch qiling va tipni aniq variantgacha toraytiring.

Misol

interface Circle {
  kind: "circle";
  radius: number;
}

interface Square {
  kind: "square";
  sideLength: number;
}

type Shape = Circle | Square;

function calculateArea(shape: Shape) {
  switch (shape.kind) {
    case "circle":
      // TypeScript knows shape is Circle here
      return Math.PI * shape.radius ** 2;
    case "square":
      // TypeScript knows shape is Square here
      return shape.sideLength ** 2;
  }
}
O‘zingiz sinab ko‘ring »

kind xossasi shakl turini aniqlash uchun diskriminant sifatida ishlatiladi.

in operatori

in operatori obyektda xususiyat mavjudligini tekshiradi.

Bu, ayniqsa, har xil turlar o‘ziga xos xususiyatlarga ega bo‘lgan birlashma turlarini qisqartirish uchun foydalidir.

Xususiyat mavjudligini tekshirish

Ajratib turuvchi xususiyat mavjudligini tekshirish orqali kasaba uyushma a’zolarini tor.

Misol

interface Dog {
  bark(): void;
}

interface Cat {
  meow(): void;
}

function makeSound(animal: Dog | Cat) {
  if ("bark" in animal) {
    // TypeScript knows animal is Dog here
    animal.bark();
  } else {
    // TypeScript knows animal is Cat here
    animal.meow();
  }
}
O‘zingiz sinab ko‘ring »

Tasdiqlash funksiyalarini yozing

Turni tasdiqlash funksiyalari - bu turni tasdiqlash muvaffaqiyatsiz bo‘lsa, xatoga yo‘l qo‘yishi mumkin bo‘lgan maxsus turdagi himoya turi.

Ular ish vaqtida ma’lumotlarni tekshirish uchun foydalidir.

Tasdiqlash funksiyalari

Turlarni toraytiradigan va noto‘g‘ri kiritishga olib keladigan ish vaqti tekshiruvlarini kodlash.

Misol

// Type assertion function
function assertIsString(value: unknown): asserts value is string {
  if (typeof value !== 'string') {
    throw new Error('Value is not a string');
  }
}

// Type assertion function with custom error
function assert(condition: unknown, message: string): asserts condition {
  if (!condition) {
    throw new Error(message);
  }
}

// Usage
function processInput(input: unknown) {
  assertIsString(input);
  // input is now typed as string
  console.log(input.toUpperCase());
}

// With custom error
function processNumber(value: unknown): number {
  assert(typeof value === 'number', 'Value must be a number');
  // value is now typed as number
  return value * 2;
}
O‘zingiz sinab ko‘ring »

Eng yaxshi amaliyotlar

Har bir turdagi himoyani qachon ishlatish kerak

  • Primitiv tiplar uchun typeof’dan foydalaning (string, number, boolean va h.k.)
  • Class misollari va o‘rnatilgan obyektlar uchun instanceof dan foydalaning
  • Murakkab tekshirish mantig‘i uchun foydalanuvchi tomonidan belgilangan turdagi himoya vositalaridan foydalaning
  • Umumiy diskriminant bilan bog‘liq turlar uchun kamsitilgan uyushmalardan foydalaning
  • Xususiyat mavjudligini tekshirish uchun in operatoridan foydalaning
  • Xatolar bilan ishlash vaqtini tekshirish uchun turdagi tasdiqlash funksiyalaridan foydalaning

Ishlash bo‘yicha mulohazalar

  • typeof va instanceof juda tez
  • Ishlash juda muhim bo‘lsa, foydalanuvchi tomonidan belgilangan turdagi himoya vositalarida murakkab mantiqdan qoching
  • Bir necha marta ishlatiladigan qimmat cheklar uchun turdagi predikatlardan foydalanishni o‘ylab ko‘ring

‹ OrqagaKeyingisi

W3Schools Pathfinder

Yutuqlaringizni kuzating – bu bepul!

Ro'yxatdan o'tishKirish