Kurs JavaScript i TypeScript · Moduł 6: Podstawy TypeScript

Typy parametrów i zwracanych wartości

14 min czytania ·
W tej lekcji11

Witaj ponownie w Parku Jurajskim! Po wielu wycieczkach po interfejsach i typach, Dr. Henry Wu zabierze nas dzisiaj do centrum operacyjnego parku, gdzie przyjrzymy się dokładniej typowaniu funkcji - czyli określaniu typów parametrów i zwracanych wartości. Jest to kluczowy element zapewnienia bezpieczeństwa i przewidywalności w naszym systemie zarządzania parkiem - podobnie jak ścisłe protokoły bezpieczeństwa są niezbędne dla sprawnego funkcjonowania Parku Jurajskiego.

Podstawy typowania funkcji

Określanie typów parametrów i zwracanych wartości to fundamentalny element TypeScript. Pozwala nam to jasno zdefiniować, jakie dane funkcja przyjmuje i co zwraca - tworząc wyraźny "kontrakt" dla tej funkcji.

// Podstawowa funkcja z typowanymi parametrami i zwracaną wartością
function obliczWymaganiaPokarmowe(
  waga: number,
  jestDrapieżnikiem: boolean,
  wiek: number
): number {
  // Dinozaury drapieżne potrzebują więcej kalorii
  const wspólczynnikDiety = jestDrapieżnikiem ? 0.05 : 0.03;

  // Młode dinozaury potrzebują więcej kalorii na jednostkę masy
  const współczynnikWieku = wiek < 5 ? 1.2 : 1.0;

  // Dzienna ilość pokarmu w kilogramach
  return waga * wspólczynnikDiety * współczynnikWieku;
}

// Użycie funkcji
const dziennyPosiłekTRex = obliczWymaganiaPokarmowe(7500, true, 7);
console.log(`Dzienna ilość pokarmu dla T-Rex: ${dziennyPosiłekTRex} kg`);

const dziennyPosiłekBrachiosaurus = obliczWymaganiaPokarmowe(35000, false, 22);
console.log(`Dzienna ilość pokarmu dla Brachiosaurusa: ${dziennyPosiłekBrachiosaurus} kg`);

Funkcja powyżej jasno definiuje, że przyjmuje trzy parametry: waga (number), jestDrapieżnikiem (boolean) i wiek (number), a zwraca wartość typu number. Dzięki temu IDE i kompilator TypeScript będą w stanie wychwycić potencjalne błędy, takie jak próba wywołania funkcji z nieprawidłowymi typami argumentów.

Parametry opcjonalne i domyślne

W Parku Jurajskim, niektóre procedury mają parametry opcjonalne lub domyślne wartości. Na przykład, gdy zlecamy badanie dinozaura, możemy określić poziom priorytetowości, ale jeśli tego nie zrobimy, przyjmowana jest standardowa wartość.

// Funkcja z parametrem opcjonalnym
function zaplanujBadanieDinozaura(
  id: string,
  typ: "rutynowe" | "specjalistyczne",
  priorytet?: 1 | 2 | 3 // Opcjonalny parametr
): string {
  // Jeśli priorytet nie został określony, używamy domyślnej wartości
  const faktycznyPriorytet = priorytet || 2;

  // Określamy termin badania na podstawie priorytetu
  let terminWDniach: number;
  switch (faktycznyPriorytet) {
    case 1: terminWDniach = 1; break;   // Nagły przypadek - następny dzień
    case 2: terminWDniach = 7; break;   // Standardowy priorytet - tydzień
    case 3: terminWDniach = 30; break;  // Niski priorytet - miesiąc
    default: terminWDniach = 7;
  }

  // Obliczamy datę badania
  const dataBadania = new Date();
  dataBadania.setDate(dataBadania.getDate() + terminWDniach);

  return `Badanie ${typ} dla dinozaura ${id} zaplanowane na ${dataBadania.toLocaleDateString()} (priorytet: ${faktycznyPriorytet})`;
}

// Wywołanie z wszystkimi parametrami
console.log(zaplanujBadanieDinozaura("TREX-01", "specjalistyczne", 1));

// Wywołanie bez parametru opcjonalnego
console.log(zaplanujBadanieDinozaura("STEG-03", "rutynowe"));

// Alternatywnie, można użyć parametru z wartością domyślną
function zaplanujBadanieDinozaura2(
  id: string,
  typ: "rutynowe" | "specjalistyczne",
  priorytet: 1 | 2 | 3 = 2 // Parametr z wartością domyślną
): string {
  // Reszta implementacji jak wyżej...
  const dataBadania = new Date();
  dataBadania.setDate(dataBadania.getDate() + (priorytet === 1 ? 1 : priorytet === 2 ? 7 : 30));

  return `Badanie ${typ} dla dinozaura ${id} zaplanowane na ${dataBadania.toLocaleDateString()} (priorytet: ${priorytet})`;
}

// Wywołanie bez podania parametru z wartością domyślną
console.log(zaplanujBadanieDinozaura2("TRIC-02", "rutynowe"));

Zauważ różnicę między parametrem opcjonalnym (oznaczanym przez ?) a parametrem z wartością domyślną (określanym przez = wartość). W obu przypadkach możemy pominąć ten parametr przy wywołaniu funkcji, ale podejście z wartością domyślną jest bardziej eleganckie i czytelne.

Typy zwracanych wartości

W typowaniu funkcji równie ważne jak typy parametrów są typy zwracanych wartości. TypeScript pozwala na precyzyjne określenie, co dokładnie funkcja zwraca, co pomaga w wykrywaniu potencjalnych błędów.

// Funkcja zwracająca liczbę
function obliczPojemnośćWybiegu(
  długość: number,
  szerokość: number,
  typDinozaura: "mały" | "średni" | "duży"
): number {
  const powierzchnia = długość * szerokość;

  // Ile dinozaurów danego typu można bezpiecznie umieścić na danej powierzchni
  switch (typDinozaura) {
    case "mały": return Math.floor(powierzchnia / 50);
    case "średni": return Math.floor(powierzchnia / 200);
    case "duży": return Math.floor(powierzchnia / 1000);
    default: return 0;
  }
}

// Funkcja zwracająca string
function generujIdentyfikatorDinozaura(
  gatunek: string,
  numer: number
): string {
  // Tworzymy identyfikator na podstawie pierwszych 4 liter gatunku i numeru
  const prefiks = gatunek.slice(0, 4).toUpperCase();
  // Formatujemy numer jako 3-cyfrowy z wiodącymi zerami
  const numerSformatowany = numer.toString().padStart(3, '0');

  return `${prefiks}-${numerSformatowany}`;
}

// Funkcja zwracająca boolean
function czyWybiegBezpieczny(
  poziomBezpieczeństwa: number,
  wymaganyPoziom: number,
  ostatniPrzegląd: Date
): boolean {
  // Sprawdzamy, czy poziom bezpieczeństwa jest wystarczający
  if (poziomBezpieczeństwa < wymaganyPoziom) {
    return false;
  }

  // Sprawdzamy, czy przegląd był w ciągu ostatnich 30 dni
  const dzisiaj = new Date();
  const trzydzieściDniTemu = new Date(dzisiaj);
  trzydzieściDniTemu.setDate(dzisiaj.getDate() - 30);

  return ostatniPrzegląd >= trzydzieściDniTemu;
}

// Przykłady użycia
const pojemnośćWybiegRaptorów = obliczPojemnośćWybiegu(100, 50, "średni");
console.log(`Wybieg raptorów może pomieścić ${pojemnośćWybiegRaptorów} osobników`);

const idNowegoDinozaura = generujIdentyfikatorDinozaura("Velociraptor", 42);
console.log(`Nowy raptor otrzymał ID: ${idNowegoDinozaura}`);

const statusWybiegTRex = czyWybiegBezpieczny(
  5, // aktualny poziom
  5, // wymagany poziom
  new Date(2023, 4, 15) // data ostatniego przeglądu (15 maja 2023)
);
console.log(`Status bezpieczeństwa wybiegu T-Rex: ${statusWybiegTRex ? "BEZPIECZNY" : "WYMAGA UWAGI"}`);

Funkcje zwracające void

Niektóre funkcje nie zwracają wartości - są wywoływane głównie dla ich efektów ubocznych, takich jak modyfikacja stanu systemu, wyświetlanie informacji czy zapisywanie danych. W TypeScript taki przypadek oznaczamy typem zwracanej wartości void.

// Funkcja nie zwracająca wartości (void)
function zarejestrujZmianyOgrodzenia(
  idWybiegu: string,
  napięcie: number,
  dataZmiany: Date = new Date() // Domyślnie używamy aktualnej daty
): void {
  // Zapisujemy informację o zmianie napięcia w ogrodzeniu
  console.log(`[${dataZmiany.toISOString()}] Zmieniono napięcie w ogrodzeniu wybiegu ${idWybiegu} na ${napięcie}V`);

  // W rzeczywistej aplikacji zapisalibyśmy te dane w bazie
  // Funkcja nie zwraca żadnej wartości
}

// Wywołanie funkcji void
zarejestrujZmianyOgrodzenia("TRX-PADDOCK", 10000);

Funkcje zwracające różne typy (union types)

W niektórych przypadkach funkcja może zwracać różne typy wartości w zależności od warunków lub parametrów. W TypeScript możemy to określić za pomocą union types.

// Funkcja zwracająca różne typy wartości
function pobierzDaneDinozaura(
  id: string,
  formatDanych: "podsumowanie" | "pełny" | "JSON"
): string | object | null {
  // Symulacja bazy danych
  const bazaDanych: Record<string, {
    nazwa: string;
    gatunek: string;
    wiek: number;
    waga: number;
    statusZdrowia: string;
  }> = {
    "TREX-001": {
      nazwa: "Rexy",
      gatunek: "Tyrannosaurus Rex",
      wiek: 7,
      waga: 8000,
      statusZdrowia: "dobry"
    },
    "VEL-001": {
      nazwa: "Blue",
      gatunek: "Velociraptor",
      wiek: 4,
      waga: 160,
      statusZdrowia: "doskonały"
    }
  };

  // Sprawdzamy, czy dinozaur istnieje
  if (!bazaDanych[id]) {
    console.error(`Nie znaleziono dinozaura o ID ${id}`);
    return null;
  }

  const dino = bazaDanych[id];

  // Zwracamy różne formaty w zależności od parametru
  switch (formatDanych) {
    case "podsumowanie":
      return `${dino.nazwa} (${dino.gatunek}): ${dino.statusZdrowia}`;

    case "pełny":
      return `
        ID: ${id}
        Nazwa: ${dino.nazwa}
        Gatunek: ${dino.gatunek}
        Wiek: ${dino.wiek} lat
        Waga: ${dino.waga} kg
        Status zdrowia: ${dino.statusZdrowia}
      `;

    case "JSON":
      return { id, ...dino };

    default:
      return null;
  }
}

// Przykłady użycia
const podsumowanieRexy = pobierzDaneDinozaura("TREX-001", "podsumowanie");
console.log(podsumowanieRexy);

const pełneDaneBlue = pobierzDaneDinozaura("VEL-001", "pełny");
console.log(pełneDaneBlue);

const jsonDaneRexy = pobierzDaneDinozaura("TREX-001", "JSON") as object;
console.log(JSON.stringify(jsonDaneRexy, null, 2));

// Obsługa błędnych danych
const nieistniejącyDinozaur = pobierzDaneDinozaura("INDOMINUS-001", "podsumowanie");
if (nieistniejącyDinozaur === null) {
  console.log("Nie znaleziono dinozaura");
}

Funkcja pobierzDaneDinozaura zwraca string, object lub null w zależności od parametrów i warunków. Dzięki union types TypeScript wie, że wynik może być jednym z tych trzech typów i odpowiednio weryfikuje kod, który używa tej funkcji.

Typ funkcji (Function Types)

TypeScript umożliwia również definiowanie typów samych funkcji, co jest niezwykle przydatne przy przekazywaniu funkcji jako parametrów lub przypisywaniu ich do zmiennych.

// Definicja typu funkcji
type FunkcjaAlarmowa = (
  poziomZagrożenia: number,
  lokalizacja: string,
  komunikat: string
) => void;

// Funkcja używająca funkcji jako parametru
function uruchomProceduręBezpieczeństwa(
  idWybiegu: string,
  poziomZagrożenia: number,
  funkcjaAlarmowa: FunkcjaAlarmowa
): void {
  console.log(`Uruchamianie procedury bezpieczeństwa dla wybiegu ${idWybiegu}`);

  // Zamykanie bram
  console.log(`- Zamykanie bram wybiegu ${idWybiegu}`);

  // Aktywacja dodatkowych zabezpieczeń
  if (poziomZagrożenia >= 4) {
    console.log("- Aktywacja dodatkowego ogrodzenia elektrycznego");
    console.log("- Wysłanie personelu bezpieczeństwa");
  }

  // Wywołanie przekazanej funkcji alarmowej
  funkcjaAlarmowa(
    poziomZagrożenia,
    `Wybieg ${idWybiegu}`,
    `Uruchomiono procedurę bezpieczeństwa poziomu ${poziomZagrożenia}`
  );
}

// Implementacja funkcji alarmowej
const alertDlaCentrumKontroli: FunkcjaAlarmowa = (poziom, lokalizacja, komunikat) => {
  console.log("=== ALERT DLA CENTRUM KONTROLI ===");
  console.log(`Poziom zagrożenia: ${poziom}`);
  console.log(`Lokalizacja: ${lokalizacja}`);
  console.log(`Komunikat: ${komunikat}`);
  console.log("===================================");
};

// Alternatywna funkcja alarmowa
const alertDlaPersoneluParku: FunkcjaAlarmowa = (poziom, lokalizacja, komunikat) => {
  const priorytet = poziom >= 4 ? "KRYTYCZNY" : poziom >= 2 ? "WAŻNY" : "INFORMACYJNY";
  console.log(`[${priorytet}] ${komunikat} w ${lokalizacja}`);

  // W rzeczywistej aplikacji wysłalibyśmy tutaj powiadomienia do personelu
};

