Kurs JavaScript i TypeScript · Moduł 6: Podstawy TypeScript
Przeciążanie funkcji
W tej lekcji9
"W Parku Jurajskim precyzja jest kluczowa," mówi Dr. Henry Wu, patrząc na swój wysoce wyspecjalizowany sprzęt laboratoryjny. "Ten sam analizator DNA może badać próbki w różnych formatach - od krwi dinozaurów, przez skamieniałości, po bursztyn. Podobnie w TypeScript, jedna funkcja może obsługiwać różne zestawy parametrów i zwracać różne typy danych."
Witaj w świecie przeciążania funkcji (function overloading) - potężnego mechanizmu TypeScript, który pozwala na definiowanie funkcji przyjmujących różne rodzaje parametrów i zwracających różne typy wyników.
Czym jest przeciążanie funkcji?
Przeciążanie funkcji to mechanizm, który umożliwia definiowanie wielu sygnatur dla jednej funkcji. W ten sposób możemy stworzyć funkcję, która reaguje różnie w zależności od liczby, typów i struktury przekazanych parametrów.
Innymi słowy, tak jak naukowcy w Parku Jurajskim mogą wykorzystywać ten sam sprzęt do różnych procedur, tak my możemy wykorzystać jedną funkcję do różnych operacji, zachowując przy tym pełne bezpieczeństwo typów.
Podstawy przeciążania funkcji
W TypeScript przeciążanie funkcji składa się z dwóch części:
- Sygnatury przeciążeń (overload signatures) - definicje typów parametrów i zwracanych wartości
- Sygnatura implementacji (implementation signature) - faktyczna implementacja funkcji, która musi być kompatybilna ze wszystkimi sygnaturami przeciążeń
Przyjrzyjmy się prostemu przykładowi:
// Sygnatury przeciążeń
function analizujPróbkę(id: number): string;
function analizujPróbkę(nazwa: string): string;
// Sygnatura implementacji
function analizujPróbkę(argument: number | string): string {
if (typeof argument === "number") {
return `Analizowanie próbki o ID: ${argument}`;
} else {
return `Analizowanie próbki: ${argument}`;
}
}
// Użycie funkcji
const wynik1 = analizujPróbkę(42); // TypeScript wie, że argument to number
const wynik2 = analizujPróbkę("Raptor-01"); // TypeScript wie, że argument to string
// const błąd = analizujPróbkę(true); // Błąd, boolean nie jest akceptowanym typemW powyższym przykładzie:
- Zdefiniowaliśmy dwie sygnatury przeciążeń - jedna przyjmująca
number, druga przyjmującastring - Stworzyliśmy jedną implementację, która obsługuje oba typy
- TypeScript dba o to, aby funkcja była wywoływana tylko z argumentami zgodnych typów
Przeciążanie z różnymi typami zwracanymi
Prawdziwa moc przeciążania ujawnia się, gdy funkcja może zwracać różne typy w zależności od parametrów wejściowych:
// Sygnatury przeciążeń z różnymi typami zwracanymi
function pobierzDaneDinozaura(id: number): { id: number; gatunek: string; wiek: number };
function pobierzDaneDinozaura(nazwa: string): { nazwa: string; gatunek: string };
// Sygnatura implementacji
function pobierzDaneDinozaura(identyfikator: number | string): any {
if (typeof identyfikator === "number") {
// Pobieranie pełnych danych na podstawie ID
return {
id: identyfikator,
gatunek: "Tyrannosaurus",
wiek: 7
};
} else {
// Pobieranie podstawowych informacji na podstawie nazwy
return {
nazwa: identyfikator,
gatunek: "Velociraptor"
};
}
}
// Użycie z pełną informacją o typach
const dinozaurPoId = pobierzDaneDinozaura(42);
console.log(dinozaurPoId.wiek); // OK, TypeScript wie, że właściwość 'wiek' istnieje
const dinozaurPoNazwie = pobierzDaneDinozaura("Blue");
// console.log(dinozaurPoNazwie.wiek); // Błąd, TypeScript wie, że obiekt nie ma właściwości 'wiek'
console.log(dinozaurPoNazwie.gatunek); // OKZwróć uwagę, że mimo użycia any w sygnaturze implementacji, TypeScript zapewnia pełne bezpieczeństwo typów podczas korzystania z funkcji, bazując na sygnaturach przeciążeń.
Przeciążanie z różną liczbą parametrów
Możemy również przeciążać funkcje, które przyjmują różną liczbę parametrów:
// Przeciążenie z różną liczbą parametrów
function monitorujDinozaura(id: number): string;
function monitorujDinozaura(id: number, poziomSzczegółów: "podstawowy" | "pełny"): Object;
function monitorujDinozaura(id: number, poziomSzczegółów?: "podstawowy" | "pełny"): string | Object {
if (!poziomSzczegółów) {
return `Monitorowanie dinozaura o ID ${id}...`;
} else if (poziomSzczegółów === "podstawowy") {
return {
status: "aktywny",
lokalizacja: "Sektor B"
};
} else {
return {
status: "aktywny",
lokalizacja: "Sektor B",
prędkość: "2 km/h",
tętno: 80,
temperaturaCiała: 38,
ostatniPosiłek: "2 godziny temu",
poziomAgresji: "niski"
};
}
}
// Użycie
const komunikat = monitorujDinozaura(5); // Zwraca string
const podstawoweDane = monitorujDinozaura(5, "podstawowy"); // Zwraca prosty obiekt
const szczegółoweDane = monitorujDinozaura(5, "pełny"); // Zwraca rozbudowany obiektPrzeciążanie metod w klasach
Przeciążanie funkcji może być również stosowane do metod w klasach:
class EkipaBadawcza {
// Sygnatury przeciążeń dla metody wyslijZespol
wyslijZespol(cel: { x: number, y: number }): string;
wyslijZespol(sektor: string): string;
wyslijZespol(cel: string, wielkosc: number): string;
// Implementacja metody
wyslijZespol(cel: { x: number, y: number } | string, wielkosc?: number): string {
if (typeof cel === "object") {
return `Wysyłanie zespołu na współrzędne: ${cel.x}, ${cel.y}`;
} else if (wielkosc !== undefined) {
return `Wysyłanie zespołu ${wielkosc}-osobowego do sektora: ${cel}`;
} else {
return `Wysyłanie standardowego zespołu do sektora: ${cel}`;
}
}
}
const ekipa = new EkipaBadawcza();
console.log(ekipa.wyslijZespol({ x: 123, y: 456 })); // Użycie współrzędnych
console.log(ekipa.wyslijZespol("B-5")); // Użycie nazwy sektora
console.log(ekipa.wyslijZespol("C-7", 5)); // Użycie nazwy sektora i wielkości zespołuZaawansowane przykłady przeciążania funkcji
Różne typy dla różnych kombinacji parametrów
// Sygnatury przeciążeń dla złożonej analizy
function analizujZachowanie(
gatunekId: number,
daneBehawioralne: number[]
): { poziomAgresji: number; ryzyko: string };
function analizujZachowanie(
gatunekId: number,
daneBehawioralne: number[],
historyczneDane: boolean
): { poziomAgresji: number; ryzyko: string; porównanie: string };
// Implementacja
function analizujZachowanie(
gatunekId: number,
daneBehawioralne: number[],
historyczneDane?: boolean
): any {
// Podstawowa analiza
const średniaAktywność = daneBehawioralne.reduce((a, b) => a + b, 0) / daneBehawioralne.length;
const poziomAgresji = Math.round(średniaAktywność * 10) / 10;
let ryzyko = "niskie";
if (poziomAgresji > 7) ryzyko = "wysokie";
else if (poziomAgresji > 4) ryzyko = "średnie";
// Podstawowy wynik
const wynik = { poziomAgresji, ryzyko };
// Rozszerzony wynik jeśli żądane są dane historyczne
if (historyczneDane) {
// Symulacja pobrania danych historycznych
const historycznyPoziom = 3.5;
const zmiana = poziomAgresji - historycznyPoziom;
const porównanie = zmiana > 0
? `Wzrost o ${zmiana.toFixed(1)} pkt`
: `Spadek o ${Math.abs(zmiana).toFixed(1)} pkt`;
return { ...wynik, porównanie };
}
return wynik;
}
// Użycie
const podstawowaAnaliza = analizujZachowanie(1, [2, 4, 3, 6, 1]);
console.log(podstawowaAnaliza.ryzyko); // "średnie"
const rozszerzonaAnaliza = analizujZachowanie(1, [2, 4, 3, 6, 1], true);
console.log(rozszerzonaAnaliza.porównanie); // "Wzrost o 0.8 pkt"Generyczne przeciążenia funkcji
Przeciążenia funkcji mogą być jeszcze potężniejsze, gdy połączymy je z generycznymi typami:
// Generyczne przeciążenia funkcji
function pobierzDane<T extends { id: number }>(id: number): T;
function pobierzDane<T extends { nazwa: string }>(nazwa: string): T;
function pobierzDane<T>(identyfikator: number | string): T {
// Implementacja komunikująca się z bazą danych i zwracająca odpowiedni typ
if (typeof identyfikator === "number") {
// Symulacja różnych typów danych dla różnych ID
if (identyfikator < 100) {
// Dinozaur
return {
id: identyfikator,
gatunek: "Tyrannosaurus",
wiek: 7,
waga: 7500
} as unknown as T;
} else {
// Pracownik
return {
id: identyfikator,
imie: "Owen",
nazwisko: "Grady",
stanowisko: "Treser"
} as unknown as T;
}
} else {
// Wyszukiwanie po nazwie
if (identyfikator.includes("REX")) {
return {
nazwa: identyfikator,
gatunek: "Tyrannosaurus",
populacja: 1
} as unknown as T;
} else {
return {
nazwa: identyfikator,
typ: "Sektor",
pojemność: 12
} as unknown as T;
}
}
}
// Interfejsy do typowania
interface Dinozaur {
id: number;
gatunek: string;
wiek: number;
waga: number;
}
interface Pracownik {
id: number;
imie: string;
nazwisko: string;
stanowisko: string;
}
interface Gatunek {
nazwa: string;
gatunek: string;
populacja: number;
}
// Użycie z jawnym określeniem typu generycznego
const trex = pobierzDane<Dinozaur>(1);
console.log(trex.wiek); // OK, TypeScript wie, że to Dinozaur
const pracownik = pobierzDane<Pracownik>(101);
console.log(pracownik.stanowisko); // OK, TypeScript wie, że to Pracownik
const gatunek = pobierzDane<Gatunek>("T-REX-01");
console.log(gatunek.populacja); // OK, TypeScript wie, że to GatunekDobre praktyki i pułapki
1. Sygnatura implementacji musi być kompatybilna z wszystkimi sygnaturami przeciążeń
Parametry w sygnaturze implementacji muszą być tak zdefiniowane, aby mogły obsłużyć wszystkie możliwe kombinacje z sygnatur przeciążeń:
// DOBRZE:
function testuj(a: string): number;
function testuj(a: number, b: boolean): string;
function testuj(a: string | number, b?: boolean): number | string {
// Implementacja
return 0 as any;
}
// ŹLE:
function zle(a: string): number;
function zle(a: number, b: boolean): string;
// Błąd: parametr 'b' w implementacji musi być opcjonalny
function zle(a: string | number, b: boolean): number | string {
return 0 as any;
}2. Sygnatury przeciążeń są sprawdzane po kolei
TypeScript sprawdza sygnatury przeciążeń od góry do dołu, więc bardziej specyficzne sygnatury powinny być definiowane przed bardziej ogólnymi:
// ŹLE - bardziej ogólna sygnatura przesłania bardziej szczegółową
function niewłaściwaKolejność(dane: any[]): number;
function niewłaściwaKolejność(dane: number[]): string; // Ta sygnatura nigdy nie zostanie dopasowana
function niewłaściwaKolejność(dane: any[]): number | string {
if (Array.isArray(dane) && dane.every(d => typeof d === "number")) {
return "Tablica liczb";
} else {
return dane.length;
}
}
// DOBRZE - bardziej specyficzna sygnatura jest pierwsza
function właściwaKolejność(dane: number[]): string;
function właściwaKolejność(dane: any[]): number;
function właściwaKolejność(dane: any[]): number | string {
if (Array.isArray(dane) && dane.every(d => typeof d === "number")) {
return "Tablica liczb";
} else {
return dane.length;
}
}3. Wyważenie między przeciążaniem a parametrami opcjonalnymi i typami unii
Czasami lepszym rozwiązaniem mogą być parametry opcjonalne lub typy unii, zamiast rozbudowanych przeciążeń:
// Zamiast wielu przeciążeń:
function opcja1(id: number): void;
function opcja1(id: number, tryb: string): void;
function opcja1(id: number, tryb: string, extra: boolean): void;
// ...i wiele więcej wersji
// Lepiej użyć parametrów opcjonalnych:
function opcja2(id: number, tryb?: string, extra?: boolean): void {
// Implementacja
}Praktyczny przykład: System zarządzania Parkiem Jurajskim
Zobaczmy kompleksowy przykład, jak przeciążanie funkcji można wykorzystać w systemie zarządzania Parkiem Jurajskim:
// Definiowanie typów używanych w systemie
type StatusDinozaura = "zdrowy" | "chory" | "w leczeniu" | "w śpiączce";
type GatunekDinozaura = "Tyrannosaurus" | "Velociraptor" | "Triceratops" | "Brachiosaurus";
type PoziomZagrożenia = 1 | 2 | 3 | 4 | 5;
interface DanePodstawowe {
id: number;
nazwa: string;
gatunek: GatunekDinozaura;
status: StatusDinozaura;
poziomZagrożenia: PoziomZagrożenia;
}
interface DaneZdrowotne {
temperaturaCiała: number;
tętno: number;
czynnikStresowy: number;
ostatniPosiłek: Date;
wagaKg: number;
}
interface DaneLokalizacyjne {
sektor: string;
współrzędneGPS: [number, number];
ostatniaAktualizacja: Date;
}
interface RaportBezpieczeństwa {
statusOgrodzenia: "sprawne" | "uszkodzone" | "w naprawie";
zasilanieAktywne: boolean;
osobyWSektorze: number;
alertyAktywne: string[];
}
// Klasa do zarządzania dinozaurami z przeciążonymi metodami
class SystemZarządzaniaDinozaurami {
private bazaDanych: Map<number, {
podstawowe: DanePodstawowe;
zdrowotne?: DaneZdrowotne;
lokalizacyjne?: DaneLokalizacyjne;
bezpieczeństwo?: RaportBezpieczeństwa;
}> = new Map();
// Metoda dodająca dinozaura do systemu
dodajDinozaura(dane: DanePodstawowe): number;
dodajDinozaura(dane: DanePodstawowe, zdrowotne: DaneZdrowotne): number;
dodajDinozaura(dane: DanePodstawowe, zdrowotne: DaneZdrowotne, lokalizacja: DaneLokalizacyjne): number;
dodajDinozaura(
dane: DanePodstawowe,
zdrowotne?: DaneZdrowotne,
lokalizacja?: DaneLokalizacyjne
): number {
const nowyRekord = {
podstawowe: dane,
zdrowotne,
lokalizacyjne: lokalizacja
};
this.bazaDanych.set(dane.id, nowyRekord);
console.log(`Dodano dinozaura: ${dane.nazwa} (ID: ${dane.id})`);
return dane.id;
}
// Przeciążona metoda do pobierania danych o dinozaurze
pobierzDane(id: number): DanePodstawowe;
pobierzDane(id: number, typ: "zdrowie"): DaneZdrowotne | undefined;
pobierzDane(id: number, typ: "lokalizacja"): DaneLokalizacyjne | undefined;
pobierzDane(id: number, typ: "bezpieczeństwo"): RaportBezpieczeństwa | undefined;
pobierzDane(id: number, typ: "wszystko"): {
podstawowe: DanePodstawowe;
zdrowotne?: DaneZdrowotne;
lokalizacyjne?: DaneLokalizacyjne;
bezpieczeństwo?: RaportBezpieczeństwa;
};
pobierzDane(id: number, typ?: "zdrowie" | "lokalizacja" | "bezpieczeństwo" | "wszystko"): any {
const rekord = this.bazaDanych.get(id);
if (!rekord) {
throw new Error(`Dinozaur o ID ${id} nie istnieje w systemie.`);
}
if (!typ) {
return rekord.podstawowe;
}
switch (typ) {
case "zdrowie":
return rekord.zdrowotne;
case "lokalizacja":
return rekord.lokalizacyjne;
case "bezpieczeństwo":
return rekord.bezpieczeństwo;
case "wszystko":
return rekord;
}
}
// Przeciążona metoda do aktualizacji danych
aktualizujDane(id: number, dane: Partial<DanePodstawowe>): boolean;
aktualizujDane(id: number, dane: DaneZdrowotne, typ: "zdrowie"): boolean;
aktualizujDane(id: number, dane: DaneLokalizacyjne, typ: "lokalizacja"): boolean;
aktualizujDane(id: number, dane: RaportBezpieczeństwa, typ: "bezpieczeństwo"): boolean;
aktualizujDane(
id: number,
dane: Partial<DanePodstawowe> | DaneZdrowotne | DaneLokalizacyjne | RaportBezpieczeństwa,
typ?: "zdrowie" | "lokalizacja" | "bezpieczeństwo"
): boolean {
const rekord = this.bazaDanych.get(id);
if (!rekord) {
console.error(`Dinozaur o ID ${id} nie istnieje w systemie.`);
return false;
}
if (!typ) {
// Aktualizacja danych podstawowych
rekord.podstawowe = { ...rekord.podstawowe, ...dane as Partial<DanePodstawowe> };
console.log(`Zaktualizowano podstawowe dane dinozaura ID: ${id}`);
} else {
switch (typ) {
case "zdrowie":
rekord.zdrowotne = { ...(rekord.zdrowotne || {}), ...dane as DaneZdrowotne };
console.log(`Zaktualizowano dane zdrowotne dinozaura ID: ${id}`);
break;
case "lokalizacja":
rekord.lokalizacyjne = { ...(rekord.lokalizacyjne || {}), ...dane as DaneLokalizacyjne };
console.log(`Zaktualizowano dane lokalizacyjne dinozaura ID: ${id}`);
break;
case "bezpieczeństwo":
rekord.bezpieczeństwo = { ...(rekord.bezpieczeństwo || {}), ...dane as RaportBezpieczeństwa };
console.log(`Zaktualizowano dane bezpieczeństwa dla dinozaura ID: ${id}`);
break;
}
}
this.bazaDanych.set(id, rekord);
return true;
}
// Przeciążona metoda do generowania raportów
generujRaport(): string; // Raport dla wszystkich dinozaurów
generujRaport(gatunek: GatunekDinozaura): string; // Raport dla wybranego gatunku
generujRaport(poziomZagrożenia: PoziomZagrożenia): string; // Raport dla poziomu zagrożenia
generujRaport(filter?: GatunekDinozaura | PoziomZagrożenia): string {
let dinozaury = Array.from(this.bazaDanych.values()).map(d => d.podstawowe);
if (filter) {
if (typeof filter === "string") {
// Filtrowanie po gatunku
dinozaury = dinozaury.filter(d => d.gatunek === filter);
return this.formatujRaport(`Raport dla gatunku: ${filter}`, dinozaury);
} else {
// Filtrowanie po poziomie zagrożenia
dinozaury = dinozaury.filter(d => d.poziomZagrożenia === filter);
return this.formatujRaport(`Raport dla poziomu zagrożenia: ${filter}`, dinozaury);
}
}
return this.formatujRaport("Pełny raport wszystkich dinozaurów", dinozaury);
}
private formatujRaport(tytuł: string, dinozaury: DanePodstawowe[]): string {
let raport = `=== ${tytuł} ===\n`;
raport += `Data: ${new Date().toLocaleString()}\n`;
raport += `Liczba dinozaurów: ${dinozaury.length}\n\n`;
dinozaury.forEach(d => {
raport += `ID: ${d.id} | ${d.nazwa} | ${d.gatunek} | Status: ${d.status} | Zagrożenie: ${d.poziomZagrożenia}\n`;
});
return raport;
}
}
// Przykładowe użycie systemu
const system = new SystemZarządzaniaDinozaurami();
// Dodawanie dinozaurów z różnymi zestawami danych
const rexId = system.dodajDinozaura({
id: 1,
nazwa: "Rexy",
gatunek: "Tyrannosaurus",
status: "zdrowy",
poziomZagrożenia: 5
});
const raptorId = system.dodajDinozaura(
{
id: 2,
nazwa: "Blue",
gatunek: "Velociraptor",
status: "zdrowy",
poziomZagrożenia: 4
},
{
temperaturaCiała: 38.5,
tętno: 85,
czynnikStresowy: 2.1,
ostatniPosiłek: new Date(Date.now() - 3600000), // 1 godzina temu
wagaKg: 160
}
);
const triceratopsId = system.dodajDinozaura(
{
id: 3,
nazwa: "Tricy",
gatunek: "Triceratops",
status: "zdrowy",
poziomZagrożenia: 2
},
{
temperaturaCiała: 37.2,
tętno: 45,
czynnikStresowy: 1.3,
ostatniPosiłek: new Date(Date.now() - 7200000), // 2 godziny temu
wagaKg: 8500
},
{
sektor: "B-7",
współrzędneGPS: [34.5678, -118.2345],
ostatniaAktualizacja: new Date()
}
);
// Pobieranie różnych typów danych
const rexPodstawowe = system.pobierzDane(rexId);
console.log(`Dinozaur ${rexPodstawowe.nazwa} ma poziom zagrożenia ${rexPodstawowe.poziomZagrożenia}`);
const raptorZdrowie = system.pobierzDane(raptorId, "zdrowie");
if (raptorZdrowie) {
console.log(`Temperatura ciała raptora: ${raptorZdrowie.temperaturaCiała}°C`);
}
const triceratopsLokalizacja = system.pobierzDane(triceratopsId, "lokalizacja");
if (triceratopsLokalizacja) {
console.log(`Triceratops znajduje się w sektorze: ${triceratopsLokalizacja.sektor}`);
}
// Aktualizacja danych
system.aktualizujDane(rexId, { status: "w leczeniu" });
system.aktualizujDane(raptorId,
{
temperaturaCiała: 39.2,
tętno: 95,
czynnikStresowy: 4.5,
ostatniPosiłek: new Date(),
wagaKg: 162
},
"zdrowie"
);
// Generowanie raportów
console.log(system.generujRaport());
console.log(system.generujRaport("Velociraptor"));
console.log(system.generujRaport(5));Podsumowanie
Przeciążanie funkcji to potężny mechanizm TypeScript, który pozwala na tworzenie elastycznych interfejsów API, zachowując jednocześnie pełne bezpieczeństwo typów. Podobnie jak naukowcy w Parku Jurajskim muszą dostosowywać swoje procedury do różnych gatunków dinozaurów, tak programiści mogą tworzyć funkcje, które dostosowują się do różnych zestawów parametrów.
Najważniejsze zasady przeciążania funkcji:
- Definiuj sygnatury przeciążeń przed sygnaturą implementacji
- Sygnatura implementacji musi być kompatybilna ze wszystkimi sygnaturami przeciążeń
- Bardziej szczegółowe sygnatury umieszczaj przed bardziej ogólnymi
- Używaj przeciążeń, gdy chcesz mieć różne typy zwracane dla różnych parametrów wejściowych
- Rozważ alternatywy (parametry opcjonalne, typy unii) dla prostszych przypadków
"W programowaniu, podobnie jak w genetyce dinozaurów," mówi Dr. Wu z uśmiechem, "prawdziwa moc leży w zdolności do adaptacji. Przeciążanie funkcji to jak tworzenie adaptacyjnych sekwencji DNA - ta sama funkcja może wyewoluować, by służyć różnym celom, zachowując przy tym swoją integralność i bezpieczeństwo."
Kod do tej lekcji: index.ts
// Przeciążanie funkcji w Parku Jurajskim
console.log("Przeciążanie funkcji TypeScript\n");
// ===========================================
// 1. Podstawowe przeciążanie
// ===========================================
console.log("=== PODSTAWOWE PRZECIĄŻANIE ===");
// Definicje przeciążeń
function identify(value: string): string;
function identify(value: number): number;
function identify(value: boolean): boolean;
// Implementacja
function identify(value: string | number | boolean): string | number | boolean {
return value;
}
console.log("String:", identify("T-Rex"));
console.log("Number:", identify(8000));
console.log("Boolean:", identify(true));
// ===========================================
// 2. Przeciążanie z różnymi parametrami
// ===========================================
console.log("\n=== RÓŻNE PARAMETRY ===");
// Przeciążenia
function createDinosaur(name: string): string;
function createDinosaur(name: string, species: string): string;
function createDinosaur(name: string, species: string, age: number): string;
// Implementacja
function createDinosaur(
name: string,
species?: string,
age?: number
): string {
let result = `Dinosaur: ${name}`;
if (species) result += `, Species: ${species}`;
if (age !== undefined) result += `, Age: ${age}`;
return result;
}
console.log(createDinosaur("Rexy"));
console.log(createDinosaur("Blue", "Velociraptor"));
console.log(createDinosaur("Charlie", "Velociraptor", 3));
// ===========================================
// 3. Przeciążanie z różnymi zwrotami
// ===========================================
console.log("\n=== RÓŻNE TYPY ZWROTNE ===");
interface Dinosaur {
name: string;
species: string;
age: number;
}
// Przeciążenia z różnymi typami zwrotnymi
function findDinosaur(id: number): Dinosaur | undefined;
function findDinosaur(name: string): Dinosaur[];
// Implementacja
function findDinosaur(
query: number | string
): Dinosaur | undefined | Dinosaur[] {
const database: Dinosaur[] = [
{ name: "Rexy", species: "T-Rex", age: 5 },
{ name: "Blue", species: "Velociraptor", age: 3 },
{ name: "Charlie", species: "Velociraptor", age: 3 }
];
if (typeof query === "number") {
return database[query];
} else {
return database.filter(d => d.name.includes(query));
}
}
console.log("Find by ID:", findDinosaur(0));
console.log("Find by name:", findDinosaur("Blue"));
// ===========================================
// 4. Przeciążanie z obiektami
// ===========================================
console.log("\n=== PRZECIĄŻANIE Z OBIEKTAMI ===");
interface SearchByName {
type: "name";
name: string;
}
interface SearchBySpecies {
type: "species";
species: string;
}
interface SearchByAge {
type: "age";
minAge: number;
maxAge: number;
}
type SearchCriteria = SearchByName | SearchBySpecies | SearchByAge;
// Przeciążenia
function search(criteria: SearchByName): Dinosaur[];
function search(criteria: SearchBySpecies): Dinosaur[];
function search(criteria: SearchByAge): Dinosaur[];
// Implementacja
function search(criteria: SearchCriteria): Dinosaur[] {
const database: Dinosaur[] = [
{ name: "Rexy", species: "T-Rex", age: 5 },
{ name: "Blue", species: "Velociraptor", age: 3 },
{ name: "Charlie", species: "Velociraptor", age: 3 },
{ name: "Delta", species: "Velociraptor", age: 4 }
];
if (criteria.type === "name") {
return database.filter(d => d.name === criteria.name);
} else if (criteria.type === "species") {
return database.filter(d => d.species === criteria.species);
} else {
return database.filter(
d => d.age >= criteria.minAge && d.age <= criteria.maxAge
);
}
}
console.log("Search by name:", search({ type: "name", name: "Blue" }));
console.log("Search by species:", search({ type: "species", species: "Velociraptor" }));
console.log("Search by age:", search({ type: "age", minAge: 3, maxAge: 4 }));
// ===========================================
// 5. Przeciążanie metod w klasach
// ===========================================
console.log("\n=== METODY W KLASACH ===");
class DinosaurManager {
private dinosaurs: Dinosaur[] = [];
// Przeciążenia
add(dino: Dinosaur): void;
add(name: string, species: string, age: number): void;
// Implementacja
add(
dinoOrName: Dinosaur | string,
species?: string,
age?: number
): void {
if (typeof dinoOrName === "string") {
this.dinosaurs.push({
name: dinoOrName,
species: species!,
age: age!
});
} else {
this.dinosaurs.push(dinoOrName);
}
}
getAll(): Dinosaur[] {
return [...this.dinosaurs];
}
// Przeciążenia get
get(index: number): Dinosaur | undefined;
get(name: string): Dinosaur | undefined;
// Implementacja
get(indexOrName: number | string): Dinosaur | undefined {
if (typeof indexOrName === "number") {
return this.dinosaurs[indexOrName];
} else {
return this.dinosaurs.find(d => d.name === indexOrName);
}
}
}
const manager = new DinosaurManager();
manager.add({ name: "Rexy", species: "T-Rex", age: 5 });
manager.add("Blue", "Velociraptor", 3);
console.log("Get by index:", manager.get(0));
console.log("Get by name:", manager.get("Blue"));
// ===========================================
// 6. Przeciążanie z Generics
// ===========================================
console.log("\n=== GENERICS Z PRZECIĄŻANIEM ===");
// Przeciążenia
function process<T extends string>(value: T): string;
function process<T extends number>(value: T): number;
function process<T extends boolean>(value: T): boolean;
// Implementacja
function process<T extends string | number | boolean>(
value: T
): string | number | boolean {
if (typeof value === "string") {
return value.toUpperCase();
} else if (typeof value === "number") {
return value * 2;
} else {
return !value;
}
}
console.log("Process string:", process("hello"));
console.log("Process number:", process(21));
console.log("Process boolean:", process(true));
// ===========================================
// 7. Zaawansowane przeciążanie
// ===========================================
console.log("\n=== ZAAWANSOWANE PRZECIĄŻANIE ===");
interface FeedOptions {
type: "scheduled";
time: Date;
}
interface EmergencyFeedOptions {
type: "emergency";
reason: string;
}
// Przeciążenia
function feedDinosaur(
dinosaur: Dinosaur,
amount: number
): void;
function feedDinosaur(
dinosaur: Dinosaur,
amount: number,
options: FeedOptions
): void;
function feedDinosaur(
dinosaur: Dinosaur,
amount: number,
options: EmergencyFeedOptions
): void;
// Implementacja
function feedDinosaur(
dinosaur: Dinosaur,
amount: number,
options?: FeedOptions | EmergencyFeedOptions
): void {
if (!options) {
console.log(`Feeding ${dinosaur.name} with ${amount}kg`);
} else if (options.type === "scheduled") {
console.log(`Scheduled feeding for ${dinosaur.name} at ${options.time.toISOString()}`);
} else {
console.log(`Emergency feeding for ${dinosaur.name}: ${options.reason}`);
}
}
const trex = { name: "Rexy", species: "T-Rex", age: 5 };
feedDinosaur(trex, 400);
feedDinosaur(trex, 400, { type: "scheduled", time: new Date() });
feedDinosaur(trex, 600, { type: "emergency", reason: "Very hungry" });
// ===========================================
// 8. Przeciążanie konstruktorów
// ===========================================
console.log("\n=== KONSTRUKTORY ===");
class Paddock {
id: string;
name: string;
capacity: number;
// Przeciążenia konstruktorów (syntaktycznie)
constructor(id: string);
constructor(id: string, name: string);
constructor(id: string, name: string, capacity: number);
// Implementacja
constructor(id: string, name?: string, capacity?: number) {
this.id = id;
this.name = name || `Paddock ${id}`;
this.capacity = capacity || 10;
}
getInfo(): string {
return `${this.name} (ID: ${this.id}, Capacity: ${this.capacity})`;
}
}
const paddock1 = new Paddock("P-01");
const paddock2 = new Paddock("P-02", "T-Rex Territory");
const paddock3 = new Paddock("P-03", "Raptor Pen", 5);
console.log(paddock1.getInfo());
console.log(paddock2.getInfo());
console.log(paddock3.getInfo());
// ===========================================
// 9. Przeciążanie z Promise
// ===========================================
console.log("\n=== PRZECIĄŻANIE Z PROMISE ===");
// Przeciążenia
function fetchData(sync: true): Dinosaur;
function fetchData(sync: false): Promise<Dinosaur>;
// Implementacja
function fetchData(sync: boolean): Dinosaur | Promise<Dinosaur> {
const dino: Dinosaur = {
name: "Rexy",
species: "T-Rex",
age: 5
};
if (sync) {
return dino;
} else {
return Promise.resolve(dino);
}
}
const syncData = fetchData(true);
console.log("Sync data:", syncData);
fetchData(false).then(asyncData => {
console.log("Async data:", asyncData);
});
// ===========================================
// 10. Podsumowanie
// ===========================================
console.log("\n=== PODSUMOWANIE ===");
console.log("Podstawowe przeciążanie - różne sygnatury");
console.log("Różne parametry - opcjonalne argumenty");
console.log("Różne zwroty - typ zależy od parametrów");
console.log("Obiekty - discriminated unions");
console.log("Metody w klasach - przeciążanie metod");
console.log("Generics - przeciążanie z typami generycznymi");
console.log("Konstruktory - przeciążanie konstruktorów");
console.log("Promise - synchroniczny vs asynchroniczny");
console.log("\nPrzeciążanie funkcji opanowane!");Hasła z dokumentacji w tej lekcji
Widzisz błąd w tej lekcji?
Sprawdź się
Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.
1. Czym jest przeciążanie funkcji (function overloading) w TypeScript?
2. Ile sygnatur implementacji może mieć przeciążona funkcja w TypeScript?
To 2 z 4 pytań do tej lekcji. Pozostałe rozwiążesz w grze.
Zadania praktyczne w grze
- Edytor kodu
Stwórz przeciążoną funkcję findDino, która przyjmuje id (number) lub nazwę (string) i zwraca odpowiedni wynik.
- Klikanie w kolejności
Ułóż elementy przeciążonej funkcji w TypeScript:
- Edytor kodu
Stwórz funkcję, która przyjmuje parametr typu string | number i używa typeof jako type guard do zwrócenia odpowiedniego opisu dinozaura.
- Układanie w pionie
Ułóż interfejsy od najbardziej ogólnego (bazowego) do najbardziej szczegółowego (rozszerzającego):
- Klikanie w kolejności
Ułóż elementy deklaracji przeciążonej funkcji findDino w TypeScript:
Zadania po tej lekcji
- PytanieCzym jest przeciążanie funkcji
- PytanieSygnatura implementacji
- Zadanie z kodemPraktyka: Przeciążanie funkcji
- Kliknij w kolejnościSortowanie: Składnia przeciążania funkcji
- PytanieTyp generyczny vs type alias
- PytanieInterfejs vs type alias
- Zadanie z kodemTyp union z type guard
- Ułóż w kolejnościKolejność rozszerzania interfejsów
- Kliknij w kolejnościSygnatura przeciążonej funkcji