TypeScript-väittämien allekirjoitukset: Ajonaikainen tyypin validointi vankkaa koodia varten

TypeScript tarjoaa erinomaisen staattisen tyypin tarkistuksen kehityksen aikana, mikä havaitsee mahdolliset virheet ennen ajonaikaa. Joskus sinun on kuitenkin varmistettava tyyppiturvallisuus ajonaikaisesti. Tässä väittämien allekirjoitukset tulevat kuvaan. Niiden avulla voit määrittää funktioita, jotka paitsi tarkistavat arvon tyypin, myös ilmoittavat TypeScriptille, että arvon tyyppi on kavennettu tarkistuksen tuloksen perusteella.

Mitä ovat väittämien allekirjoitukset?

Väittämän allekirjoitus on erityinen funktion allekirjoitus TypeScriptissä, joka käyttää asserts-avainsanaa. Se kertoo TypeScriptille, että jos funktio palauttaa virhettä heittämättä, niin tietty ehto argumentin tyypistä on taatusti tosi. Tämän avulla voit tarkentaa tyyppejä tavalla, jonka kääntäjä ymmärtää, vaikka se ei pystyisi automaattisesti päättelemään tyyppiä koodin perusteella.

Perussyntaksi on:

            function assertsCondition(argument: Type): asserts argument is NarrowedType {
  // ... toteutus, joka tarkistaa ehdon ja heittää, jos se on väärä ...
}

            

              
                Copy
              
            
          

• assertsCondition: Funktiosi nimi.
• argument: Type: Argumentti, jonka tyypin haluat tarkistaa.
• asserts argument is NarrowedType: Tämä on väittämän allekirjoitus. Se kertoo TypeScriptille, että jos assertsCondition(argument) palauttaa virhettä heittämättä, niin TypeScript voi käsitellä argument-muuttujaa tyyppinä NarrowedType.

Miksi käyttää väittämien allekirjoituksia?

Väittämien allekirjoitukset tarjoavat useita etuja:

• Ajonaikainen tyypin validointi: Ne mahdollistavat arvon tyypin validoinnin ajonaikaisesti, mikä estää odottamattomia virheitä, joita voi aiheutua virheellisistä tiedoista.
• Parannettu koodin turvallisuus: Varmistamalla tyyppirajoitukset ajonaikaisesti voit vähentää virheiden riskiä ja parantaa koodisi yleistä luotettavuutta.
• Tyypin kaventaminen: Väittämien allekirjoitukset antavat TypeScriptille mahdollisuuden kaventaa muuttujan tyyppiä ajonaikaisen tarkistuksen tuloksen perusteella, mikä mahdollistaa tarkemman tyypin tarkistuksen myöhemmässä koodissa.
• Parannettu koodin luettavuus: Ne tekevät koodistasi selkeämmän odotettujen tyyppien suhteen, mikä helpottaa sen ymmärtämistä ja ylläpitämistä.

Käytännön esimerkkejä

Esimerkki 1: Merkkijonon tarkistaminen

Luodaan funktio, joka väittää, että arvo on merkkijono. Jos se ei ole merkkijono, se heittää virheen.

            function assertIsString(value: any): asserts value is string {
  if (typeof value !== 'string') {
    throw new Error(`Odotettiin merkkijonoa, mutta vastaanotettiin ${typeof value}`);
  }
}

function processString(input: any) {
  assertIsString(input);
  // TypeScript tietää nyt, että 'input' on merkkijono
  console.log(input.toUpperCase());
}

processString("hello"); // Toimii hyvin
// processString(123); // Heittää virheen ajonaikaisesti

            

              
                Copy
              
            
          

Tässä esimerkissä assertIsString tarkistaa, onko syötearvo merkkijono. Jos se ei ole, se heittää virheen. Jos se palauttaa virhettä heittämättä, TypeScript tietää, että input on merkkijono, jolloin voit turvallisesti kutsua merkkijonomenetelmiä, kuten toUpperCase().

Esimerkki 2: Tietyn objektirakenteen tarkistaminen

Oletetaan, että työskentelet API:sta haettujen tietojen kanssa ja haluat varmistaa, että se on tietyn objektirakenteen mukainen ennen sen käsittelyä. Oletetaan, että odotat objektia, jolla on name (merkkijono) ja age (numero) -ominaisuudet.

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

