Kurs JavaScript i TypeScript · Moduł 6: Podstawy TypeScript

Definicja interfejsów

11 min czytania ·
W tej lekcji11

Witaj z powrotem w Parku Jurajskim! Dziś, pod czujnym okiem Dr. Henry Wu, będziemy zgłębiać fundamentalną koncepcję TypeScript, która jest równie kluczowa dla organizacji kodu, jak protokoły bezpieczeństwa są dla prawidłowego funkcjonowania parku - interfejsy.

Czym są interfejsy w TypeScript?

Interfejsy w TypeScript definiują kontrakty w kodzie oraz opisują strukturę obiektów. Są one jak szczegółowe protokoły, które określają, co powinno zawierać dany obiekt. W kontekście Parku Jurajskiego, interfejsy można porównać do standardów bezpieczeństwa i protokołów obsługi dla różnych gatunków dinozaurów - każdy gatunek ma swoje specyficzne wymagania i cechy.

Podstawowa składnia interfejsu

Interfejs definiujemy za pomocą słowa kluczowego interface:

interface Dinozaur {
  id: number;
  nazwa: string;
  gatunek: string;
  wiek: number;
  waga: number;
}

// Tworzymy obiekt, który musi spełniać wymagania interfejsu
const rex: Dinozaur = {
  id: 1,
  nazwa: "Rex",
  gatunek: "Tyrannosaurus",
  wiek: 7,
  waga: 8000
};

// Poniższy kod spowodowałby błąd, ponieważ brakuje wymaganych właściwości
// const raptor: Dinozaur = {
//   id: 2,
//   nazwa: "Blue"
// };

Właściwości opcjonalne

Niektóre właściwości w interfejsie mogą być opcjonalne, oznaczane przez dodanie znaku zapytania (?). To jak oznaczenie opcjonalnych procedur obsługi dla poszczególnych dinozaurów.

interface OkazDinozaura {
  id: number;
  nazwa: string;
  gatunek: string;
  tagRFID?: string;        // Opcjonalny tag RFID
  ostatnieBadanie?: Date;  // Opcjonalna data ostatniego badania
  notatki?: string;        // Opcjonalne notatki badawcze
}

// Obiekt spełniający interfejs, ale bez wszystkich opcjonalnych właściwości
const okaz1: OkazDinozaura = {
  id: 101,
  nazwa: "Specimen A",
  gatunek: "Velociraptor"
};

// Obiekt z niektórymi opcjonalnymi właściwościami
const okaz2: OkazDinozaura = {
  id: 102,
  nazwa: "Specimen B",
  gatunek: "Dilophosaurus",
  tagRFID: "DILO-102",
  notatki: "Wykazuje agresywne zachowania w obecności nowych obiektów"
};

Tylko do odczytu (readonly)

Niektóre właściwości powinny być modyfikowane tylko przy tworzeniu obiektu. W TypeScript możemy to osiągnąć używając modyfikatora readonly. To jak procedury bezpieczeństwa, które raz ustalone, nie mogą być zmieniane podczas normalnej operacji.

interface KodGenetyczny {
  readonly id: string;
  readonly sekwencja: string;
  readonly gatunekDawca: string;
  modyfikacje: string[];
  dataIzolacji: Date;
}

// Tworzymy kod genetyczny
const kodTRex: KodGenetyczny = {
  id: "GEN-TREX-001",
  sekwencja: "ACGTTGCAAGCTA...",
  gatunekDawca: "Żaba zachodnioafrykańska",
  modyfikacje: ["Uzupełnienie luk DNA", "Korekta genów agresji"],
  dataIzolacji: new Date("2022-05-15")
};

// Możemy dodawać nowe modyfikacje
kodTRex.modyfikacje.push("Wzmocnienie odporności immunologicznej");

// Ale nie możemy zmienić wartości pól readonly
// kodTRex.id = "GEN-TREX-002"; // Błąd: Cannot assign to 'id' because it is a read-only property
// kodTRex.sekwencja = "GCTA..."; // Błąd: Cannot assign to 'sekwencja' because it is a read-only property

Interfejsy funkcji

Interfejsy mogą również definiować typy funkcji, co jest przydatne przy opisywaniu funkcji zwrotnych lub przekazywanych jako parametry. W kontekście parku, to jak definiowanie standardowych procedur obsługi różnych sytuacji.

// Interfejs funkcji bezpieczeństwa
interface SprawdzenieBezpieczeństwa {
  (poziomZagrożenia: number, strefaParku: string): boolean;
}

// Implementacja funkcji zgodnej z interfejsem
const sprawdźDostęp: SprawdzenieBezpieczeństwa = function(poziom, strefa) {
  // Logika sprawdzania dostępu
  if (strefa === "Wybieg T-Rex" && poziom < 5) {
    return false; // Odmowa dostępu do strefy T-Rex dla pracowników poniżej poziomu 5
  }

  if (strefa.includes("Laboratorium") && poziom < 4) {
    return false; // Odmowa dostępu do laboratoriów dla pracowników poniżej poziomu 4
  }

  return true; // Dostęp dozwolony dla pozostałych przypadków
};

// Użycie funkcji
console.log(sprawdźDostęp(3, "Wybieg T-Rex")); // false
console.log(sprawdźDostęp(5, "Wybieg T-Rex")); // true
console.log(sprawdźDostęp(3, "Obszar publiczny")); // true

Indeksowalne typy

Interfejsy mogą definiować typy indeksowalne - użyteczne, gdy mamy obiekty z dynamiczną liczbą właściwości tego samego typu. W kontekście parku, może to być baza danych dinozaurów indeksowana po ich identyfikatorach.

// Interfejs dla bazy danych dinozaurów
interface BazaDanychDinozaurów {
  [id: string]: {
    nazwa: string;
    gatunek: string;
    wiek: number;
    zdrowie: "dobre" | "wymaga uwagi" | "krytyczne";
  };
}

// Tworzenie bazy danych
const bazaDanych: BazaDanychDinozaurów = {
  "TREX-001": {
    nazwa: "Rex",
    gatunek: "Tyrannosaurus",
    wiek: 7,
    zdrowie: "dobre"
  },
  "VELOC-001": {
    nazwa: "Blue",
    gatunek: "Velociraptor",
    wiek: 4,
    zdrowie: "dobre"
  },
  "TRIC-003": {
    nazwa: "Trike",
    gatunek: "Triceratops",
    wiek: 10,
    zdrowie: "wymaga uwagi"
  }
};

// Dostęp do danych
console.log(bazaDanych["VELOC-001"].nazwa); // "Blue"

// Dodawanie nowego wpisu
bazaDanych["STEGO-002"] = {
  nazwa: "Spike",
  gatunek: "Stegosaurus",
  wiek: 6,
  zdrowie: "dobre"
};

Interfejsy klas

Interfejsy mogą również definiować kontrakty, które klasy muszą implementować. To jak standardy operacyjne, które każdy departament w parku musi spełniać.

// Interfejs dla systemów bezpieczeństwa
interface SystemBezpieczeństwa {
  nazwa: string;
  czyAktywny: boolean;
  poziomBezpieczeństwa: number;

  aktywuj(): void;
  dezaktywuj(): void;
  sprawdźStan(): string;
}

// Klasa implementująca interfejs
class SystemElektronicznychOgrodzeń implements SystemBezpieczeństwa {
  nazwa: string;
  czyAktywny: boolean;
  poziomBezpieczeństwa: number;
  napięcie: number; // Dodatkowa właściwość specyficzna dla tej klasy

  constructor(nazwa: string, poziomBezpieczeństwa: number, napięcie: number) {
    this.nazwa = nazwa;
    this.czyAktywny = false; // Początkowo nieaktywny
    this.poziomBezpieczeństwa = poziomBezpieczeństwa;
    this.napięcie = napięcie;
  }

  aktywuj(): void {
    this.czyAktywny = true;
    console.log(`System ${this.nazwa} został aktywowany. Napięcie: ${this.napięcie}V`);
  }

  dezaktywuj(): void {
    this.czyAktywny = false;
    console.log(`System ${this.nazwa} został dezaktywowany.`);
  }

  sprawdźStan(): string {
    return this.czyAktywny
      ? `${this.nazwa}: AKTYWNY (Poziom ${this.poziomBezpieczeństwa})`
      : `${this.nazwa}: NIEAKTYWNY`;
  }

  // Metoda specyficzna dla tej klasy
  zwiększNapięcie(o: number): void {
    this.napięcie += o;
    console.log(`Zwiększono napięcie do ${this.napięcie}V`);
  }
}

// Użycie klasy
const ogrodzenieTRex = new SystemElektronicznychOgrodzeń("Ogrodzenie T-Rex", 5, 10000);
ogrodzenieTRex.aktywuj();
console.log(ogrodzenieTRex.sprawdźStan());
ogrodzenieTRex.zwiększNapięcie(2000);

Rozszerzanie interfejsów

Interfejsy mogą rozszerzać inne interfejsy, podobnie jak w biologii, gdzie gatunki dzielą wspólne cechy, ale mają też swoje unikalne właściwości.

// Podstawowy interfejs dla wszystkich zwierząt w parku
interface Zwierzę {
  id: number;
  gatunek: string;
  wiek: number;
  waga: number;
}

// Interfejs dla dinozaurów rozszerzający interfejs Zwierzę
interface Dinozaur extends Zwierzę {
  era: string; // np. "Kreda", "Jura"
  jestDrapieżnikiem: boolean;
  dietaGłówna: string[];
}

// Interfejs dla dinozaurów drapieżnych rozszerzający interfejs Dinozaur
interface DrapieżnyDinozaur extends Dinozaur {
  siłaUgryzienia: number;  // w PSI
  prędkośćBiegu: number;   // w km/h
  zachowaniePodczasPolowania: string[];
}

// Tworzenie obiektu zgodnego z interfejsem DrapieżnyDinozaur
const velociraptor: DrapieżnyDinozaur = {
  id: 101,
  gatunek: "Velociraptor",
  wiek: 4,
  waga: 70,
  era: "Kreda",
  jestDrapieżnikiem: true,
  dietaGłówna: ["małe ssaki", "jaszczurki", "inne małe dinozaury"],
  siłaUgryzienia: 1000,
  prędkośćBiegu: 60,
  zachowaniePodczasPolowania: ["polowanie w stadzie", "zasadzka", "pościg"]
};

Łączenie deklaracji interfejsów

W TypeScript możliwe jest definiowanie tego samego interfejsu wielokrotnie - deklaracje zostaną połączone. To przydatne, gdy chcemy dodać nowe właściwości do istniejącego interfejsu.

// Początkowa definicja protokołu bezpieczeństwa
interface ProtokółBezpieczeństwa {
  nazwa: string;
  poziomZagrożenia: number;
  proceduraEwakuacji: string;
}

// Rozszerzenie protokołu o dodatkowe właściwości
interface ProtokółBezpieczeństwa {
  personelOdpowiedzialny: string[];
  czasReakcji: number; // w minutach
}

// Obiekt musi zawierać wszystkie właściwości z obu deklaracji
const protokółAlfa: ProtokółBezpieczeństwa = {
  nazwa: "Protokół Alfa",
  poziomZagrożenia: 3,
  proceduraEwakuacji: "Ewakuacja w kierunku głównego centrum kontroli",
  personelOdpowiedzialny: ["Dr. Wu", "Owen Grady", "Claire Dearing"],
  czasReakcji: 15
};

Interfejsy vs typy

TypeScript oferuje również słowo kluczowe type do definiowania typów. Choć często interfejsy i typy mogą być używane zamiennie, istnieją między nimi różnice:

// Definicja za pomocą interface
interface PlanEwakuacji {
  trasa: string[];
  czasSzacunkowy: number;
  punktyZbiórek: string[];
}

// Równoważna definicja za pomocą type
type PlanEwakuacjiType = {
  trasa: string[];
  czasSzacunkowy: number;
  punktyZbiórek: string[];
};

// Oba działają podobnie przy podstawowym użyciu
const planA: PlanEwakuacji = {
  trasa: ["Centrum operacyjne", "Main Street", "Hala ewakuacyjna"],
  czasSzacunkowy: 25,
  punktyZbiórek: ["Centrum operacyjne", "Hala ewakuacyjna"]
};

const planB: PlanEwakuacjiType = {
  trasa: ["Wybieg Gallimimus", "Innovation Center", "Hala ewakuacyjna"],
  czasSzacunkowy: 30,
  punktyZbiórek: ["Innovation Center", "Hala ewakuacyjna"]
};

Główne różnice między interface a type:

  1. Rozszerzalność:

    • Interfejsy można rozszerzać przez wielokrotne deklaracje o tej samej nazwie
    • Typy nie mogą być "otwarte" - raz zadeklarowany typ nie może być rozszerzony
  2. Złożone typy:

    • Typy mogą reprezentować bezpośrednio typy proste, unie, przecięcia
    • Interfejsy są bardziej ukierunkowane na definiowanie kształtu obiektów
// Możliwe tylko z typami
type IDDinozaura = string | number;
type KoordynatyWybiegu = [number, number, string]; // Tuple
type StatusDinozaura = "aktywny" | "odpoczywający" | "śpiący"; // Union of literals

// Bardziej naturalne z interfejsami
interface Procedura {
  nazwa: string;
  kroki: string[];
  czasWykonania: number;
  personelOdpowiedzialny: string[];
}

Praktyczne zastosowanie interfejsów

Przyjrzyjmy się, jak możemy wykorzystać interfejsy do modelowania systemu zarządzania Parkiem Jurajskim:

// Podstawowe interfejsy
interface OsobaWParku {
  id: string;
  imię: string;
  nazwisko: string;
  poziomDostępu: 1 | 2 | 3 | 4 | 5;
  dataZatrudnienia: Date;
}

interface Lokalizacja {
  id: string;
  nazwa: string;
  typ: "wybieg" | "laboratorium" | "centrum operacyjne" | "strefa publiczna";
  współrzędne: [number, number]; // [szerokość, długość]
  wymaganyPoziomDostępu: 1 | 2 | 3 | 4 | 5;
}

interface GatunekDinozaura {
  nazwa: string;
  eraGeologiczna: string;
  typ: "roślinożerca" | "drapieżnik" | "wszystkożerca";
  przeciętnaWaga: number;
  przeciętnyWiek: number;
  poziomNiebezpieczeństwa: 1 | 2 | 3 | 4 | 5;
  wymaganiaDiety: string[];
  wymaganiaHabitatu: string[];
}

interface OkazDinozaura {
  id: string;
  gatunek: string;
  imię?: string;
  wiek: number;
  waga: number;
  płeć: "samiec" | "samica";
  lokalizacja: string; // ID lokalizacji
  stanZdrowia: "doskonały" | "dobry" | "wymaga uwagi" | "chory" | "krytyczny";
  ostatnieBadanie: Date;
  tagRFID: string;
  notatki?: string;
}

// Interfejsy dla systemów zarządzania
interface SystemŚledzeniaOkazów {
  pobierzPozycję(idOkazu: string): [number, number];
  śledźRuch(idOkazu: string, czasŚledzenia: number): [number, number][];
  sprawdźCzyWStrefie(idOkazu: string, idStrefy: string): boolean;
  alertGdyPozaStrefą(idOkazu: string, callback: (okaz: OkazDinozaura) => void): void;
}

interface SystemZarządzaniaPracownikami {
  dodajPracownika(pracownik: OsobaWParku): void;
  usuńPracownika(id: string): boolean;
  przyznajDostęp(idPracownika: string, poziom: 1 | 2 | 3 | 4 | 5): boolean;
  sprawdźObecnośćWStrefie(idPracownika: string, idStrefy: string): boolean;
}

// Przykład implementacji
class SystemZarządzaniaParkiem {
  private pracownicy: OsobaWParku[] = [];
  private lokalizacje: Lokalizacja[] = [];
  private gatunki: GatunekDinozaura[] = [];
  private okazy: OkazDinozaura[] = [];

  // Metody dla pracowników
  dodajPracownika(pracownik: OsobaWParku): void {
    this.pracownicy.push(pracownik);
    console.log(`Dodano pracownika: ${pracownik.imię} ${pracownik.nazwisko}`);
  }

  // Metody dla lokalizacji
  dodajLokalizację(lokalizacja: Lokalizacja): void {
    this.lokalizacje.push(lokalizacja);
    console.log(`Dodano lokalizację: ${lokalizacja.nazwa}`);
  }

  // Metody dla gatunków
  dodajGatunek(gatunek: GatunekDinozaura): void {
    this.gatunki.push(gatunek);
    console.log(`Dodano gatunek: ${gatunek.nazwa}`);
  }

  // Metody dla okazów
  dodajOkaz(okaz: OkazDinozaura): void {
    this.okazy.push(okaz);
    console.log(`Dodano okaz: ${okaz.id} (${okaz.gatunek})`);
  }

  // Metody zarządzania
  sprawdźDostęp(idPracownika: string, idLokalizacji: string): boolean {
    const pracownik = this.pracownicy.find(p => p.id === idPracownika);
    const lokalizacja = this.lokalizacje.find(l => l.id === idLokalizacji);

    if (!pracownik || !lokalizacja) return false;

    return pracownik.poziomDostępu >= lokalizacja.wymaganyPoziomDostępu;
  }

