Kurs JavaScript i TypeScript · Moduł 6: Podstawy TypeScript
Definicja interfejsów
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 propertyInterfejsy 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")); // trueIndeksowalne 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:
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
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 interfejsu | Zastosowanie w Parku Jurajskim |
|---|---|
| Podstawowa definicja | Struktury danych dla dinozaurów, pracowników, lokalizacji |
| Właściwości opcjonalne | Dodatkowe informacje, które mogą, ale nie muszą być dostępne |
| Właściwości readonly | Dane, które nie powinny być zmieniane, np. ID genetyczne |
| Interfejsy funkcji | Definicje procedur bezpieczeństwa i protokołów |
| Typy indeksowalne | Dynamiczne bazy danych dinozaurów i zasobów |
| Interfejsy klas | Standardy dla systemów bezpieczeństwa i monitoringu |
| Rozszerzanie interfejsów | Dziedziczenie cech między gatunkami dinozaurów |
| Łączenie deklaracji | Rozszerzanie 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. Czym interfejs różni się od type alias w TypeScript?
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: