Kurs JavaScript i TypeScript · Moduł 6: Podstawy TypeScript

Typy złożone (array, tuple, enum)

8 min czytania ·
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); // false

Praktyczne 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

TypZastosowanie w Parku JurajskimPrzykład
ArrayKolekcje podobnych elementów, np. lista dinozaurówstring[], Dinozaur[]
Multidimensional ArrayReprezentacja przestrzenna, np. mapa parkunumber[][]
TupleStałe struktury z określonymi typami i rozmiarami, np. dane genetyczne[string, string, number, boolean]
EnumZdefiniowane kategorie, np. poziomy zagrożeniaenum KategoriaZagrożenia {...}
Const EnumZoptymalizowane enumy dla wydajnościconst 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. 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:

  1. PytanieTypy tuple
  2. Zadanie z kodemPraktyka: Array i Tuple w TypeScript
  3. Ułóż w kolejnościHierarchia typów TypeScript
  4. Ułóż w kolejnościSkładnia tuple

Przydatne artykuły