  znajdźOkazyGatunku(nazwaGatunku: string): OkazDinozaura[] {
    return this.okazy.filter(o => o.gatunek === nazwaGatunku);
  }

  znajdźOkazyWStrefie(idStrefy: string): OkazDinozaura[] {
    return this.okazy.filter(o => o.lokalizacja === idStrefy);
  }

  generujRaportStanuParku(): {
    liczbaPracowników: number;
    liczbaLokalizacji: number;
    liczbaGatunków: number;
    liczbaOkazów: number;
    stanZdrowiaOkazów: {
      doskonały: number;
      dobry: number;
      wymagaUwagi: number;
      chory: number;
      krytyczny: number;
    }
  } {
    // Analiza stanu zdrowia wszystkich okazów
    const stanZdrowia = {
      doskonały: 0,
      dobry: 0,
      wymagaUwagi: 0,
      chory: 0,
      krytyczny: 0
    };

    this.okazy.forEach(okaz => {
      if (okaz.stanZdrowia === "doskonały") stanZdrowia.doskonały++;
      else if (okaz.stanZdrowia === "dobry") stanZdrowia.dobry++;
      else if (okaz.stanZdrowia === "wymaga uwagi") stanZdrowia.wymagaUwagi++;
      else if (okaz.stanZdrowia === "chory") stanZdrowia.chory++;
      else if (okaz.stanZdrowia === "krytyczny") stanZdrowia.krytyczny++;
    });

    return {
      liczbaPracowników: this.pracownicy.length,
      liczbaLokalizacji: this.lokalizacje.length,
      liczbaGatunków: this.gatunki.length,
      liczbaOkazów: this.okazy.length,
      stanZdrowiaOkazów: stanZdrowia
    };
  }
}

// Przykład użycia
const parkJurajski = new SystemZarządzaniaParkiem();

// Dodanie lokalizacji
parkJurajski.dodajLokalizację({
  id: "LOC-001",
  nazwa: "Wybieg T-Rex",
  typ: "wybieg",
  współrzędne: [23.45, -67.89],
  wymaganyPoziomDostępu: 4
});

// Dodanie gatunku
parkJurajski.dodajGatunek({
  nazwa: "Tyrannosaurus Rex",
  eraGeologiczna: "Kreda",
  typ: "drapieżnik",
  przeciętnaWaga: 7000,
  przeciętnyWiek: 30,
  poziomNiebezpieczeństwa: 5,
  wymaganiaDiety: ["duże ilości mięsa", "uzupełnianie wapnia"],
  wymaganiaHabitatu: ["duży obszar", "naturalna roślinność", "dostęp do wody"]
});

// Dodanie pracownika
parkJurajski.dodajPracownika({
  id: "EMP-001",
  imię: "Owen",
  nazwisko: "Grady",
  poziomDostępu: 5,
  dataZatrudnienia: new Date("2010-06-15")
});

// Dodanie okazu
parkJurajski.dodajOkaz({
  id: "DINO-001",
  gatunek: "Tyrannosaurus Rex",
  imię: "Rexy",
  wiek: 7,
  waga: 7500,
  płeć: "samica",
  lokalizacja: "LOC-001",
  stanZdrowia: "dobry",
  ostatnieBadanie: new Date("2023-03-20"),
  tagRFID: "RFID-TREX-001"
});

// Generowanie raportu
const raport = parkJurajski.generujRaportStanuParku();
console.log("Raport stanu Parku Jurajskiego:");
console.log(`Liczba pracowników: ${raport.liczbaPracowników}`);
console.log(`Liczba lokalizacji: ${raport.liczbaLokalizacji}`);
console.log(`Liczba gatunków: ${raport.liczbaGatunków}`);
console.log(`Liczba okazów: ${raport.liczbaOkazów}`);
console.log("Stan zdrowia okazów:", raport.stanZdrowiaOkazów);

Podsumowanie

Interfejsy w TypeScript są potężnym narzędziem do modelowania struktur danych i definiowania kontraktów w kodzie. W kontekście zarządzania Parkiem Jurajskim, pozwalają nam precyzyjnie określić, jak powinny wyglądać różne systemy, procedury i elementy parku.

