Kurs JavaScript i TypeScript · Moduł 6: Podstawy TypeScript
Typy złożone (array, tuple, enum)
W tej lekcji7
Witaj ponownie w Parku Jurajskim! Po zapoznaniu się z podstawowymi typami danych w TypeScript, jesteśmy gotowi, aby przejść do bardziej zaawansowanych struktur. W dzisiejszej lekcji Dr. Wu zabierze nas do laboratorium, gdzie będziemy eksperymentować z bardziej złożonymi typami danych.
Tak jak w Parku Jurajskim nie wystarczy znać pojedynczych gatunków - trzeba rozumieć, jak funkcjonują całe ekosystemy i hierarchie dinozaurów - tak w TypeScript nie wystarczy znać tylko typy podstawowe. Musimy nauczyć się organizować dane w bardziej złożone struktury.
Typy tablicowe (Array)
Tablice w TypeScript są jak wybiegi w Parku Jurajskim - służą do przechowywania kolekcji podobnych elementów. Możemy zdefiniować typ tablicy na dwa sposoby:
// Definiowanie tablicy dinozaurów
let dinozaury: string[] = ["Tyrannosaurus", "Velociraptor", "Triceratops"];
// Alternatywna notacja
let dinozauryAlt: Array<string> = ["Brachiosaurus", "Stegosaurus", "Ankylosaurus"];
// Tablica liczb - np. wagi dinozaurów w kilogramach
let wagi: number[] = [7500, 350, 8500, 35000, 5500];
// Dostęp do elementów tablicy
console.log(`Pierwszy dinozaur: ${dinozaury[0]}`); // Tyrannosaurus
console.log(`Liczba dinozaurów: ${dinozaury.length}`); // 3
// Dodawanie do tablicy
dinozaury.push("Spinosaurus");
console.log(`Teraz mamy ${dinozaury.length} dinozaurów`); // 4
// Iteracja po tablicy
dinozaury.forEach(dino => {
console.log(`Badanie zachowania: ${dino}`);
});Tablice mogą również przechowywać bardziej złożone obiekty:
// Definiowanie interfejsu dla obiektu dinozaura
interface Dinozaur {
id: number;
nazwa: string;
gatunek: string;
jestDrapieżnikiem: boolean;
wiekMlnLat: number;
}
// Tablica obiektów dinozaurów
const kolekcjaOkazów: Dinozaur[] = [
{ id: 1, nazwa: "Rex", gatunek: "Tyrannosaurus", jestDrapieżnikiem: true, wiekMlnLat: 68 },
{ id: 2, nazwa: "Blue", gatunek: "Velociraptor", jestDrapieżnikiem: true, wiekMlnLat: 75 },
{ id: 3, nazwa: "Trixie", gatunek: "Triceratops", jestDrapieżnikiem: false, wiekMlnLat: 68 }
];
// Filtrowanie tablicy - znajdź wszystkie drapieżniki
const drapieżniki = kolekcjaOkazów.filter(dino => dino.jestDrapieżnikiem);
console.log(`Liczba drapieżników: ${drapieżniki.length}`); // 2
// Przekształcanie tablicy - pozyskaj tylko nazwy dinozaurów
const nazwyDinozaurów = kolekcjaOkazów.map(dino => dino.nazwa);
console.log(`Nazwy okazów: ${nazwyDinozaurów.join(", ")}`); // "Rex, Blue, Trixie"Tablice wielowymiarowe
Tablice wielowymiarowe można wykorzystać do reprezentowania bardziej złożonych danych, takich jak mapa wybiegów w Parku Jurajskim:
// Dwuwymiarowa tablica reprezentująca mapę Parku Jurajskiego
// 0 = teren niedostępny, 1 = ścieżka, 2 = wybieg roślinożerców, 3 = wybieg drapieżników
const mapaParkuJurajskiego: number[][] = [
[0, 0, 2, 2, 2, 0, 0],
[0, 1, 1, 1, 1, 1, 0],
[0, 1, 3, 3, 3, 1, 0],
[0, 1, 1, 1, 1, 1, 0],
[0, 0, 2, 2, 2, 0, 0]
];
// Sprawdzanie, co znajduje się na danej pozycji
function sprawdźTeren(x: number, y: number): string {
const teren = mapaParkuJurajskiego[y][x];
switch (teren) {
case 0: return "Teren niedostępny";
case 1: return "Ścieżka dla zwiedzających";
case 2: return "Wybieg dinozaurów roślinożernych";
case 3: return "UWAGA! Wybieg drapieżników!";
default: return "Nieznany teren";
}
}
console.log(sprawdźTeren(2, 2)); // "UWAGA! Wybieg drapieżników!"Tablice o różnych typach elementów - Tuple (krotki)
Krotki (Tuple) to specjalny rodzaj tablicy, w której znamy dokładną liczbę elementów i ich typy. To jak transport dinozaurów - musi być ściśle określony typ pojazdu i specjalne zabezpieczenia odpowiednie dla konkretnego gatunku.
// Krotka reprezentująca dane pracownika: [id, imię, stanowisko, poziom dostępu]
type PracownikParku = [number, string, string, number];
const pracownicy: PracownikParku[] = [
[1, "John Hammond", "Dyrektor", 5],
[2, "Dr. Alan Grant", "Paleontolog", 4],
[3, "Dr. Ellie Sattler", "Paleobotanik", 4],
[4, "Dennis Nedry", "Programista", 3]
];
// Krotka z różnymi typami elementów
// Format: [kod DNA, gatunek, wiek w latach, czy jest drapieżnikiem]
type KodGenetyczny = [string, string, number, boolean];
const kodTRex: KodGenetyczny = ["ACGTTCAGC", "Tyrannosaurus Rex", 68, true];
// Destrukturyzacja krotki
const [dnaKod, gatunek, wiek, drapieżnik] = kodTRex;
console.log(`DNA: ${dnaKod}, Gatunek: ${gatunek}`);
// Opcjonalne elementy krotki (od TypeScript 3.0)
// Format: [id, nazwa, opcjonalny tag RFID]
type OkazMuzealny = [number, string, string?];
const okazDinozaura: OkazMuzealny = [42, "Czaszka Velociraptora"];
const okazZTagiem: OkazMuzealny = [43, "Jajo dinozaura", "RFID-J-43"];Typy wyliczeniowe (Enum)
Typy wyliczeniowe (Enum) w TypeScript są jak kategorie bezpieczeństwa w Parku Jurajskim - pomagają definiować zbiór nazwanych stałych, z których można korzystać w kodzie.
// Definiowanie typu wyliczeniowego dla kategorii zagrożeń
enum KategoriaZagrożenia {
Niskie, // 0
Umiarkowane, // 1
Wysokie, // 2
Krytyczne, // 3
PoziomCzerwony // 4
}
// Użycie enum
let zagrożenieWybieguTRex: KategoriaZagrożenia = KategoriaZagrożenia.Wysokie;
if (zagrożenieWybieguTRex >= KategoriaZagrożenia.Wysokie) {
console.log("Zalecane podwójne ogrodzenie elektryczne!");
}
// Dostęp po wartości
const kategoriaOpis = (poziom: KategoriaZagrożenia): string => {
switch (poziom) {
case KategoriaZagrożenia.Niskie: return "Standardowe środki ostrożności";
case KategoriaZagrożenia.Umiarkowane: return "Zwiększona czujność";
case KategoriaZagrożenia.Wysokie: return "Podwójne zabezpieczenia";
case KategoriaZagrożenia.Krytyczne: return "Zakaz wstępu dla zwiedzających";
case KategoriaZagrożenia.PoziomCzerwony: return "Ewakuacja parku!";
default: return "Nieznany poziom zagrożenia";
}
};
console.log(kategoriaOpis(zagrożenieWybieguTRex)); // "Podwójne zabezpieczenia"
// Enum z określonymi wartościami
enum StatusDinozaura {
Nieaktywny = 0,
OgraniczonaAktywność = 5,
Aktywny = 10,
BardzoAktywny = 15,
NiezbędnaInterwencja = 20
}
let statusRexT: StatusDinozaura = StatusDinozaura.BardzoAktywny;
console.log(`Poziom aktywności T-Rex: ${statusRexT}`); // 15
// Enum tekstowy
enum GatunekDinozaura {
TRex = "Tyrannosaurus Rex",
Raptor = "Velociraptor",
Tric = "Triceratops",
Stego = "Stegosaurus",
Brach = "Brachiosaurus"
}
let ulubieniecPubliczności: GatunekDinozaura = GatunekDinozaura.TRex;
console.log(`Dzisiejsza atrakcja: ${ulubieniecPubliczności}`); // "Tyrannosaurus Rex"Const Enum
Const Enum to optymalizacja TypeScript, która eliminuje obiekt enum w czasie kompilacji, zastępując odwołania do enum bezpośrednio wartościami.
// Zdefiniowanie Const Enum
const enum StrefaBezpieczeństwa {
Publiczna = 1,
Pracownicy = 2,
OgraniczonyDostęp = 3,
Laboratoria = 4,
Zagrożenie = 5
}
// Wykorzystanie Const Enum
function sprawdźUprawnienia(poziomDostępu: number, wymaganaStrefa: StrefaBezpieczeństwa): boolean {
return poziomDostępu >= wymaganaStrefa;
}
// Wywołanie z wartościami enum
const dostępDrWu = sprawdźUprawnienia(5, StrefaBezpieczeństwa.Laboratoria); // true
const dostępPracownika = sprawdźUprawnienia(2, StrefaBezpieczeństwa.Zagrożenie); // falsePraktyczne zastosowanie typów złożonych
Przyjrzyjmy się, jak możemy wykorzystać te typy złożone do zbudowania systemu zarządzania Parkiem Jurajskim:
// Definiowanie interfejsów i typów
enum StatusZdrowia {
Doskonały = "doskonały",
Dobry = "dobry",
Wymagauwagi = "wymaga uwagi",
Chory = "chory",
Krytyczny = "krytyczny"
}
enum KlasyfikacjaDiety {
Roślinożerca = "roślinożerca",
Wszystkożerca = "wszystkożerca",
Drapieżnik = "drapieżnik"
}
interface DaneWitalne {
temperatura: number;
tętno: number;
ciśnienieKrwi: [number, number]; // Krotka [skurczowe, rozkurczowe]
poziomStresu: number; // 1-10
}
interface Dinozaur {
id: number;
nazwa: string;
gatunek: string;
klasyfikacjaDiety: KlasyfikacjaDiety;
wiek: number;
waga: number;
status: StatusZdrowia;
daneWitalne: DaneWitalne;
aktywnośćDziennaArray: number[]; // Poziom aktywności w okresach 3-godzinnych (8 wartości dla pełnej doby)
}
// Tworzenie systemu zarządzania dinozaurami
class SystemZarządzaniaDinozaurami {
private dinozaury: Dinozaur[] = [];
dodajDinozaura(dino: Dinozaur): void {
this.dinozaury.push(dino);
console.log(`Dodano dinozaura: ${dino.nazwa} (${dino.gatunek})`);
}
znajdźDinozaura(id: number): Dinozaur | undefined {
return this.dinozaury.find(d => d.id === id);
}
aktualizujStatusZdrowia(id: number, nowyStatus: StatusZdrowia): boolean {
const dino = this.znajdźDinozaura(id);
if (dino) {
dino.status = nowyStatus;
console.log(`Zaktualizowano status zdrowia ${dino.nazwa} na: ${nowyStatus}`);
return true;
}
return false;
}
pobierzDrapieżniki(): Dinozaur[] {
return this.dinozaury.filter(d => d.klasyfikacjaDiety === KlasyfikacjaDiety.Drapieżnik);
}
pobierzDinozauryWymagająceUwagi(): Dinozaur[] {
return this.dinozaury.filter(d =>
d.status === StatusZdrowia.Wymagauwagi ||
d.status === StatusZdrowia.Chory ||
d.status === StatusZdrowia.Krytyczny
);
}
obliczŚrednięAktywności(id: number): number | null {
const dino = this.znajdźDinozaura(id);
if (dino) {
const suma = dino.aktywnośćDziennaArray.reduce((acc, val) => acc + val, 0);
return suma / dino.aktywnośćDziennaArray.length;
}
return null;
}
przygotujRaportDzienny(): [string, number, StatusZdrowia][] {
// Zwraca krotkę [nazwa, id, status] dla każdego dinozaura
return this.dinozaury.map(d => [d.nazwa, d.id, d.status]);
}
}
// Przykładowe użycie
const systemJP = new SystemZarządzaniaDinozaurami();
// Dodanie dinozaurów do systemu
systemJP.dodajDinozaura({
id: 1,
nazwa: "Rexy",
gatunek: "Tyrannosaurus Rex",
klasyfikacjaDiety: KlasyfikacjaDiety.Drapieżnik,
wiek: 7,
waga: 8000,
status: StatusZdrowia.Dobry,
daneWitalne: {
temperatura: 38.2,
tętno: 70,
ciśnienieKrwi: [140, 90],
poziomStresu: 3
},
aktywnośćDziennaArray: [2, 1, 0, 0, 1, 3, 5, 2]
});
systemJP.dodajDinozaura({
id: 2,
nazwa: "Blue",
gatunek: "Velociraptor",
klasyfikacjaDiety: KlasyfikacjaDiety.Drapieżnik,
wiek: 3,
waga: 350,
status: StatusZdrowia.Doskonały,
daneWitalne: {
temperatura: 39.1,
tętno: 95,
ciśnienieKrwi: [130, 85],
poziomStresu: 2
},
aktywnośćDziennaArray: [4, 2, 1, 0, 2, 5, 6, 3]
});
systemJP.dodajDinozaura({
id: 3,
nazwa: "Spike",
gatunek: "Stegosaurus",
klasyfikacjaDiety: KlasyfikacjaDiety.Roślinożerca,
wiek: 12,
waga: 5000,
status: StatusZdrowia.Wymagauwagi,
daneWitalne: {
temperatura: 37.5,
tętno: 50,
ciśnienieKrwi: [125, 80],
poziomStresu: 6
},
aktywnośćDziennaArray: [3, 3, 2, 1, 3, 2, 2, 1]
});
// Korzystanie z systemu
const drapieżniki = systemJP.pobierzDrapieżniki();
console.log(`Liczba drapieżników w parku: ${drapieżniki.length}`);
const wymagającyUwagi = systemJP.pobierzDinozauryWymagająceUwagi();
console.log(`Liczba dinozaurów wymagających uwagi: ${wymagającyUwagi.length}`);
// Przykład raportu dziennego (tablica krotek)
const raportDzienny = systemJP.przygotujRaportDzienny();
console.log("\nDzienny raport stanu dinozaurów:");
raportDzienny.forEach(([nazwa, id, status]) => {
console.log(`- ${nazwa} (ID: ${id}): ${status}`);
});
// Przykład aktualizacji statusu
systemJP.aktualizujStatusZdrowia(1, StatusZdrowia.Wymagauwagi);Podsumowanie typów złożonych
| Typ | Zastosowanie w Parku Jurajskim | Przykład |
|---|---|---|
| Array | Kolekcje podobnych elementów, np. lista dinozaurów | string[], Dinozaur[] |
| Multidimensional Array | Reprezentacja przestrzenna, np. mapa parku | number[][] |
| Tuple | Stałe struktury z określonymi typami i rozmiarami, np. dane genetyczne | [string, string, number, boolean] |
| Enum | Zdefiniowane kategorie, np. poziomy zagrożenia | enum KategoriaZagrożenia {...} |
| Const Enum | Zoptymalizowane enumy dla wydajności | const enum StrefaBezpieczeństwa {...} |
Pamiętaj, że dobór odpowiednich typów danych w projekcie jest jak projektowanie bezpiecznych i efektywnych wybiegów w Parku Jurajskim - dobre projektowanie na początku zaoszczędzi wielu problemów w przyszłości!
Dr. Wu zawsze powtarza: "Precyzyjna kontrola typów to podstawa sukcesu - zarówno w laboratorium genetycznym, jak i w kodzie TypeScript."
Kod do tej lekcji: index.ts
// Typy złożone w Parku Jurajskim
console.log("Typy złożone TypeScript\n");
// ===========================================
// 1. ARRAY - tablice
// ===========================================
console.log("=== TABLICE (ARRAY) ===");
// Dwa sposoby definiowania tablic
let dinosaurs: string[] = ["Tyrannosaurus", "Velociraptor", "Triceratops"];
let weights: Array<number> = [7500, 350, 8500, 35000];
console.log("Dinosaurs:", dinosaurs);
console.log("First dinosaur:", dinosaurs[0]);
console.log("Count:", dinosaurs.length);
// Operacje na tablicach
dinosaurs.push("Spinosaurus");
console.log("After push:", dinosaurs);
// Iteracja
dinosaurs.forEach((dino, index) => {
console.log(`${index + 1}. ${dino}`);
});
// Tablica obiektów
interface Dinosaur {
id: number;
name: string;
species: string;
isCarnivore: boolean;
ageMillionYears: number;
}
const collection: Dinosaur[] = [
{ id: 1, name: "Rex", species: "Tyrannosaurus", isCarnivore: true, ageMillionYears: 68 },
{ id: 2, name: "Blue", species: "Velociraptor", isCarnivore: true, ageMillionYears: 75 },
{ id: 3, name: "Trike", species: "Triceratops", isCarnivore: false, ageMillionYears: 68 }
];
console.log("\nDinosaur collection:", collection);
// Filtrowanie
const carnivores = collection.filter(d => d.isCarnivore);
console.log("Carnivores:", carnivores.map(d => d.name));
// ===========================================
// 2. TUPLE - krotki
// ===========================================
console.log("\n=== TUPLE - KROTKI ===");
// Tuple - tablica o stałej długości i typach
let dinoData: [string, number, boolean] = ["T-Rex", 8000, true];
console.log("Species:", dinoData[0]);
console.log("Weight:", dinoData[1]);
console.log("Is dangerous:", dinoData[2]);
// Tuple z nazwanymi elementami (TS 4.0+)
type DinoTuple = [species: string, weight: number, dangerous: boolean];
let velociraptor: DinoTuple = ["Velociraptor", 350, true];
console.log("Velociraptor data:", velociraptor);
// Tuple z opcjonalnymi elementami
type PaddockData = [id: string, capacity: number, isLocked?: boolean];
let paddock1: PaddockData = ["P-01", 5, true];
let paddock2: PaddockData = ["P-02", 10]; // isLocked opcjonalne
console.log("Paddock 1:", paddock1);
console.log("Paddock 2:", paddock2);
// ===========================================
// 3. ENUM - wyliczenia
// ===========================================
console.log("\n=== ENUM - WYLICZENIA ===");
// Enum numeryczny
enum SecurityLevel {
Green = 1,
Yellow = 2,
Orange = 3,
Red = 4,
Critical = 5
}
let currentSecurity: SecurityLevel = SecurityLevel.Orange;
console.log("Security level:", SecurityLevel[currentSecurity]); // "Orange"
console.log("Security value:", currentSecurity); // 3
// Enum tekstowy
enum DinosaurDiet {
Carnivore = "CARNIVORE",
Herbivore = "HERBIVORE",
Omnivore = "OMNIVORE"
}
let trexDiet: DinosaurDiet = DinosaurDiet.Carnivore;
console.log("T-Rex diet:", trexDiet); // "CARNIVORE"
// Enum z obliczeniami
enum PaddockSize {
Small = 100,
Medium = 500,
Large = 1000,
ExtraLarge = Large * 2 // 2000
}
console.log("Extra large paddock:", PaddockSize.ExtraLarge);
// Const enum (optymalizacja)
const enum DinosaurPeriod {
Triassic = "TRIASSIC",
Jurassic = "JURASSIC",
Cretaceous = "CRETACEOUS"
}
let trexPeriod: DinosaurPeriod = DinosaurPeriod.Cretaceous;
console.log("T-Rex period:", trexPeriod);
// ===========================================
// 4. Funkcje pomocnicze dla typów złożonych
// ===========================================
console.log("\n=== OPERACJE NA TYPACH ZŁOŻONYCH ===");
// Funkcja dla tablic
function getTotalWeight(dinosaurs: Dinosaur[]): number {
return weights.reduce((sum, w) => sum + w, 0);
}
console.log("Total weight:", getTotalWeight(collection));
// Funkcja dla tuple
function createDinoTuple(species: string, weight: number, dangerous: boolean): DinoTuple {
return [species, weight, dangerous];
}
const newDino = createDinoTuple("Stegosaurus", 5000, false);
console.log("New dinosaur:", newDino);
// Funkcja dla enum
function getSecurityColor(level: SecurityLevel): string {
switch (level) {
case SecurityLevel.Green:
return "Green";
case SecurityLevel.Yellow:
return "Yellow";
case SecurityLevel.Orange:
return "Orange";
case SecurityLevel.Red:
return "Red";
case SecurityLevel.Critical:
return "Critical";
default:
return "Unknown";
}
}
console.log("Current security:", getSecurityColor(currentSecurity));
// ===========================================
// 5. Zagnieżdżone struktury
// ===========================================
console.log("\n=== ZAGNIEŻDŻONE STRUKTURY ===");
interface Paddock {
id: string;
size: PaddockSize;
security: SecurityLevel;
dinosaurs: Dinosaur[];
coordinates: [latitude: number, longitude: number];
}
const trexPaddock: Paddock = {
id: "P-01",
size: PaddockSize.Large,
security: SecurityLevel.Critical,
dinosaurs: [collection[0]],
coordinates: [22.3964, -159.5261]
};
console.log("T-Rex Paddock:", trexPaddock);
console.log("Coordinates:", trexPaddock.coordinates);
console.log("Dinosaurs in paddock:", trexPaddock.dinosaurs.length);
// ===========================================
// 6. Podsumowanie
// ===========================================
console.log("\n=== PODSUMOWANIE ===");
console.log("Array - kolekcje elementów tego samego typu");
console.log("Tuple - tablice o stałej długości i różnych typach");
console.log("Enum - nazwane stałe wartości");
console.log("Zagnieżdżanie - łączenie złożonych struktur");
console.log("\nTypy złożone opanowane!");Hasła z dokumentacji w tej lekcji
Widzisz błąd w tej lekcji?
Sprawdź się
Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.
1. Czym jest tuple w TypeScript?
Zadania praktyczne w grze
- Edytor kodu
Zdefiniuj tablicę gatunków (string[]) i krotkę [string, number] dla nazwy i wagi dinozaura.
- Układanie w pionie
Uporządkuj typy TypeScript od najbardziej ogólnego do najbardziej szczegółowego:
- Układanie w poziomie
Ułóż elementy deklaracji tuple w TypeScript: