TypeScript Academy · Oppitunti

Geneeriset funktiot: tyyppiparametrit

Lisätkää funktioihin tyyppiparametreja uudelleenkäytettävyyden parantamiseksi

Oppitunti 1/413 vaihetta

Geneeriset funktiot: tyyppiparametrit 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.

Tervetuloa

Geneeristen tyyppien avulla voit kirjoittaa minkä tahansa tyypin kanssa toimivia funktioita tyyp安全isyyden säilyttäen. `any`-tyypin sijaan käytät tyyppiparametria, jonka tyyppi ratkaistaan funktion kutsun yhteydessä.

Geneeristen tyyppien ratkaisema ongelma

`any`-tyyppiä palauttava funktio menettää tyyppitiedot. Geneeriset tyypit säilyttävät syöte- ja tulostyyppien välisen suhteen.

// Without generics — loses type info
function first(arr: any[]): any { return arr[0]; }

// With generics — type-safe
function first<T>(arr: T[]): T { return arr[0]; }

Tyyppiparametrin syntaksi

Määritä tyyppiparametri kulmasulkeissa `` parametriluettelon edellä. Käytä T:tä parametreissa ja paluutyypissä.

function identity<T>(value: T): T {
  return value;
}
const n = identity(42);       // T is number
const s = identity('hello');  // T is string

Geneeristen funktioiden tyyppipäättely

TypeScript päättelee tyyppiargumentin todellisen argumentin perusteella. Useimmiten sitä ei tarvitse määrittää erikseen.

function wrap<T>(val: T): T[] { return [val]; }
const nums = wrap(42);    // T inferred as number -> number[]
const strs = wrap('hi');  // T inferred as string -> string[]

Useita tyyppiparametreja

Funktioilla voi olla useita tyyppiparametreja.

function pair<A, B>(a: A, b: B): [A, B] {
  return [a, b];
}
const p = pair(1, 'hello'); // [number, string]

Geneeriset taulukkofunktiot

Geneeriset tyypit ovat välttämättömiä taulukkojen apufunktioissa, joiden on toimittava minkä tahansa alkiotyypin kanssa.

function filterNull<T>(arr: (T | null)[]): T[] {
  return arr.filter((x): x is T => x !== null);
}

Tyyppiargumenttien määrittäminen erikseen

Voit antaa tyyppiargumentit erikseen, jos TypeScript ei pysty päättelemään niitä.

function create<T>(): T | null { return null; }
const user = create<User>(); // T cannot be inferred — must be explicit

Geneeriset tyypit ja any

Toisin kuin `any`, geneeriset tyypit säilyttävät tyyppien välisen suhteen funktion läpi. Paluutyyppi on sidoksissa syötetyyppiin.

function echo<T>(val: T): T { return val; }
const n: number = echo(42);   // OK
// const s: string = echo(42); // Error — T is number

Geneeriset nuolifunktiot

Nuolifunktiot käyttävät samaa syntaksia, mutta .tsx-tiedostoissa tarvitaan pilkku erottamaan syntaksi JSX-tageista.

const identity = <T>(val: T): T => val;
// In .tsx files:
const identity2 = <T,>(val: T): T => val;

Eri tyypin palauttaminen

Geneeriset funktiot voivat käyttää tyyppiparametria muunnetulla tavalla.

function mapArray<T, U>(arr: T[], fn: (item: T) => U): U[] {
  return arr.map(fn);
}
const lengths = mapArray(['hello', 'world'], s => s.length);
// lengths: number[]

Oletusarvoiset geneeriset parametrit

Määritä tyyppiparametrille oletustyyppi, jotta sen antaminen olisi valinnaista.

function createList<T = string>(): T[] { return []; }
const list = createList(); // T defaults to string

Pikatarkistus

Mikä on kutsun `identity(42)` paluutyyppi?

Vastaa interaktiivisessa oppitunnissa

Kertaus

Geneeriset funktiot käyttävät tyyppiparametreja (T) säilyttääkseen syötteiden ja tulosteiden väliset tyyppisuhteet. TypeScript päättelee tyyppiargumentit automaattisesti. Käytä geneerisiä tyyppejä any-tyypin sijaan uudelleenkäytettävien ja tyyppiturvallisten apufunktioiden kirjoittamiseen.

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 ”Geneeriset funktiot: tyyppiparametrit” ilmainen?

Kyllä – oppitunnin ”Geneeriset funktiot: tyyppiparametrit” 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 ”Geneeriset funktiot: tyyppiparametrit”?

Lisätkää funktioihin tyyppiparametreja uudelleenkäytettävyyden parantamiseksi 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 ”Geneeriset funktiot: tyyppiparametrit”-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

Geneeriset funktiot: tyyppiparametrit
Geneeriset interface-määrittelyt ja tyyppialiakset
Geneeristen tyyppien rajoitteet extends-avainsanalla
Oletustyyppiparametrit

← Takaisin: TypeScript Academy