Cecha interfejsuZastosowanie w Parku Jurajskim
Podstawowa definicjaStruktury danych dla dinozaurów, pracowników, lokalizacji
Właściwości opcjonalneDodatkowe informacje, które mogą, ale nie muszą być dostępne
Właściwości readonlyDane, które nie powinny być zmieniane, np. ID genetyczne
Interfejsy funkcjiDefinicje procedur bezpieczeństwa i protokołów
Typy indeksowalneDynamiczne bazy danych dinozaurów i zasobów
Interfejsy klasStandardy dla systemów bezpieczeństwa i monitoringu
Rozszerzanie interfejsówDziedziczenie cech między gatunkami dinozaurów
Łączenie deklaracjiRozszerzanie protokołów o dodatkowe procedury

Dr. Wu podsumowuje: "Interfejsy w TypeScript, podobnie jak nasze protokoły w parku, zapewniają, że każdy element systemu działa zgodnie z oczekiwaniami. Dzięki nim możemy budować złożone systemy z pewnością, że poszczególne komponenty będą ze sobą współpracować - co jest absolutnie kluczowe, gdy mamy do czynienia z gatunkami, które mogą być niebezpieczne, jeśli coś pójdzie nie tak."

Kod do tej lekcji: index.ts
// Interfejsy w Parku Jurajskim
console.log("Interfejsy TypeScript\n");

// ===========================================
// 1. Podstawowe interfejsy
// ===========================================
console.log("=== PODSTAWOWE INTERFEJSY ===");

// Prosty interfejs
interface Dinosaur {
  name: string;
  species: string;
  age: number;
  weight: number;
}

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

console.log("T-Rex:", trex);

// ===========================================
// 2. Opcjonalne właściwości
// ===========================================
console.log("\n=== OPCJONALNE WŁAŚCIWOŚCI ===");

interface DinosaurWithOptionals {
  name: string;
  species: string;
  age: number;
  nickname?: string; // opcjonalne
  medicalNotes?: string; // opcjonalne
}

const blue: DinosaurWithOptionals = {
  name: "Blue",
  species: "Velociraptor",
  age: 3,
  nickname: "The Beta"
  // medicalNotes pominięte - OK
};

console.log("Blue:", blue);
console.log("Has medical notes:", blue.medicalNotes !== undefined);

// ===========================================
// 3. Readonly properties
// ===========================================
console.log("\n=== READONLY PROPERTIES ===");

interface DinosaurWithReadonly {
  readonly id: string; // nie można zmieniać
  readonly dnaSequence: string; // nie można zmieniać
  name: string; // można zmieniać
  age: number; // można zmieniać
}

const dino: DinosaurWithReadonly = {
  id: "DINO-001",
  dnaSequence: "ACGT...",
  name: "Rex",
  age: 5
};

// dino.id = "DINO-002"; // Error: Cannot assign to 'id'
dino.name = "Rexy"; // OK
dino.age = 6; // OK

console.log("Dinosaur:", dino);

// ===========================================
// 4. Metody w interfejsach
// ===========================================
console.log("\n=== METODY W INTERFEJSACH ===");

interface DinosaurWithMethods {
  name: string;
  species: string;
  energy: number;

  // Metody
  roar(): string;
  eat(amount: number): void;
  sleep(hours: number): void;
  getStatus(): string;
}

class TyrannosaurusRex implements DinosaurWithMethods {
  name: string;
  species: string;
  energy: number;

  constructor(name: string) {
    this.name = name;
    this.species = "Tyrannosaurus Rex";
    this.energy = 100;
  }

  roar(): string {
    this.energy -= 5;
    return `${this.name} roars: ROAAAAAR!`;
  }

  eat(amount: number): void {
    this.energy += amount * 2;
    if (this.energy > 100) this.energy = 100;
    console.log(`${this.name} ate ${amount}kg. Energy: ${this.energy}`);
  }

  sleep(hours: number): void {
    this.energy += hours * 10;
    if (this.energy > 100) this.energy = 100;
    console.log(`${this.name} slept ${hours}h. Energy: ${this.energy}`);
  }

  getStatus(): string {
    if (this.energy > 70) return "Energetic";
    if (this.energy > 30) return "Normal";
    return "Tired";
  }
}

const rexy = new TyrannosaurusRex("Rexy");
console.log(rexy.roar());
rexy.eat(50);
console.log("Status:", rexy.getStatus());

// ===========================================
// 5. Index signatures
// ===========================================
console.log("\n=== INDEX SIGNATURES ===");

// Dynamiczne klucze
interface DinosaurCollection {
  [id: string]: Dinosaur;
}