function assertIsPerson(value: any): asserts value is Person {
  if (typeof value !== 'object' || value === null) {
    throw new Error(`Odotettiin objektia, mutta vastaanotettiin ${typeof value}`);
  }

  if (!('name' in value) || typeof value.name !== 'string') {
    throw new Error(`Odotettiin merkkijono-ominaisuutta 'name'`);
  }

  if (!('age' in value) || typeof value.age !== 'number') {
    throw new Error(`Odotettiin numero-ominaisuutta 'age'`);
  }
}

function processPerson(data: any) {
  assertIsPerson(data);
  // TypeScript tietää nyt, että 'data' on Person
  console.log(`Nimi: ${data.name}, Ikä: ${data.age}`);
}

processPerson({ name: "Alice", age: 30 }); // Toimii hyvin
// processPerson({ name: "Bob", age: "30" }); // Heittää virheen ajonaikaisesti
// processPerson({ name: "Charlie" }); // Heittää virheen ajonaikaisesti

            

              
                Copy
              
            
          

Tässä assertIsPerson tarkistaa, onko syötearvo objekti, jolla on vaaditut ominaisuudet ja tyypit. Jos jokin tarkistus epäonnistuu, se heittää virheen. Muuten TypeScript käsittelee data-muuttujaa Person-objektina.

Esimerkki 3: Tietyn Enum-arvon tarkistaminen

Harkitse enumia, joka edustaa erilaisia ​​tilaustiloja.

            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(`Odotettiin OrderStatus-tilaa, mutta vastaanotettiin ${value}`);
  }
}

function processOrder(status: any) {
  assertIsOrderStatus(status);
  // TypeScript tietää nyt, että 'status' on OrderStatus
  console.log(`Tilauksen tila: ${status}`);
}

processOrder(OrderStatus.SHIPPED); // Toimii hyvin
// processOrder("CANCELLED"); // Heittää virheen ajonaikaisesti

            

              
                Copy
              
            
          

Tässä esimerkissä assertIsOrderStatus varmistaa, että syötearvo on kelvollinen OrderStatus-enum-arvo. Jos se ei ole, se heittää virheen. Tämä auttaa estämään virheellisten tilaustilojen käsittelyn.

Esimerkki 4: Tyypin predikaattien käyttäminen väittämisfunktioiden kanssa

On mahdollista yhdistää tyypin predikaatteja ja väittämisfunktioita suuremman joustavuuden saavuttamiseksi.

            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(`Odotettiin merkkijonoa, mutta vastaanotettiin ${typeof value}`);
    }
}

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

processValue("TypeScript"); // Toimii
// processValue(123); // Heittää

            

              
                Copy
              
            
          

Parhaat käytännöt

• Pidä väittämät ytimekkäinä: Keskity validoimaan olennaiset ominaisuudet tai ehdot, joita koodisi tarvitsee toimiakseen oikein. Vältä liian monimutkaisia ​​väittämiä, jotka saattavat hidastaa sovellustasi.
• Anna selkeitä virheilmoituksia: Sisällytä informatiivisia virheilmoituksia, jotka auttavat kehittäjiä tunnistamaan nopeasti virheen syyn ja kuinka se korjataan. Käytä erityistä kieltä, joka ohjaa käyttäjää. Sen sijaan, että sanoisit "Virheelliset tiedot", sano esimerkiksi "Odotettiin objektia, jolla on ominaisuudet 'name' ja 'age'".
• Käytä tyypin predikaatteja monimutkaisiin tarkistuksiin: Jos validointilogiikkasi on monimutkaista, harkitse tyypin predikaattien käyttöä tyypin tarkistuslogiikan kapseloimiseksi ja koodin luettavuuden parantamiseksi.
• Harkitse suorituskykyvaikutuksia: Ajonaikainen tyypin validointi lisää sovelluksesi yleiskuormitusta. Käytä väittämien allekirjoituksia harkiten ja vain tarvittaessa. Staattista tyypin tarkistusta tulisi suosia aina kun mahdollista.
• Käsittele virheet sujuvasti: Varmista, että sovelluksesi käsittelee väittämisfunktioiden heittämät virheet sujuvasti, estäen kaatumiset ja tarjoten hyvän käyttökokemuksen. Harkitse mahdollisesti epäonnistuvan koodin käärimistä try-catch-lohkoihin.
• Dokumentoi väittämäsi: Dokumentoi selkeästi väittämisfunktioiden tarkoitus ja käyttäytyminen selittämällä ehdot, jotka ne tarkistavat, ja odotetut tyypit. Tämä auttaa muita kehittäjiä ymmärtämään ja käyttämään koodiasi oikein.

