TypeScript Academy · Oppitunti

Vertailut tyyppitasolla

Vertailkaa lukuja kokonaan tyyppitasolla.

Oppitunti 3/413 vaihetta

Vertailut tyyppitasolla on ilmainen TypeScript Academy-oppitunti CoddyKitissä. Tämä on oppitunti 3/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.

Lukujen vertailu

Numeeristen literaalityyppien vertailussa hyödynnetään jälleen tupleja. Ajatuksena on pienentää molempia lukuja samassa tahdissa ja katsoa, kumpi saavuttaa nollan ensin. Tyhjän tuplen ensimmäisenä saavuttava luku on pienempi.

type BuildTuple<N extends number, Acc extends unknown[] = []> =
  Acc["length"] extends N ? Acc : BuildTuple<N, [...Acc, unknown]>;

Literaalien yhtäsuuruus

Numeeristen literaalien yhtäsuuruus perustuu keskinäiseen sijoitettavuuteen. Kaksi literaalia ovat yhtäsuuria, kun kumpikin laajentaa toisen. Tupleihin kääriminen estää unioneihin liittyvät yllätykset.

type NumEquals<A extends number, B extends number> =
  [A] extends [B] ? ([B] extends [A] ? true : false) : false;

type X = NumEquals<3, 3>; // true
type Y = NumEquals<3, 4>; // false

Suurempi kuin pienentämällä

Kun haluatte tarkistaa ehdon A > B, rakentakaa molemmille tuplet ja poistakaa kummastakin yksi alkio jokaisella askeleella. Jos B tyhjenee ensin, vaikka A:ssa on edelleen alkioita, A on suurempi.

type GreaterThan<A extends number, B extends number> =
  BuildTuple<A> extends [...BuildTuple<B>, unknown, ...unknown[]]
    ? true : false;

type X = GreaterThan<5, 3>; // true
type Y = GreaterThan<3, 5>; // false

Miten hahmo tulkitaan

Hahmo [...BuildTuple<B>, unknown, ...unknown[]] tarkoittaa: etuliite, jonka pituus on B, ja sen jälkeen vähintään yksi lisäalkio. Jos A sopii tähän, siinä on enemmän alkioita kuin B:ssä, joten A > B.

type A = GreaterThan<4, 4>; // false (no extra element)
type B = GreaterThan<6, 2>; // true

Pienempi kuin

LessThan on yksinkertaisesti GreaterThan käännetyillä argumenteilla. Käyttäkää olemassa olevaa toteutusta sen sijaan, että johtaisitte sen uudelleen.

type LessThan<A extends number, B extends number> =
  GreaterThan<B, A>;

type X = LessThan<3, 5>; // true
type Y = LessThan<5, 3>; // false

Suurempi tai yhtä suuri

Yhdistäkää vertailu ja yhtäsuuruus. A >= B on tosi, kun A > B tai A == B.

type Gte<A extends number, B extends number> =
  GreaterThan<A, B> extends true
    ? true
    : NumEquals<A, B>;

type X = Gte<5, 5>; // true
type Y = Gte<3, 5>; // false

Rekursiivinen vertailu

Vaihtoehtoisessa menetelmässä molempia lukuja pienennetään, kunnes toinen saavuttaa nollan. Tämä havainnollistaa samantahtisuuden ideaa: nollaan ensimmäisenä päätyvä luku on pienempi.

type Cmp<A extends number, B extends number> =
  A extends 0
    ? (B extends 0 ? "eq" : "lt")
    : B extends 0
      ? "gt"
      : Cmp<Dec<A>, Dec<B>>;

type X = Cmp<3, 5>; // "lt"

Dec-riippuvuus

Rekursiivinen versio tarvitsee edellisen oppitunnin Dec-operaation. Jokaisella askeleella kummaltakin puolelta poistetaan yksi merkki. Kun molemmat ovat nollia, luvut ovat yhtäsuuria; jos vain toinen on nolla, toinen on suurempi.

type Dec<N extends number> =
  BuildTuple<N> extends [unknown, ...infer R] ? R["length"] : 0;

Yhtäsuuruus ja sijoitettavuus

Olkaa tarkkana: number extends number on tosi, mutta se ei tarkoita literaalien yhtäsuuruutta. Tässä esitetyt vertailut olettavat tarkat literaalityypit, kuten 3 ja 5, eivät laajaa number-tyyppiä.

type A = NumEquals<3, 3>;          // true
type B = 3 extends number ? 1 : 0; // 1 (assignability, not equality)

Järjestysavaimen rakentaminen

Vertailun avulla voitte koodata järjestyssääntöjä. Voitte esimerkiksi päättää tyyppitasolla, onko kahdesta luvusta koostuva tuple järjestetty nousevasti.

type IsSorted<A extends number, B extends number> =
  GreaterThan<A, B> extends true ? false : true;

type X = IsSorted<2, 5>; // true
type Y = IsSorted<5, 2>; // false

Käyttäkää harkiten

Vertailut kuluttavat rekursiota. Ne sopivat erinomaisesti pienten rajattujen arvojen, kuten indeksien ja kiinteiden rajojen, tarkistamiseen, mutta ne eivät ole yleinen numeerinen kirjasto. Pitäkää operandit pieninä ja suosikaa etuliitehahmoon perustuvaa muotoa, joka on matalampi kuin täysi samantahtinen rekursio.

type A = GreaterThan<9, 4>; // true (cheap, prefix pattern)

Pikatarkistus

Testatkaa ymmärrystänne tyyppitason vertailuista.

Vastaa interaktiivisessa oppitunnissa

Kertaus

Osaatte nyt järjestää lukuja tyyppijärjestelmässä.

Yhtäsuuruus literaalien keskinäisen sijoitettavuuden avulla.
GreaterThan B:n pituisen etuliitteen ja ylimääräisen alkion avulla.
LessThan vaihtaa argumenttien järjestyksen; Gte lisää yhtäsuuruuden.
Toimii pienillä literaaliluvuilla, ei laajalla number-tyypillä.

Seuraavaksi näistä rakennetaan käytännöllisiä apuohjelmia.

Aloita maksutta

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

Aloita opiskelu maksutta Näytä koko kurssi

Usein kysytyt kysymykset

Onko oppitunti ”Vertailut tyyppitasolla” ilmainen?

Kyllä – oppitunnin ”Vertailut tyyppitasolla” 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 ”Vertailut tyyppitasolla”?

Vertailkaa lukuja kokonaan tyyppitasolla. 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 3/4.

Kuinka kauan ”Vertailut tyyppitasolla”-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

← Takaisin: TypeScript Academy