const collection: DinosaurCollection = {
  "T-001": trex,
  "V-001": blue
};

console.log("Collection:", collection);
console.log("T-001:", collection["T-001"]);

// Mieszane właściwości
interface PaddockData {
  id: string;
  capacity: number;
  [key: string]: any; // inne dynamiczne właściwości
}

const paddock: PaddockData = {
  id: "P-01",
  capacity: 10,
  securityLevel: "high",
  temperature: 25,
  humidity: 60
};

console.log("Paddock:", paddock);

// ===========================================
// 6. Funkcje w interfejsach
// ===========================================
console.log("\n=== FUNKCJE W INTERFEJSACH ===");

// Typ funkcji
interface DinosaurFilter {
  (dino: Dinosaur): boolean;
}

const carnivoreFilter: DinosaurFilter = (dino) => {
  return dino.species.includes("saurus") && dino.weight > 1000;
};

console.log("Is T-Rex carnivore:", carnivoreFilter(trex));

// Interface dla funkcji z właściwościami
interface DinosaurValidator {
  (dino: Dinosaur): boolean;
  errorMessage: string;
}

const ageValidator: DinosaurValidator = (dino) => {
  return dino.age >= 0 && dino.age <= 100;
};
ageValidator.errorMessage = "Age must be between 0 and 100";

console.log("Validator:", ageValidator(trex));
console.log("Error message:", ageValidator.errorMessage);

// ===========================================
// 7. Zagnieżdżone interfejsy
// ===========================================
console.log("\n=== ZAGNIEŻDŻONE INTERFEJSY ===");

interface Location {
  latitude: number;
  longitude: number;
  altitude: number;
}

interface Paddock {
  id: string;
  name: string;
  location: Location; // zagnieżdżony interfejs
  dimensions: {
    width: number;
    length: number;
    height: number;
  };
  dinosaurs: Dinosaur[];
}

const trexPaddock: Paddock = {
  id: "P-01",
  name: "T-Rex Territory",
  location: {
    latitude: 22.3964,
    longitude: -159.5261,
    altitude: 50
  },
  dimensions: {
    width: 1000,
    length: 1500,
    height: 50
  },
  dinosaurs: [trex]
};

console.log("Paddock:", trexPaddock);
console.log("Location:", trexPaddock.location);

// ===========================================
// 8. Hybrid types
// ===========================================
console.log("\n=== HYBRID TYPES ===");

interface Counter {
  (start: number): string;
  interval: number;
  reset(): void;
}

function createCounter(): Counter {
  let count = 0;

  const counter = function(start: number) {
    count = start;
    return `Count: ${count}`;
  } as Counter;

  counter.interval = 1;
  counter.reset = function() {
    count = 0;
  };

  return counter;
}

const myCounter = createCounter();
console.log(myCounter(5));
console.log("Interval:", myCounter.interval);
myCounter.reset();

// ===========================================
// 9. Podsumowanie
// ===========================================
console.log("\n=== PODSUMOWANIE ===");
console.log("Podstawowe interfejsy - struktura obiektów");
console.log("Opcjonalne właściwości - ?");
console.log("Readonly - niezmienne właściwości");
console.log("Metody - funkcje w interfejsach");
console.log("Index signatures - dynamiczne klucze");
console.log("Zagnieżdżone interfejsy - złożone struktury");

console.log("\nInterfejsy 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 interfejs różni się od type alias w TypeScript?

  2. 2. Jak oznaczyć właściwość interfejsu jako opcjonalną w TypeScript?

Zadania praktyczne w grze

  • Edytor kodu

    Zdefiniuj interfejs Dinosaur z polami name: string, species: string, weight?: number i metodą roar(): void.

  • Układanie w poziomie

    Ułóż elementy definicji interfejsu TypeScript:

  • Klikanie w kolejności

    Ułóż elementy definicji pola readonly w interfejsie:

  • Układanie w pionie

    Uporządkuj koncepty interfejsów od najprostszych do najbardziej zaawansowanych:

  1. PytanieInterfejsy TypeScript
  2. PytanieOpcjonalne właściwości interfejsu
  3. Zadanie z kodemPraktyka: Tworzenie interfejsu
  4. Ułóż w kolejnościSkładnia interfejsu
  5. Kliknij w kolejnościSortowanie: Pole readonly w interfejsie
  6. Ułóż w kolejnościMożliwości interfejsów TypeScript

Przydatne artykuły