// Użycie funkcji z różnymi implementacjami funkcji alarmowej
uruchomProceduręBezpieczeństwa("RAPTOR-01", 3, alertDlaCentrumKontroli);
uruchomProceduręBezpieczeństwa("TREX-01", 5, alertDlaPersoneluParku);

W powyższym przykładzie zdefiniowaliśmy typ funkcji FunkcjaAlarmowa, który określa sygnaturę funkcji przyjmującej trzy parametry i nie zwracającej wartości. Następnie użyliśmy tego typu, aby zdefiniować parametr w funkcji uruchomProceduręBezpieczeństwa i implementacje konkretnych funkcji alarmowych.

Typowanie funkcji z callbackiem

Funkcje z callbackami są powszechne w JavaScript, szczególnie w operacjach asynchronicznych. TypeScript pozwala na precyzyjne typowanie takich funkcji.

// Funkcja z callbackiem typowanym inline
function monitorujZdrowieZwierzęcia(
  idZwierzęcia: string,
  interwałWSekundach: number,
  callback: (dane: { temperatura: number; tętno: number; poziomStresu: number }) => void
): void {
  console.log(`Rozpoczęto monitoring zdrowia zwierzęcia ${idZwierzęcia} co ${interwałWSekundach} sekund`);

  // Symulacja pierwszego pomiaru
  const danePoczątkowe = {
    temperatura: 38.5,
    tętno: 72,
    poziomStresu: 3
  };

  // Wywołanie callbacka z pierwszymi danymi
  callback(danePoczątkowe);

  // W rzeczywistej aplikacji ustawilibyśmy tutaj interwał do regularnego monitorowania
  console.log("Monitoring uruchomiony");
}

// Użycie funkcji z callbackiem
monitorujZdrowieZwierzęcia("TREX-001", 60, (dane) => {
  console.log("Otrzymano nowe dane zdrowotne:");
  console.log(`- Temperatura: ${dane.temperatura}°C`);
  console.log(`- Tętno: ${dane.tętno} uderzeń/min`);
  console.log(`- Poziom stresu: ${dane.poziomStresu}/10`);

  // Sprawdzenie alertów zdrowotnych
  if (dane.temperatura > 39.5) {
    console.log("ALERT: Podwyższona temperatura!");
  }

  if (dane.tętno > 100) {
    console.log("ALERT: Przyspieszone tętno!");
  }

  if (dane.poziomStresu > 7) {
    console.log("ALERT: Wysoki poziom stresu!");
  }
});

// Można również zdefiniować typ callbacka oddzielnie
type CallbackMonitoringuZdrowia = (dane: {
  temperatura: number;
  tętno: number;
  poziomStresu: number;
  timeStamp?: Date; // opcjonalny parametr
}) => void;

// Funkcja z typem callbacka
function zaawansowanyMonitoringZdrowia(
  idZwierzęcia: string,
  opcje: { interwał: number; powiadomienia: boolean },
  callback: CallbackMonitoringuZdrowia
): void {
  console.log(`Konfiguracja zaawansowanego monitoringu dla ${idZwierzęcia}`);
  console.log(`- Interwał: ${opcje.interwał} sekund`);
  console.log(`- Powiadomienia: ${opcje.powiadomienia ? "włączone" : "wyłączone"}`);

  // Symulacja danych z timestampem
  const dane = {
    temperatura: 38.2,
    tętno: 68,
    poziomStresu: 2,
    timeStamp: new Date()
  };

  callback(dane);
}

// Użycie funkcji z typem callbacka
zaawansowanyMonitoringZdrowia("STEG-003", { interwał: 120, powiadomienia: true }, (dane) => {
  const czasPomiaru = dane.timeStamp ? dane.timeStamp.toISOString() : "nieznany";
  console.log(`[${czasPomiaru}] Dane zdrowotne: T:${dane.temperatura}°C, HR:${dane.tętno}, Stres:${dane.poziomStresu}/10`);
});

Funkcje generyczne

Jedną z najpotężniejszych funkcji TypeScript są generyki, które pozwalają na tworzenie funkcji i typów, które działają z różnymi typami danych, zachowując przy tym bezpieczeństwo typów.

// Funkcja generyczna do filtrowania danych
function filtrujDane<T>(
  dane: T[],
  predykat: (element: T) => boolean
): T[] {
  return dane.filter(predykat);
}

// Przykładowe dane dinozaurów
interface DaneDino {
  id: string;
  nazwa: string;
  gatunek: string;
  waga: number;
  poziomNiebezpieczeństwa: number;
}

