W TypeScript, oprócz prostych typów takich jak string, number czy boolean, możemy również definiować bardziej złożone struktury danych, które umożliwiają przechowywanie wielu wartości jednocześnie. Do najczęściej używanych typów złożonych należą tablice, krotki oraz obiekty.

Tablice w TypeScript pozwalają na przechowywanie wielu wartości tego samego typu w jednej zmiennej. Aby określić typ tablicy, możemy użyć dwóch składni:

• Dodanie nawiasów kwadratowych [] po nazwie typu.
• Użycie ogólnej formy Array<typ>.

Przykład:

let numbers: number[] = [1, 2, 3, 4]; 
let fruits: Array = ["jabłko", "banan", "gruszka"];

• push(): dodaje element na końcu tablicy,
• pop(): usuwa element z końca tablicy,
• map(), filter(), reduce() i inne.

Przykład 2:

let mixedArray: (string | number)[] = [1, "banan", 3, "jabłko"];

Krotki to specjalny rodzaj tablicy, który pozwala określić liczbę elementów oraz ich typy na danym indeksie. Każdy element w krotce może mieć inny typ, co daje większą elastyczność w przechowywaniu heterogenicznych danych.

Przykład:

let person: [string, number]; 
person = ["Jan Kowalski", 30]; // Poprawne 
// person = [30, "Jan Kowalski"]; // Błąd, niewłaściwa kolejność typów

Krotki są szczególnie przydatne w sytuacjach, gdy wiemy z góry, ile i jakiego rodzaju wartości będzie przechowywać nasza struktura danych. Przykładem może być zwracanie wielu wartości z funkcji:

Przykład:

function getUserInfo(): [string, number] { 
    return ["Anna Nowak", 25]; 
} 
                    
let userInfo = getUserInfo(); 
console.log(`Użytkownik: ${userInfo[0]}, wiek: ${userInfo[1]}`);

Obiekty w TypeScript pozwalają na definiowanie bardziej złożonych struktur danych, które są zbiorem par klucz-wartość. Klucze w obiekcie są zazwyczaj ciągami znaków, a wartości mogą być dowolnymi typami.

Przykład:

let car: { brand: string; model: string; year: number } = { 
    brand: "Toyota", 
    model: "Corolla", 
    year: 2021, 
};

Obiekty mogą być także zagnieżdżone, co pozwala na tworzenie bardziej rozbudowanych struktur:

let employee: { 
    name: string; 
    position: string; 
    contact: { 
        email: string; 
        phone: string; 
    }; 
 = { 
    name: "Paweł", 
    position: "Developer", 
    contact: { 
        email: "pawel@example.com", 
        phone: "123-456-789", 
    }, 
};

TypeScript pozwala również na definiowanie własnych złożonych typów za pomocą słowa kluczowego type. Możemy zdefiniować typ, który będzie reprezentował bardziej rozbudowane struktury, takie jak połączenie różnych typów.

Przykład:

type Product = {
    name: string;
    price: number;
    inStock: boolean;
};

let product1: Product = {
    name: "Laptop",
    price: 2500,
    inStock: true,
};

Dzięki takim własnym typom możemy łatwo zorganizować struktury danych w naszym kodzie, co ułatwia pracę z bardziej złożonymi danymi.

Union types to sposób na zdefiniowanie zmiennej, która może mieć więcej niż jeden typ. Używamy symbolu |, aby połączyć różne typy.

Przykład:

let id: number | string; 
id = 123; 
id = "abc123";

Typy skrzyżowania pozwalają na połączenie kilku typów w jeden, dzięki czemu zmienna musi spełniać wymagania wszystkich typów naraz.

Przykład:

type Person = { name: string };
type Employee = { employeeId: number };

type Worker = Person & Employee;

let worker: Worker = {
    name: "Jan",
    employeeId: 1234,
};

Typy złożone w TypeScript, takie jak tablice, krotki i obiekty, pozwalają na tworzenie bardziej zaawansowanych struktur danych, które możemy precyzyjnie typować. Dzięki temu kod jest bardziej czytelny, mniej podatny na błędy oraz łatwiejszy do utrzymania. Dodatkowo, TypeScript daje nam narzędzia do tworzenia własnych typów złożonych, co jeszcze bardziej zwiększa elastyczność w modelowaniu danych.