TypeScripti kinnitusallkirjad: käitusajaline tüübihinnang robustse koodi jaoks

TypeScript pakub arenduse käigus suurepärast staatilist tüübihindamist, püüdes kinni potentsiaalsed vead enne käitusaega. Mõnikord peate aga tagama tüübiga ohutuse käitusajal. Siin tulevadki mängu kinnitusallkirjad. Need võimaldavad teil määratleda funktsioone, mis mitte ainult ei kontrolli väärtuse tüüpi, vaid ka teavitavad TypeScripti sellest, et väärtuse tüüp on kontrolli tulemuse põhjal kitsendatud.

Mis on kinnitusallkirjad?

Kinnitusallkiri on TypeScriptis eriline funktsiooni allkirja tüüp, mis kasutab asserts märksõna. See ütleb TypeScriptile, et kui funktsioon naaseb ilma veata, siis teatud tingimus argumendi tüübi kohta on garanteeritud tõene. See võimaldab teil tüüpe täpsustada viisil, mida kompilaator mõistab, isegi kui ta ei saa automaatselt koodi põhjal tüüpi tuvastada.

Põhisüntaks on:

            function assertsCondition(argument: Type): asserts argument is NarrowedType {
  // ... rakendus, mis kontrollib tingimust ja viskab vea, kui see on vale ...
}

            

              
                Copy
              
            
          

• assertsCondition: Teie funktsiooni nimi.
• argument: Type: Argument, mille tüüpi soovite kontrollida.
• asserts argument is NarrowedType: See on kinnitusallkiri. See ütleb TypeScriptile, et kui assertsCondition(argument) naaseb ilma veata, siis TypeScript võib argumenti käsitleda kui tüüpi NarrowedType.

Miks kasutada kinnitusallkirju?

Kinnitusallkirjad pakuvad mitmeid eeliseid:

• Käitusajaline tüübihinnang: Need võimaldavad teil käitusajal väärtuse tüüpi hinnata, vältides ootamatuid vigu, mis võivad tekkida valest andmest.
• Parem koodi ohutus: Käitusajal tüübipiiranguid jõustades saate vähendada vigade riski ja parandada oma koodi üldist töökindlust.
• Tüübi kitsendamine: Kinnitusallkirjad võimaldavad TypeScriptil kitsendada muutuja tüüpi käitusajal kontrollimise tulemuse põhjal, võimaldades täpsemat tüübihindamist järgnevas koodis.
• Parem koodi loetavus: Need muudavad teie koodi oodatavate tüüpide osas selgemaks, muutes selle mõistmise ja hooldamise lihtsamaks.

Praktilised näited

Näide 1: Stringi kontrollimine

Loome funktsiooni, mis kinnitab, et väärtus on string. Kui see pole string, viskab see vea.

            function assertIsString(value: any): asserts value is string {
  if (typeof value !== 'string') {
    throw new Error(`Oodati stringi, kuid saadi ${typeof value}`);
  }
}

function processString(input: any) {
  assertIsString(input);
  // TypeScript teab nüüd, et 'input' on string
  console.log(input.toUpperCase());
}

processString("hello"); // Töötab hästi
// processString(123); // Viska viga käitusajal

            

              
                Copy
              
            
          

Selles näites kontrollib assertIsString, kas sisendväärtus on string. Kui see pole, viskab see vea. Kui see naaseb ilma veata, teab TypeScript, et input on string, võimaldades teil turvaliselt kutsuda stringi meetodeid nagu toUpperCase().

Näide 2: Kindla objekti struktuuri kontrollimine

Oletagem, et töötate API-st saadud andmetega ja soovite enne selle töötlemist tagada, et see vastab kindlale objektistruktuurile. Oletagem, et ootate objekti, millel on name (string) ja age (number) atribuudid.

            interface Person {
  name: string;
  age: number;
}

function assertIsPerson(value: any): asserts value is Person {
  if (typeof value !== 'object' || value === null) {
    throw new Error(`Oodati objekti, kuid saadi ${typeof value}`);
  }

  if (!('name' in value) || typeof value.name !== 'string') {
    throw new Error(`Oodati string 'name' atribuuti`);
  }

  if (!('age' in value) || typeof value.age !== 'number') {
    throw new Error(`Oodati number 'age' atribuuti`);
  }
}

function processPerson(data: any) {
  assertIsPerson(data);
  // TypeScript teab nüüd, et 'data' on Person
  console.log(`Nimi: ${data.name}, Vanus: ${data.age}`);
}

processPerson({ name: "Alice", age: 30 }); // Töötab hästi
// processPerson({ name: "Bob", age: "30" }); // Viska viga käitusajal
// processPerson({ name: "Charlie" }); // Viska viga käitusajal

            

              
                Copy
              
            
          

Siin kontrollib assertIsPerson, kas sisendväärtus on objekt vajalike atribuutide ja tüüpidega. Kui mõni kontroll ebaõnnestub, viskab see vea. Vastasel juhul käsitleb TypeScript datat kui Person objekti.

Näide 3: Kindla enum väärtuse kontrollimine

Vaadake enumit, mis esindab erinevaid tellimuse olekuid.

            enum OrderStatus {
  PENDING = "PENDING",
  PROCESSING = "PROCESSING",
  SHIPPED = "SHIPPED",
  DELIVERED = "DELIVERED",
}

function assertIsOrderStatus(value: any): asserts value is OrderStatus {
  if (!Object.values(OrderStatus).includes(value)) {
    throw new Error(`Oodati OrderStatus, kuid saadi ${value}`);
  }
}

function processOrder(status: any) {
  assertIsOrderStatus(status);
  // TypeScript teab nüüd, et 'status' on OrderStatus
  console.log(`Tellimuse olek: ${status}`);
}

processOrder(OrderStatus.SHIPPED); // Töötab hästi
// processOrder("CANCELLED"); // Viska viga käitusajal

            

              
                Copy
              
            
          

Selles näites tagab assertIsOrderStatus, et sisendväärtus on kehtiv OrderStatus enum väärtus. Kui see pole, viskab see vea. See aitab vältida ebakehtivate tellimuse olekute töötlemist.

Näide 4: Tüüpide predikaatide kasutamine kinnitusfunktsioonidega

On võimalik kombineerida tüüpide predikaate ja kinnitusfunktsioone suurema paindlikkuse saavutamiseks.

            function isString(value: any): value is string {
    return typeof value === 'string';
}

function assertString(value: any): asserts value is string {
    if (!isString(value)) {
        throw new Error(`Oodati stringi, kuid saadi ${typeof value}`);
    }
}

function processValue(input: any) {
    assertString(input);
    console.log(input.toUpperCase());
}

processValue("TypeScript"); // Töötab
// processValue(123); // Viska

            

              
                Copy
              
            
          

Parimad tavad

• Hoidke kinnitused lühikesed: Keskenduge vajalike atribuutide või tingimuste hindamisele, mida teie koodi korrektseks toimimiseks vajatakse. Vältige liiga keerukaid kinnitusi, mis võivad teie rakenduse aeglustada.
• Esitage selged veateated: Lisage informatiivsed veateated, mis aitavad arendajatel kiiresti tuvastada vea põhjust ja kuidas seda parandada. Kasutage konkreetset keelt, mis juhendab kasutajat. Näiteks selle asemel, et öelda „Ebakehtivad andmed”, öelge „Oodati objekti atribuutidega „name” ja „age””.
• Kasutage keerukate kontrollide jaoks tüüpide predikaate: Kui teie hinnangulogika on keeruline, kaaluge tüüpide predikaatide kasutamist tüübikontrolli loogika kapseldamiseks ja koodi loetavuse parandamiseks.
• Arvestage jõudluse mõjudega: Käitusajaline tüübihinnang lisab teie rakendusele töökoormust. Kasutage kinnitusallkirju mõistlikult ja ainult siis, kui see on vajalik. Staatilist tüübihindamist tuleks võimaluse korral eelistada.
• Käsitsege vigu graatsiliselt: Veenduge, et teie rakendus käsitseb kinnitusfunktsioonide poolt visatud vigu graatsiliselt, vältides krahhe ja pakkudes head kasutajakogemust. Kaaluge potentsiaalselt ebaõnnestuva koodi ümbris-bloki try-catch abil.
• Dokumenteerige oma kinnitused: Dokumenteerige selgelt oma kinnitusfunktsioonide eesmärk ja käitumine, selgitades nende kontrollitavaid tingimusi ja oodatavaid tüüpe. See aitab teistel arendajatel teie koodi õigesti mõista ja kasutada.

