Kalliiden tyyppioperaatioiden välttäminen
Tunnistakaa ja korjatkaa syvästi rekursiiviset tai distributiiviset tyypit
Kalliiden tyyppioperaatioiden välttäminen on ilmainen TypeScript Academy-oppitunti CoddyKitissä. Tämä on oppitunti 2/4. Voit lukea koko oppitunnin alta ilmaiseksi ja harjoitella sen jälkeen käytännössä selaimessa sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla. Oppitunti kuuluu TypeScript Academy-oppimispolkuun, ja edistymisesi synkronoituu verkon ja CoddyKit-sovelluksen välillä. TypeScript Academy-kurssilla on yhteensä 4 oppituntia.
Mikä tekee tyyppioperaatiosta raskaan
Syvästi rekursiiviset tyypit, suuret unionien hajautukset ja monimutkaiset infer-ketjut pakottavat TypeScriptin luomaan monia tyyppimuunnelmia, mikä aiheuttaa eksponentiaalista hidastumista.
// Expensive: distributes over every member of a large union
type FilterStrings<T> = T extends string ? T : never;
type Result = FilterStrings<string | number | boolean | null | undefined | ...>;Välttäkää liian suuria unioneja
Satoja jäseniä sisältävät union-tyypit, kuten monet merkkijonoliteraalit, voivat tehdä tyyppitarkistuksesta erittäin hidasta. Harkitkaa alueen rajaamista tai string-tyypin käyttämistä yhdessä validoinnin kanssa.
// Expensive
type HugeUnion = "a" | "b" | "c" | /* 200 more ... */ "z";
// Better: string with a runtime check
function isValid(s: string): s is ValidString { return VALID_SET.has(s); }Suosikaa rajapintoja monimutkaisten tyyppialiasien sijaan
TypeScript välimuistittaa rajapintoja tehokkaammin kuin monimutkaisia tyyppialiasien leikkauksia. Suosikaa interface-määrittelyä usein viitatuissa olioiden rakenteissa.
// Slow: recomputed union intersection each time
type BigObject = TypeA & TypeB & TypeC & TypeD;
// Fast: interface (cached)
interface BigObject extends TypeA, TypeB, TypeC, TypeD {}Rajoittakaa rekursion syvyyttä
Rekursiiviset ehdolliset tyypit ovat tehokkaita, mutta ne voivat saavuttaa TypeScriptin syvyysrajan, joka on yleensä 100 tasoa. Lisätkää syvyyslaskuri, joka lopettaa käsittelyn aikaisin.
type Flatten<T, Depth extends number[] = []> =
Depth["length"] extends 10 ? T
: T extends (infer U)[] ? Flatten<U, [...Depth, 0]>
: T;Välimuistittakaa välityypit
Nimetkää monimutkaiset välityypit, jotta TypeScript voi välimuistittaa ja käyttää niitä uudelleen sen sijaan, että se laskisi ne uudelleen jokaisessa viittauskohdassa.
// Before: recomputed at each use
type MyResult<T> = T extends SomeComplex<infer U> ? Transform<U> : never;
// After: split into named intermediates
type ExtractU<T> = T extends SomeComplex<infer U> ? U : never;
type MyResult<T> = Transform<ExtractU<T>>;Välttäkää syviä mapped-tyyppejä suurissa olioissa
DeepReadonly-tyypin käyttäminen erittäin suuressa oliotyypissä pakottaa TypeScriptin käymään jokaisen ominaisuuden rekursiivisesti läpi, mikä on raskasta.
// Expensive on 50-property nested objects
type Safe = DeepReadonly<HugeConfig>;
// Better: annotate at creation time with const assertionsKäyttäkää geneeristen tyyppien laiskaa evaluointia
Kalliin tyypin kääriminen thunk-funktioon, eli sen palauttavaan funktiotyyppiin, siirtää evaluoinnin siihen asti, kunnes tyyppiä todella tarvitaan.
// Lazy evaluation via wrapper
type Lazy<T> = () => T;
type ExpensiveLazy = Lazy<DeepReadonly<HugeConfig>>;Suosikaa eksplisiittisiä paluutyyppejä
Funktioiden paluutyyppien eksplisiittinen merkitseminen estää TypeScriptiä päättelemästä niitä toistuvasti jokaisessa kutsukohdassa ja nopeuttaa tyyppitarkistusta.
// Let TypeScript infer (may be slow for complex functions)
function process(data: Input) { return transform(data); }
// Faster: explicit annotation
function process(data: Input): Output { return transform(data); }isolatedDeclarations rinnakkaista tarkistusta varten
TypeScript 5.5+:n isolatedDeclarations-asetus edellyttää eksplisiittisiä paluutyyppejä ja mahdollistaa toisistaan riippumattomien tiedostojen rinnakkaisen tyyppitarkistuksen ilman täydellistä päättelyä.
// tsconfig.json
{
"compilerOptions": {
"isolatedDeclarations": true
}
}Projektiviittaukset eristämistä varten
Projektiviittaukset estävät TypeScriptiä tarkistamasta tyyppien osalta muuttumattomia paketteja, mikä on suurin yksittäinen hyöty suurissa monorepoissa.
# With project references:
# tsc --build only recompiles packages whose sources changed
# Unchanged packages: declaration files used directlyKertaus: raskaiden tyyppien välttäminen
Jotta TypeScript pysyisi nopeana, välttäkää valtavia unioneja, välimuistittakaa välityypit, suosikaa rajapintoja monimutkaisten tyyppialiasien sijaan, rajoittakaa rekursion syvyyttä, käyttäkää eksplisiittisiä paluutyyppejä ja eristäkää paketit projektiviittauksilla.
Pikatarkistus
Mikä lähestymistapa auttaa TypeScriptiä välimuistittamaan olion rakenteen tehokkaammin?
Mitä opitte
Raskaisiin TypeScriptin tyyppioperaatioihin kuuluvat suuret unionit, syvä rekursio ja toistuva monimutkainen päättely. Optimoikaa suorituskykyä välimuistittamalla välityypit, suosimalla rajapintoja, rajoittamalla unionien kokoa ja käyttämällä projektiviittauksia monorepoissa.
Opi TypeScript tekoälytuutorin avulla — ilmaiseksi
Kirjoita ja suorita oikeaa koodia selaimessa, saa välitöntä apua tekoälytuutorilta ympäri vuorokauden ja jatka siitä, mihin jäit, verkossa tai sovelluksessa.
- Kurssit
- 101
- Oppitunnit
- 352
Usein kysytyt kysymykset
Onko oppitunti ”Kalliiden tyyppioperaatioiden välttäminen” ilmainen?
Kyllä – oppitunnin ”Kalliiden tyyppioperaatioiden välttäminen” koko tekstin voi lukea täällä verkossa ilmaiseksi. Jos haluat harjoitella interaktiivisesti sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla sekä avata koko TypeScript Academy-kurssin, päivitä CoddyKit PROhon. TypeScript Academy-kurssilla on yhteensä 4 oppituntia.
Mitä opin oppitunnilla ”Kalliiden tyyppioperaatioiden välttäminen”?
Tunnistakaa ja korjatkaa syvästi rekursiiviset tai distributiiviset tyypit Harjoittelet TypeScript Academy-aihetta koodilla, jonka suoritat suoraan selaimessa. Ympäri vuorokauden käytettävissä oleva tekoälytuutori vastaa kysymyksiisi oppitunnin aikana.
Tarvitsenko kokemusta aloittaakseni TypeScript Academy-opiskelun?
Aiempi kokemus ei ole tarpeen. CoddyKitin TypeScript Academy-oppimispolku sopii vasta-alkajista edistyneisiin, joten voit aloittaa tästä tai alusta ja edetä omaan tahtiisi. Tämä on oppitunti 2/4.
Kuinka kauan ”Kalliiden tyyppioperaatioiden välttäminen”-oppitunnin suorittaminen kestää?
Useimmat CoddyKitin oppitunnit kestävät noin 5–10 minuuttia. Jokainen oppitunti on lyhyt ja interaktiivinen, joten edistyt tasaisesti ja voit jatkaa siitä, mihin jäit – sekä verkossa että sovelluksessa.
Voinko kirjoittaa ja suorittaa koodia tällä TypeScript Academy-oppitunnilla?
Kyllä. Jokainen TypeScript Academy-oppitunti sisältää sisäänrakennetun koodieditorin, joten voit kirjoittaa ja suorittaa oikeaa koodia suoraan selaimessa ja saada välitöntä palautetta tekoälyltä – paikallista asennusta ei tarvita.
Kaikki tämän kurssin oppitunnit
- Hitaan TypeScript-käännöksen profilointi
- Kalliiden tyyppioperaatioiden välttäminen
- skipLibCheck ja eristetyt declaration-tiedostot
- Tyyppien tarkistus CI:ssä: strategiat ja työkalut