M

MLOG

Eesti

Uurige TypeScripti tüübivalvureid ja tüübikinnitusi, et parandada tüübiohutust, vältida käitusviga ning kirjutada vastupidavamat ja hooldatavamat koodi. Õppige praktiliste näidete ja parimate praktikate abil.

Tüübiohutuse meisterlikkus: põhjalik juhend tüübivalvuritele ja tüübikinnitustele

Tarkvaraarenduse valdkonnas, eriti dünaamiliselt tüübitud keeltega nagu JavaScript töötades, võib tüübiohutuse säilitamine olla märkimisväärne väljakutse. TypeScript, JavaScripti superkomplekt, lahendab selle mure, tuues sisse staatilise tüüpimise. Kuid isegi TypeScripti tüübisüsteemiga tekib olukordi, kus kompilaator vajab abi muutuja õige tüübi järeldamisel. Siin tulevad mängu tüübivalvurid ja tüübikinnitused. See põhjalik juhend süveneb nendesse võimsatesse funktsioonidesse, pakkudes praktilisi näiteid ja parimaid praktikaid teie koodi usaldusväärsuse ja hooldatavuse parandamiseks.

Mis on tüübivalvurid?

Tüübivalvurid on TypeScripti avaldised, mis kitsendavad muutuja tüüpi teatud skoobis. Need võimaldavad kompilaatoril mõista muutuja tüüpi täpsemalt, kui see esialgu järeldas. See on eriti kasulik, kui tegeletakse liittüüpidega või kui muutuja tüüp sõltub käitusaegsetest tingimustest. Tüübivalvureid kasutades saate vältida käitusvigu ja kirjutada robustsemat koodi.

Levinud tüübivalvurite tehnikad

TypeScript pakub mitmeid sisseehitatud mehhanisme tüübivalvurite loomiseks:

typeof-i kasutamine

typeof-operaator on otsekohene viis muutuja primitiivse tüübi kontrollimiseks. See tagastab stringi, mis näitab tüüpi.

function printValue(value: string | number) {
  if (typeof value === "string") {
    console.log(value.toUpperCase()); // TypeScript teab, et 'value' on siin string
  } else {
    console.log(value.toFixed(2)); // TypeScript teab, et 'value' on siin number
  }
}

printValue("hello"); // Väljund: HELLO
printValue(3.14159); // Väljund: 3.14

instanceof-i kasutamine

instanceof-operaator kontrollib, kas objekt on teatud klassi eksemplar. See on eriti kasulik pärilusega töötamisel.

class Animal {
  name: string;
  constructor(name: string) {
    this.name = name;
  }
}

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

function makeSound(animal: Animal) {
  if (animal instanceof Dog) {
    animal.bark(); // TypeScript teab, et 'animal' on siin Dog
  } else {
    console.log("Üldine looma häälitsus");
  }
}

const myDog = new Dog("Buddy");
const myAnimal = new Animal("Generic Animal");

makeSound(myDog); // Väljund: Woof!
makeSound(myAnimal); // Väljund: Üldine looma häälitsus

in-i kasutamine

in-operaator kontrollib, kas objektil on konkreetne omadus. See on kasulik objektidega tegelemisel, millel võivad olla erinevad omadused sõltuvalt nende tüübist.

interface Bird {
  fly(): void;
  layEggs(): void;
}

interface Fish {
  swim(): void;
  layEggs(): void;
}

function move(animal: Bird | Fish) {
  if ("fly" in animal) {
    animal.fly(); // TypeScript teab, et 'animal' on siin Bird
  } else {
    animal.swim(); // TypeScript teab, et 'animal' on siin Fish
  }
}

const myBird: Bird = { fly: () => console.log("Lendab"), layEggs: () => console.log("Muneb mune") };
const myFish: Fish = { swim: () => console.log("Ujub"), layEggs: () => console.log("Muneb mune") };

move(myBird); // Väljund: Lendab
move(myFish); // Väljund: Ujub

Kohandatud tüübivalvuri funktsioonid

Keerukamate stsenaariumide jaoks saate defineerida oma tüübivalvuri funktsioone. Need funktsioonid tagastavad tüübipredikaadi, mis on tõeväärtusavaldise, mida TypeScript kasutab muutuja tüübi kitsendamiseks. Tüübipredikaat on kujul muutuja on Tüüp.

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

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

type Shape = Square | Circle;

function isSquare(shape: Shape): shape is Square {
  return shape.kind === "square";
}

function getArea(shape: Shape) {
  if (isSquare(shape)) {
    return shape.size * shape.size; // TypeScript teab, et 'shape' on siin Square
  } else {
    return Math.PI * shape.radius * shape.radius; // TypeScript teab, et 'shape' on siin Circle
  }
}

const mySquare: Square = { kind: "square", size: 5 };
const myCircle: Circle = { kind: "circle", radius: 3 };

console.log(getArea(mySquare)); // Väljund: 25
console.log(getArea(myCircle)); // Väljund: 28.274333882308138

Mis on tüübikinnitused?