const dinozaury: DaneDino[] = [
  { id: "TREX-001", nazwa: "Rexy", gatunek: "T-Rex", waga: 8000, poziomNiebezpieczeństwa: 5 },
  { id: "VEL-001", nazwa: "Blue", gatunek: "Velociraptor", waga: 150, poziomNiebezpieczeństwa: 4 },
  { id: "TRIC-001", nazwa: "Tri", gatunek: "Triceratops", waga: 9000, poziomNiebezpieczeństwa: 2 },
  { id: "STEG-001", nazwa: "Spike", gatunek: "Stegosaurus", waga: 5000, poziomNiebezpieczeństwa: 2 },
  { id: "BRACH-001", nazwa: "Brachie", gatunek: "Brachiosaurus", waga: 40000, poziomNiebezpieczeństwa: 1 }
];

// Użycie generycznej funkcji z typem DaneDino
const niebezpieczneDinozaury = filtrujDane<DaneDino>(
  dinozaury,
  dino => dino.poziomNiebezpieczeństwa >= 4
);

console.log("Niebezpieczne dinozaury:");
niebezpieczneDinozaury.forEach(dino => {
  console.log(`- ${dino.nazwa} (${dino.gatunek}): poziom zagrożenia ${dino.poziomNiebezpieczeństwa}`);
});

// Użycie tej samej funkcji z innym typem danych
const temperatury = [28.5, 29.2, 30.1, 27.8, 31.5, 30.8, 32.1, 29.5];
const wysokieTemperatury = filtrujDane<number>(
  temperatury,
  temp => temp > 30
);

console.log(`Zarejestrowano ${wysokieTemperatury.length} pomiarów z temperaturą powyżej 30°C`);

// Bardziej złożona funkcja generyczna dla operacji na danych
function przetwórzIZwróćDane<T, U>(
  dane: T[],
  transformacja: (element: T) => U
): U[] {
  return dane.map(transformacja);
}

// Użycie złożonej funkcji generycznej
const raportDinozaurów = przetwórzIZwróćDane<DaneDino, { nazwa: string; poziomZagrożenia: string }>(
  dinozaury,
  dino => ({
    nazwa: `${dino.nazwa} (${dino.gatunek})`,
    poziomZagrożenia: dino.poziomNiebezpieczeństwa >= 4
      ? "WYSOKI"
      : dino.poziomNiebezpieczeństwa >= 3
        ? "ŚREDNI"
        : "NISKI"
  })
);

console.log("Raport zagrożeń:");
raportDinozaurów.forEach(raport => {
  console.log(`- ${raport.nazwa}: ${raport.poziomZagrożenia}`);
});

Funkcje generyczne są niezwykle elastyczne i pozwalają na wielokrotne wykorzystanie tej samej logiki z różnymi typami danych, przy jednoczesnym zachowaniu bezpieczeństwa typów.

Przeciążanie funkcji (Function Overloading)

TypeScript umożliwia przeciążanie funkcji, co pozwala na zdefiniowanie wielu sygnatur funkcji z różnymi typami parametrów i zwracanych wartości.

// Przeciążenie funkcji dla różnych formatów ID
// Definicje sygnatur funkcji
function generujIdentyfikator(typ: "dinozaur", numer: number): string;
function generujIdentyfikator(typ: "pracownik", imię: string, nazwisko: string): string;
function generujIdentyfikator(typ: "lokalizacja", strefa: string, numer: number): string;

// Implementacja funkcji obsługująca wszystkie przypadki
function generujIdentyfikator(
  typ: "dinozaur" | "pracownik" | "lokalizacja",
  wartość1: number | string,
  wartość2?: string
): string {
  switch (typ) {
    case "dinozaur":
      // wartość1 jest numerem
      return `DINO-${(wartość1 as number).toString().padStart(3, '0')}`;

    case "pracownik":
      // wartość1 jest imieniem, wartość2 jest nazwiskiem
      if (typeof wartość1 === "string" && typeof wartość2 === "string") {
        const inicjały = `${wartość1.charAt(0)}${wartość2.charAt(0)}`.toUpperCase();
        return `EMP-${inicjały}-${Math.floor(Math.random() * 1000).toString().padStart(3, '0')}`;
      }
      throw new Error("Nieprawidłowe parametry dla typu 'pracownik'");

    case "lokalizacja":
      // wartość1 jest strefą, wartość2 jest numerem
      if (typeof wartość1 === "string" && typeof wartość2 === "number") {
        return `LOC-${wartość1.toUpperCase()}-${wartość2.toString().padStart(2, '0')}`;
      }
      throw new Error("Nieprawidłowe parametry dla typu 'lokalizacja'");

    default:
      throw new Error(`Nieznany typ identyfikatora: ${typ}`);
  }
}