Kasutusjuhud erinevates tööstusharudes

Kinnitusallkirjad võivad olla kasulikud erinevates tööstusharudes:

• E-kaubandus: Kasutajasisendi valideerimine kassas, et tagada tarneaadresside, makseteabe ja tellimuse üksikasjade õigsus.
• Finants: Finantsandmete kontrollimine välistest allikatest, näiteks aktsiahindade või valuutavahetuskursside, enne nende kasutamist arvutustes või aruannetes.
• Tervishoid: Terviseandmete vastavuse tagamine konkreetsete vormingute ja standarditega, näiteks meditsiiniliste rekordite või laboritulemustega.
• Tootmine: Andmete kontrollimine sensoritelt ja masinatelt, et tagada tootmisprotsesside sujuv ja tõhus toimimine.
• Logistika: Tarneandmete, näiteks jälgimisnumbrite ja tarneaadresside täpsuse ja täielikkuse kontrollimine.

Alternatiivid kinnitusallkirjadele

Kuigi kinnitusallkirjad on võimas tööriist, on käitusajal tüübihindamiseks ka teisi lähenemisviise TypeScriptis:

• Tüübihoidjad: Tüübihoidjad on funktsioonid, mis tagastavad boolean väärtuse, mis näitab, kas väärtus on kindlat tüüpi. Neid saab kasutada muutuja tüübi kitsendamiseks tingimusploki sees. Kuid erinevalt kinnitusallkirjadest ei viska need tüübikontrolli ebaõnnestumisel vigu.
• Käitusajal tüübikontrolli raamatukogud: Raamatukogud nagu io-ts, zod ja yup pakuvad põhjalikke käitusajal tüübikontrolli võimalusi, sealhulgas skeemide hindamist ja andmete teisendamist. Need raamatukogud võivad olla eriti kasulikud keerukate andmestruktuuride või väliste API-dega töötamisel.

Kokkuvõte

TypeScripti kinnitusallkirjad pakuvad võimsat mehhanismi käitusajaline tüübihindamise jõustamiseks, parandades koodi töökindlust ja vältides ootamatuid vigu. Määratledes funktsioone, mis kinnitavad väärtuse tüüpi, saate parandada tüübiga ohutust, kitsendada tüüpe ja muuta oma koodi selgemaks ning hooldatavamaks. Kuigi alternatiive on olemas, pakuvad kinnitusallkirjad kerget ja tõhusat viisi käitusajaline tüübihindamise lisamiseks teie TypeScripti projektidesse. Parimaid tavasid järgides ja jõudlusmõjudega hoolikalt arvestades saate kasutada kinnitusallkirju robustsemate ja töökindlamate rakenduste loomiseks.

Pidage meeles, et kinnitusallkirjad on kõige tõhusamad, kui neid kasutatakse koos TypeScripti staatilise tüübihindamise funktsioonidega. Neid tuleks kasutada staatilise tüübihindamise täiendamiseks, mitte asendamiseks. Kombineerides staatilist ja käitusajalist tüübihindamist, saate saavutada kõrge koodi ohutuse taseme ja vältida paljusid levinud vigu.