Kurs JavaScript i TypeScript · Moduł 6: Podstawy TypeScript

Przeciążanie funkcji

12 min czytania ·
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:

  1. Sygnatury przeciążeń (overload signatures) - definicje typów parametrów i zwracanych wartości
  2. 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 typem

W powyższym przykładzie:

  1. Zdefiniowaliśmy dwie sygnatury przeciążeń - jedna przyjmująca number, druga przyjmująca string
  2. Stworzyliśmy jedną implementację, która obsługuje oba typy
  3. 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);  // OK

Zwróć 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 obiekt

Przeciąż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łu

Zaawansowane 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 Gatunek

Dobre 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:

  1. Definiuj sygnatury przeciążeń przed sygnaturą implementacji
  2. Sygnatura implementacji musi być kompatybilna ze wszystkimi sygnaturami przeciążeń
  3. Bardziej szczegółowe sygnatury umieszczaj przed bardziej ogólnymi
  4. Używaj przeciążeń, gdy chcesz mieć różne typy zwracane dla różnych parametrów wejściowych
  5. 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. 1. Czym jest przeciążanie funkcji (function overloading) w TypeScript?

  2. 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:

  1. PytanieCzym jest przeciążanie funkcji
  2. PytanieSygnatura implementacji
  3. Zadanie z kodemPraktyka: Przeciążanie funkcji
  4. Kliknij w kolejnościSortowanie: Składnia przeciążania funkcji
  5. PytanieTyp generyczny vs type alias
  6. PytanieInterfejs vs type alias
  7. Zadanie z kodemTyp union z type guard
  8. Ułóż w kolejnościKolejność rozszerzania interfejsów
  9. Kliknij w kolejnościSygnatura przeciążonej funkcji

Przydatne artykuły