// Przykłady użycia dla różnych przeciążeń
const idDinozaura = generujIdentyfikator("dinozaur", 42);
console.log(`ID dinozaura: ${idDinozaura}`);

const idPracownika = generujIdentyfikator("pracownik", "John", "Hammond");
console.log(`ID pracownika: ${idPracownika}`);

const idLokalizacji = generujIdentyfikator("lokalizacja", "A", 5);
console.log(`ID lokalizacji: ${idLokalizacji}`);

Przeciążanie funkcji pozwala na tworzenie bardziej elastycznych i czytelnych interfejsów API, gdzie ta sama funkcja może obsługiwać różne zestawy parametrów.

Typowanie funkcji asynchronicznych

W nowoczesnym JavaScript często używamy funkcji asynchronicznych. TypeScript doskonale współpracuje z obietnicami (Promises) i słowami kluczowymi async/await.

// Funkcja asynchroniczna zwracająca Promise<string>
async function pobierzDaneDinozauraZAPI(id: string): Promise<string> {
  console.log(`Pobieranie danych dinozaura ${id} z API...`);

  // Symulacja opóźnienia sieciowego
  await new Promise(resolve => setTimeout(resolve, 1000));

  // Symulacja danych z API
  const dinozaury: Record<string, { nazwa: string; gatunek: string }> = {
    "TREX-001": { nazwa: "Rexy", gatunek: "Tyrannosaurus Rex" },
    "VEL-001": { nazwa: "Blue", gatunek: "Velociraptor" }
  };

  if (dinozaury[id]) {
    const dino = dinozaury[id];
    return `${dino.nazwa} (${dino.gatunek})`;
  } else {
    throw new Error(`Nie znaleziono dinozaura o ID ${id}`);
  }
}

// Funkcja asynchroniczna zwracająca Promise<boolean>
async function sprawdźStatusZdrowia(id: string): Promise<boolean> {
  console.log(`Sprawdzanie statusu zdrowia dinozaura ${id}...`);

  try {
    // Symulacja opóźnienia
    await new Promise(resolve => setTimeout(resolve, 800));

    // Symulacja wyniku (dla uproszczenia zawsze zwraca true)
    return true;
  } catch (error) {
    console.error(`Błąd podczas sprawdzania statusu zdrowia: ${error}`);
    return false;
  }
}

// Funkcja asynchroniczna używająca wielu operacji asynchronicznych
async function przygotujRaportDinozaura(id: string): Promise<{
  id: string;
  dane: string;
  statusZdrowia: boolean;
  czasGenerowania: string;
}> {
  console.log(`Przygotowywanie raportu dla dinozaura ${id}...`);

  // Równoległe wykonanie dwóch operacji asynchronicznych
  const [dane, statusZdrowia] = await Promise.all([
    pobierzDaneDinozauraZAPI(id),
    sprawdźStatusZdrowia(id)
  ]);

  // Przygotowanie raportu
  return {
    id,
    dane,
    statusZdrowia,
    czasGenerowania: new Date().toISOString()
  };
}

// Użycie funkcji asynchronicznych
async function przykładUżyciaAsync() {
  try {
    const raport = await przygotujRaportDinozaura("TREX-001");
    console.log("Raport gotowy:");
    console.log(JSON.stringify(raport, null, 2));

    // Próba pobrania nieistniejącego dinozaura
    const nieistniejący = await pobierzDaneDinozauraZAPI("INDOMINUS-001")
      .catch(error => {
        console.error(`Wystąpił błąd: ${error.message}`);
        return "Nieznany dinozaur";
      });

    console.log(`Wynik dla nieistniejącego: ${nieistniejący}`);
  } catch (error) {
    console.error(`Wystąpił błąd: ${error}`);
  }
}

// Wywołanie funkcji
przykładUżyciaAsync();

W powyższym przykładzie zdefiniowaliśmy kilka funkcji asynchronicznych zwracających różne typy obietnic (Promise<string>, Promise<boolean> i Promise<object>). TypeScript zapewnia pełne wsparcie typów dla tych funkcji i pozwala na bezpieczne łączenie operacji asynchronicznych.

Podsumowanie

Typowanie parametrów i zwracanych wartości funkcji to jeden z fundamentalnych elementów TypeScript, który pomaga w tworzeniu bezpiecznego, przewidywalnego i łatwego w utrzymaniu kodu. W kontekście naszego Parku Jurajskiego, dobre typowanie funkcji jest jak solidne protokoły bezpieczeństwa - pomagają zapobiec potencjalnym katastrofom, zanim się wydarzą.

TechnikaZastosowanie w Parku Jurajskim
Podstawowe typowanie funkcjiFunkcje obliczające wymagania pokarmowe dinozaurów
Parametry opcjonalne i domyślnePlanowanie badań dinozaurów z różnymi priorytetami
Funkcje voidRejestrowanie zmian w systemach bezpieczeństwa
Union types w zwracanych wartościachPobieranie danych dinozaurów w różnych formatach
Typy funkcjiDefiniowanie funkcji alarmowych dla procedur bezpieczeństwa
CallbackiMonitorowanie zdrowia dinozaurów
Funkcje generyczneFiltrowanie i przetwarzanie różnych typów danych
Przeciążanie funkcjiGenerowanie różnych typów identyfikatorów
Funkcje asynchronicznePobieranie danych z API i generowanie raportów

Dr. Wu podsumowuje: "W Parku Jurajskim każda procedura musi być precyzyjnie zdefiniowana i wykonana, aby zapewnić bezpieczeństwo zarówno gościom, jak i naszym cennym okazom. Podobnie w TypeScript, prawidłowe typowanie funkcji zapewnia, że każda operacja odbędzie się dokładnie tak, jak zaplanowano - bez niespodzianek. A jak wszyscy wiemy, w świecie dinozaurów niespodzianki rzadko bywają przyjemne."

Kod do tej lekcji: index.ts
// Typy parametrów i zwracanych wartości w Parku Jurajskim
console.log("Typy w funkcjach TypeScript\n");

// ===========================================
// 1. Podstawowe typy parametrów
// ===========================================
console.log("=== PODSTAWOWE TYPY PARAMETRÓW ===");

function feedDinosaur(name: string, amount: number): void {
  console.log(`Feeding ${name} with ${amount}kg of food`);
}

feedDinosaur("Rexy", 400);
feedDinosaur("Blue", 50);

// ===========================================
// 2. Typy zwracanych wartości
// ===========================================
console.log("\n=== TYPY ZWRACANYCH WARTOŚCI ===");

// Zwraca string
function getDinosaurName(id: number): string {
  return `Dinosaur-${id}`;
}

// Zwraca number
function calculateWeight(baseWeight: number, factor: number): number {
  return baseWeight * factor;
}

// Zwraca boolean
function isDangerous(species: string): boolean {
  const dangerousSpecies = ["Tyrannosaurus", "Velociraptor", "Spinosaurus"];
  return dangerousSpecies.some(s => species.includes(s));
}

// Zwraca void (nic nie zwraca)
function logStatus(message: string): void {
  console.log(`[LOG] ${message}`);
}

console.log("Name:", getDinosaurName(1));
console.log("Weight:", calculateWeight(1000, 1.5));
console.log("Dangerous:", isDangerous("Tyrannosaurus Rex"));
logStatus("System operational");

// ===========================================
// 3. Opcjonalne parametry
// ===========================================
console.log("\n=== OPCJONALNE PARAMETRY ===");

function createDinosaur(
  name: string,
  species: string,
  age?: number, // opcjonalne
  weight?: number // opcjonalne
): string {
  let desc = `${name} (${species})`;
  if (age !== undefined) desc += `, ${age} years old`;
  if (weight !== undefined) desc += `, ${weight}kg`;
  return desc;
}

console.log(createDinosaur("Rexy", "T-Rex"));
console.log(createDinosaur("Blue", "Velociraptor", 3));
console.log(createDinosaur("Delta", "Velociraptor", 3, 350));

// ===========================================
// 4. Domyślne wartości parametrów
// ===========================================
console.log("\n=== DOMYŚLNE WARTOŚCI ===");

function calculateFeedAmount(
  weight: number,
  dietType: "carnivore" | "herbivore" = "herbivore",
  multiplier: number = 1.0
): number {
  const basePercentage = dietType === "carnivore" ? 0.05 : 0.10;
  return weight * basePercentage * multiplier;
}

console.log("Carnivore 8000kg:", calculateFeedAmount(8000, "carnivore"));
console.log("Herbivore 5000kg:", calculateFeedAmount(5000)); // domyślnie herbivore
console.log("Herbivore 5000kg x2:", calculateFeedAmount(5000, "herbivore", 2));

// ===========================================
// 5. Rest parameters
// ===========================================
console.log("\n=== REST PARAMETERS ===");

function createHerd(species: string, ...names: string[]): string[] {
  return names.map(name => `${name} (${species})`);
}

const triceratopsHerd = createHerd(
  "Triceratops",
  "Tri",
  "Trike",
  "Sarah",
  "Cera"
);

console.log("Herd:", triceratopsHerd);

function sumWeights(...weights: number[]): number {
  return weights.reduce((sum, w) => sum + w, 0);
}

console.log("Total weight:", sumWeights(8000, 350, 300, 5000));

// ===========================================
// 6. Typy obiektowe jako parametry
// ===========================================
console.log("\n=== TYPY OBIEKTOWE ===");