Tüübikinnitused on viis öelda TypeScripti kompilaatorile, et teate muutuja tüübi kohta rohkem, kui see hetkel mõistab. Need on viis TypeScripti tüübijärelduse ülekirjutamiseks ja väärtuse tüübi selgesõnaliseks määramiseks. Siiski on oluline kasutada tüübikinnitusi ettevaatlikult, kuna need võivad TypeScripti tüübikontrollist mööda minna ja valesti kasutamisel potentsiaalselt põhjustada käitusvigu.

Tüübikinnitustel on kaks vormi:

as-võtmesõna on üldiselt eelistatud, kuna see on JSX-iga paremini ühilduv.

Millal kasutada tüübikinnitusi

Tüübikinnitusi kasutatakse tavaliselt järgmistes stsenaariumides:

Tüübikinnituste näited

Selgesõnaline tüübikinnitus

Selles näites kinnitame, et document.getElementById-i kutse tagastab HTMLCanvasElement-i. Ilma kinnituseta järeldaks TypeScript üldisema tüübi HTMLElement | null.

const canvas = document.getElementById("myCanvas") as HTMLCanvasElement;
const ctx = canvas.getContext("2d"); // TypeScript teab, et 'canvas' on siin HTMLCanvasElement

if (ctx) {
  ctx.fillStyle = "#FF0000";
  ctx.fillRect(0, 0, 150, 75);
}

Tundmatute tüüpidega töötamine

Välisest allikast, näiteks API-st, pärinevate andmetega töötades võite saada andmeid tundmatu tüübiga. Saate kasutada tüübikinnitust, et öelda TypeScriptile, kuidas andmeid käsitleda.

interface User {
  id: number;
  name: string;
  email: string;
}

async function fetchUser(id: number): Promise<User> {
  const response = await fetch(`https://jsonplaceholder.typicode.com/users/${id}`);
  const data = await response.json();
  return data as User; // Kinnita, et andmed on User tüüpi
}

fetchUser(1)
  .then(user => {
    console.log(user.name); // TypeScript teab, et 'user' on siin User
  })
  .catch(error => {
    console.error("Viga kasutaja toomisel:", error);
  });

Hoiatused tüübikinnituste kasutamisel

Tüübikinnitusi tuleks kasutada säästlikult ja ettevaatlikult. Tüübikinnituste liigne kasutamine võib varjata aluseks olevaid tüübivigu ja põhjustada käitusaegseid probleeme. Siin on mõned olulised kaalutlused:

Tüübi kitsendamine

Tüübivalvurid on lahutamatult seotud tüübi kitsendamise kontseptsiooniga. Tüübi kitsendamine on protsess, mille käigus täpsustatakse muutuja tüüp spetsiifilisemaks tüübiks, tuginedes käitusaegsetele tingimustele või kontrollidele. Tüübivalvurid on tööriistad, mida kasutame tüübi kitsendamise saavutamiseks.

TypeScript kasutab vooanalüüsi, et mõista, kuidas muutuja tüüp muutub erinevates koodiharudes. Kui kasutatakse tüübivalvurit, uuendab TypeScript oma sisemist arusaama muutuja tüübist, võimaldades teil ohutult kasutada sellele tüübile spetsiifilisi meetodeid ja omadusi.

Tüübi kitsendamise näide

function processValue(value: string | number | null) {
  if (value === null) {
    console.log("Väärtus on null");
  } else if (typeof value === "string") {
    console.log(value.toUpperCase()); // TypeScript teab, et 'value' on siin string
  } else {
    console.log(value.toFixed(2)); // TypeScript teab, et 'value' on siin number
  }
}

processValue("test"); // Väljund: TEST
processValue(123.456); // Väljund: 123.46
processValue(null); // Väljund: Väärtus on null

Parimad praktikad

Et oma TypeScripti projektides tüübivalvureid ja tüübikinnitusi tõhusalt kasutada, kaaluge järgmisi parimaid praktikaid:

Rahvusvahelised kaalutlused

Globaalsele publikule rakendusi arendades olge teadlik, kuidas tüübivalvurid ja tüübikinnitused võivad mõjutada lokaliseerimis- ja rahvusvahelistamis- (i18n) püüdlusi. Täpsemalt kaaluge järgmist:

Kokkuvõte

Tüübivalvurid ja tüübikinnitused on olulised tööriistad tüübiohutuse parandamiseks ja robustsema TypeScripti koodi kirjutamiseks. Mõistes, kuidas neid funktsioone tõhusalt kasutada, saate vältida käitusvigu, parandada koodi hooldatavust ja luua usaldusväärsemaid rakendusi. Pidage meeles eelistada võimaluse korral tüübivalvureid tüübikinnitustele, dokumenteerida oma tüübikinnitused ja valideerida väliseid andmeid, et tagada oma tüübiteabe täpsus. Nende põhimõtete rakendamine võimaldab teil luua stabiilsemat ja prognoositavamat tarkvara, mis sobib globaalseks kasutuselevõtuks.