Käyttötapaukset eri toimialoilla

Väittämien allekirjoitukset voivat olla hyödyllisiä eri toimialoilla:

• Verkkokauppa: Käyttäjän syötteen validointi kassalla sen varmistamiseksi, että toimitusosoitteet, maksutiedot ja tilaustiedot ovat oikein.
• Rahoitus: Ulkoisista lähteistä saatavien taloudellisten tietojen, kuten osakekurssien tai valuuttakurssien, tarkistaminen ennen niiden käyttämistä laskelmissa tai raporteissa.
• Terveydenhuolto: Sen varmistaminen, että potilastiedot ovat tiettyjen muotojen ja standardien mukaisia, kuten potilastiedot tai laboratoriotulokset.
• Valmistus: Antureiden ja koneiden tietojen validointi sen varmistamiseksi, että tuotantoprosessit sujuvat ongelmitta ja tehokkaasti.
• Logistiikka: Sen tarkistaminen, että lähetystiedot, kuten seurantanumerot ja toimitusosoitteet, ovat tarkkoja ja täydellisiä.

Vaihtoehtoja väittämien allekirjoituksille

Vaikka väittämien allekirjoitukset ovat tehokas työkalu, TypeScriptissä on myös muita lähestymistapoja ajonaikaiseen tyypin validointiin:

• Tyypin vartijat: Tyypin vartijat ovat funktioita, jotka palauttavat boolean-arvon, joka ilmaisee, onko arvo tiettyä tyyppiä. Niitä voidaan käyttää muuttujan tyypin kaventamiseen ehdollisessa lohkossa. Toisin kuin väittämien allekirjoitukset, ne eivät kuitenkaan heitä virheitä, kun tyypin tarkistus epäonnistuu.
• Ajonaikaiset tyypin tarkistuskirjastot: Kirjastot, kuten io-ts, zod ja yup, tarjoavat kattavat ajonaikaiset tyypin tarkistusominaisuudet, mukaan lukien skeeman validointi ja tiedon muuntaminen. Nämä kirjastot voivat olla erityisen hyödyllisiä käsiteltäessä monimutkaisia ​​tietorakenteita tai ulkoisia sovellusrajapintoja.

Johtopäätös

TypeScript-väittämien allekirjoitukset tarjoavat tehokkaan mekanismin ajonaikaisen tyypin validoinnin toteuttamiseksi, mikä parantaa koodin luotettavuutta ja estää odottamattomia virheitä. Määrittelemällä funktioita, jotka väittävät arvon tyypin, voit parantaa tyyppiturvallisuutta, kaventaa tyyppejä ja tehdä koodistasi selkeämmän ja ylläpidettävämmän. Vaikka vaihtoehtoja onkin, väittämien allekirjoitukset tarjoavat kevyen ja tehokkaan tavan lisätä ajonaikaisia ​​tyyppitarkistuksia TypeScript-projekteihisi. Noudattamalla parhaita käytäntöjä ja harkitsemalla huolellisesti suorituskykyvaikutuksia voit hyödyntää väittämien allekirjoituksia rakentaaksesi vankempia ja luotettavampia sovelluksia.

Muista, että väittämien allekirjoitukset ovat tehokkaimmillaan, kun niitä käytetään yhdessä TypeScriptin staattisten tyypin tarkistusominaisuuksien kanssa. Niitä tulisi käyttää täydentämään, ei korvaamaan, staattista tyypin tarkistusta. Yhdistämällä staattisen ja ajonaikaisen tyypin validoinnin voit saavuttaa korkean koodin turvallisuustason ja estää monia yleisiä virheitä.