Rekursiivisten tyyppimäärittelyjen perusteet
Kirjoittakaa tyyppejä, jotka viittaavat turvallisesti itseensä.
Rekursiivisten tyyppimäärittelyjen perusteet on ilmainen TypeScript Academy-oppitunti CoddyKitissä. Tämä on oppitunti 1/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ä on rekursiivinen tyyppi
Rekursiivinen tyyppi on tyyppi, joka viittaa omaan määrittelyynsä. Sen avulla voitte kuvata tietorakenteita, joiden syvyydelle ei ole ennalta määrättyä ylärajaa.
type LinkedList<T> = {
value: T;
next: LinkedList<T> | null;
};
// next is the same type again, ending at null.Linkitetyn listan tyyppi
Klassisessa esimerkissä jokainen solmu sisältää value-arvon ja next-osoittimen toiseen solmuun tai ketjun päättävään null-arvoon.
type LinkedList<T> = { value: T; next: LinkedList<T> | null };
const list: LinkedList<number> = {
value: 1,
next: { value: 2, next: null }
};
console.log(list.value, list.next?.value);Perustapaus on tärkeä
Jokainen rekursiivinen tyyppi tarvitsee lopetusehdon, tässä tapauksessa null-arvon, jotta rekursio voi päättyä. Ilman sitä tyyppi olisi äärettömän syvä.
type LinkedList<T> = { value: T; next: LinkedList<T> | null };
const single: LinkedList<string> = { value: "only", next: null };
console.log(single.next);Pidemmät ketjut
Voitte upottaa rakenteita niin syvälle kuin haluatte. Tyyppi sallii minkä tahansa pituuden, koska next on itsessään lista tai null-arvo.
type LinkedList<T> = { value: T; next: LinkedList<T> | null };
const chain: LinkedList<number> = {
value: 10,
next: { value: 20, next: { value: 30, next: null } }
};
console.log(chain.next?.next?.value);Linkitetyn listan läpikäynti
Funktio voi kulkea ketjun läpi seuraamalla next-osoitinta, kunnes se saavuttaa null-arvon. Rekursiivinen tyyppi tekee tästä täysin tyyppiturvallista.
type LinkedList<T> = { value: T; next: LinkedList<T> | null };
function toArray<T>(list: LinkedList<T> | null): T[] {
const out: T[] = [];
let cur = list;
while (cur) { out.push(cur.value); cur = cur.next; }
return out;
}
const l: LinkedList<number> = { value: 1, next: { value: 2, next: null } };
console.log(toArray(l));Rekursiiviset funktiot rekursiivisilla tyypeillä
Rekursiiviset tyypit sopivat luontevasti yhteen rekursiivisten funktioiden kanssa. Tässä laskemme pituuden rekursiivisesti next-osoittimen avulla.
type LinkedList<T> = { value: T; next: LinkedList<T> | null };
function length<T>(list: LinkedList<T> | null): number {
return list === null ? 0 : 1 + length(list.next);
}
const l: LinkedList<string> = { value: "a", next: { value: "b", next: null } };
console.log(length(l));Listan lisääminen alkuun
Koska tyyppi on yhdenmukainen, uusien listojen rakentaminen on helppoa: kääritkää olemassa oleva lista uuden pääsolmun next-arvoksi.
type LinkedList<T> = { value: T; next: LinkedList<T> | null };
function prepend<T>(value: T, list: LinkedList<T> | null): LinkedList<T> {
return { value, next: list };
}
const l = prepend(1, prepend(2, null));
console.log(l.value, l.next?.value);Valinnaiset ja null-arvoiset lopetusehdot
Voitte päättää rakenteen null-arvoon tai tehdä next-ominaisuudesta valinnaisen. Molemmat päättävät rekursion; valitkaa tapa sen mukaan, miten haluatte kuvata lopun.
type ListA<T> = { value: T; next: ListA<T> | null };
type ListB<T> = { value: T; next?: ListB<T> };
const a: ListA<number> = { value: 1, next: null };
const b: ListB<number> = { value: 1 };
console.log(a.value, b.value);Rekursiiviset tyypit ovat laiskoja
TypeScript laajentaa rekursiivista tyyppiä vain niin pitkälle kuin sitä todellisuudessa käytetään. Määrittely voi viitata itseensä ilman ääretöntä työmäärää.
type LinkedList<T> = { value: T; next: LinkedList<T> | null };
// Using two levels only expands two levels.
const l: LinkedList<number> = { value: 1, next: { value: 2, next: null } };
console.log(l.next?.value);Listan muuntaminen mapilla
Rekursiivinen map muuntaa jokaisen arvon ja säilyttää samalla rakenteen palauttaen uuden, samanmuotoisen listan.
type LinkedList<T> = { value: T; next: LinkedList<T> | null };
function mapList<T, U>(list: LinkedList<T> | null, fn: (v: T) => U): LinkedList<U> | null {
if (list === null) return null;
return { value: fn(list.value), next: mapList(list.next, fn) };
}
const l: LinkedList<number> = { value: 1, next: { value: 2, next: null } };
console.log(mapList(l, x => x * 10)?.value);Miksi rekursiiviset tyypit ovat tehokkaita
Itseensä viittaavien tyyppien avulla voitte mallintaa mielivaltaisen syvälle upotettua dataa, listoja, puita ja JSON-dataa täysin tyyppiturvallisesti ilman suunnitteluun asetettua kiinteää syvyysrajoitusta.
type LinkedList<T> = { value: T; next: LinkedList<T> | null };
const l: LinkedList<boolean> = { value: true, next: { value: false, next: null } };
console.log(l.value, l.next?.value);Pikatarkistus: rekursiiviset tyypit
Testatkaa ymmärrystänne rekursiivisista tyyppimäärittelyistä.
Kertaus: rekursiiviset tyyppimäärittelyt
Opitte, että rekursiivinen tyyppi viittaa itseensä, tarvitsee päättymiseen perustapauksen, kuten null-arvon, ja sopii luontevasti yhteen rekursiivisten funktioiden kanssa linkitettyjen listojen läpikäyntiin, muuntamiseen ja rakentamiseen.
type LinkedList<T> = { value: T; next: LinkedList<T> | null };
const l: LinkedList<number> = { value: 1, next: null };
console.log(l.value);
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 ”Rekursiivisten tyyppimäärittelyjen perusteet” ilmainen?
Kyllä – oppitunnin ”Rekursiivisten tyyppimäärittelyjen perusteet” 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 ”Rekursiivisten tyyppimäärittelyjen perusteet”?
Kirjoittakaa tyyppejä, jotka viittaavat turvallisesti itseensä. 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 1/4.
Kuinka kauan ”Rekursiivisten tyyppimäärittelyjen perusteet”-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
- Rekursiivisten tyyppimäärittelyjen perusteet
- Puurakenteiden tyypitys
- JSON-arvotyypit
- Rekursion syvyys ja rajoitukset