interface Dinosaur {
  name: string;
  species: string;
  age: number;
  weight: number;
  diet: "carnivore" | "herbivore" | "omnivore";
}

function displayDinosaur(dino: Dinosaur): string {
  return `${dino.name} - ${dino.species} (${dino.age}y, ${dino.weight}kg, ${dino.diet})`;
}

const trex: Dinosaur = {
  name: "Rexy",
  species: "Tyrannosaurus Rex",
  age: 5,
  weight: 8000,
  diet: "carnivore"
};

console.log(displayDinosaur(trex));

// Destrukturyzacja w parametrach
function getDinosaurInfo({ name, species, age }: Dinosaur): string {
  return `${name} is a ${age}-year-old ${species}`;
}

console.log(getDinosaurInfo(trex));

// ===========================================
// 7. Union types w parametrach
// ===========================================
console.log("\n=== UNION TYPES ===");

type ID = string | number;

function findDinosaur(id: ID): string {
  return typeof id === "string"
    ? `Finding by string ID: ${id}`
    : `Finding by numeric ID: ${id}`;
}

console.log(findDinosaur("DINO-001"));
console.log(findDinosaur(42));

// ===========================================
// 8. Funkcje zwracające obiekty
// ===========================================
console.log("\n=== ZWRACANIE OBIEKTÓW ===");

function createDinosaurRecord(
  name: string,
  species: string
): { id: string; name: string; species: string; createdAt: Date } {
  return {
    id: `DINO-${Date.now()}`,
    name,
    species,
    createdAt: new Date()
  };
}

const newDino = createDinosaurRecord("Delta", "Velociraptor");
console.log("New record:", newDino);

// ===========================================
// 9. Funkcje zwracające funkcje
// ===========================================
console.log("\n=== HIGHER-ORDER FUNCTIONS ===");

function createMultiplier(factor: number): (value: number) => number {
  return (value: number) => value * factor;
}

const double = createMultiplier(2);
const triple = createMultiplier(3);

console.log("Double 100:", double(100));
console.log("Triple 100:", triple(100));

// ===========================================
// 10. Type inference
// ===========================================
console.log("\n=== TYPE INFERENCE ===");

// TypeScript wywnioskuje typy
function inferredTypes(a: number, b: string) {
  const sum = a + a; // number
  const text = b + b; // string
  return { sum, text }; // { sum: number; text: string }
}

const result = inferredTypes(5, "hello");
console.log("Inferred result:", result);

// ===========================================
// 11. Never type
// ===========================================
console.log("\n=== NEVER TYPE ===");

// Funkcja nigdy nie zwraca (zawsze rzuca wyjątek)
function throwError(message: string): never {
  throw new Error(message);
}

// Funkcja nigdy się nie kończy (nieskończona pętla)
function infiniteLoop(): never {
  while (true) {
    // nieskończona pętla
  }
}

console.log("Never type defined (but not called)");

// ===========================================
// 12. Overload signatures (zapowiedź)
// ===========================================
console.log("\n=== FUNCTION OVERLOADS - ZAPOWIEDŹ ===");

// Definicje przeciążeń
function processData(data: string): string;
function processData(data: number): number;
function processData(data: boolean): boolean;

// Implementacja
function processData(data: string | number | boolean): string | number | boolean {
  if (typeof data === "string") {
    return data.toUpperCase();
  } else if (typeof data === "number") {
    return data * 2;
  } else {
    return !data;
  }
}

console.log("Process string:", processData("hello"));
console.log("Process number:", processData(42));
console.log("Process boolean:", processData(true));

// ===========================================
// 13. Podsumowanie
// ===========================================
console.log("\n=== PODSUMOWANIE ===");
console.log("Typy parametrów - określanie typów wejściowych");
console.log("Typy zwracanych wartości - co funkcja zwraca");
console.log("Opcjonalne parametry - parametry z ?");
console.log("Domyślne wartości - wartości domyślne");
console.log("Rest parameters - ...args");
console.log("Destrukturyzacja - { prop } w parametrach");
console.log("Union types - string | number");
console.log("Never - funkcje nigdy nie zwracające");

console.log("\nTypy 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. Jaka jest różnica między x?: string a x: string | undefined w parametrze funkcji?

  2. 2. Co oznacza typ zwracany void w TypeScript?

Zadania praktyczne w grze

  • Edytor kodu

    Zaimplementuj typowaną createDinosaur factory function z interfejsami dla różnych gatunków.

  • Układanie w poziomie

    Ułóż elementy funkcji TypeScript z typami parametrów i wartości zwracanej:

  1. PytanieRóżnica między x?: string a x: string | undefined
  2. PytanieTyp zwracany void
  3. Zadanie z kodemPraktyka: Factory z typami
  4. Ułóż w kolejnościSkładnia funkcji z typami

Przydatne artykuły