Aliasy typów i interfejsy

Witamy na kolejnej lekcji! W tej lekcji dowie się Pan/Pani o aliasach typów i interfejsach w TypeScript, w tym o ich różnicach, podobieństwach oraz o tym, kiedy używać każdego z nich. Zaczynajmy!

Czym są aliasy typów?

Alias typu pozwala zdefiniować własną nazwę dla typu. Może reprezentować typy prymitywne, obiekty, a nawet sygnatury funkcji.

Przykład:

Zadanie: Utwórz alias typu dla obiektu reprezentującego książkę i użyj go do zdefiniowania zmiennej.

type Point = {
  x: number;
  y: number;
};

let point: Point = { x: 10, y: 20 };
console.log(point); 
// Output: { x: 10, y: 20 }

Czym są interfejsy?

Interfejs definiuje strukturę obiektu, w tym jego właściwości i metody. Często używa się go do wymuszania spójności i bezpieczeństwa typów obiektów.

Przykład:

Zadanie: Utwórz interfejs dla profilu użytkownika i użyj go do zdefiniowania zmiennej.

interface Point {
  x: number;
  y: number;
}

let point: Point = { x: 5, y: 15 };
console.log(point); 
// Output: { x: 5, y: 15 }

Aliasy typów a interfejsy: podobieństwa

Aliasy typów i interfejsy mają pewne wspólne cechy:

• Oba mogą opisywać strukturę obiektu.
• Oba mogą służyć do definiowania typów funkcji.
• Oba obsługują rozszerzanie innych typów.

Przykład: typ funkcji:

Zadanie: Zdefiniuj alias typu i interfejs dla funkcji, a następnie ich użyj.

type Add = (a: number, b: number) => number;
interface Subtract {
  (a: number, b: number): number;
}

let add: Add = (x, y) => x + y;
let subtract: Subtract = (x, y) => x - y;

console.log(add(5, 3)); 
// Output: 8
console.log(subtract(5, 3)); 
// Output: 2

Aliasy typów a interfejsy: różnice

Oto najważniejsze różnice:

• Interfejsy: Mogą być scalane (scalanie deklaracji).
• Aliasy typów: Nie można ich scalać.
• Aliasy typów: Mogą definiować typy unii i przecięć.
• Interfejsy: Są przeznaczone przede wszystkim do opisywania struktur obiektów.

Przykład: typy unii z aliasami typów:

Zadanie: Użyj aliasu typu do zdefiniowania typu unii i przypisz różne wartości do zmiennej.

type StringOrNumber = string | number;

let value: StringOrNumber = "Hello";
value = 42;
// value = true; 
// Error: Type 'true' is not assignable to type 'StringOrNumber'.

Rozszerzanie typów i interfejsów

Zarówno aliasy typów, jak i interfejsy mogą rozszerzać inne typy:

• Interfejsy: Używają słowa kluczowego extends.
• Aliasy typów: Używają przecięć (&).

Przykład:

Zadanie: Rozszerz alias typu i interfejs, aby utworzyć nowe typy.

interface Animal {
  name: string;
}

interface Dog extends Animal {
  breed: string;
}

type Bird = Animal & { canFly: boolean };

let myDog: Dog = { name: "Buddy", breed: "Golden Retriever" };
let myBird: Bird = { name: "Parrot", canFly: true };

console.log(myDog, myBird);

Scalanie deklaracji

Interfejsy obsługują scalanie deklaracji, w ramach którego wiele deklaracji interfejsu o tej samej nazwie jest łączonych w jeden interfejs. Aliasy typów nie obsługują tej funkcji.

Przykład:

Zadanie: Utwórz dwie deklaracje interfejsu o tej samej nazwie i przetestuj scalanie deklaracji.

interface Person {
  name: string;
}

interface Person {
  age: number;
}

let person: Person = { name: "Alice", age: 30 };
console.log(person); 
// Output: { name: "Alice", age: 30 }

Kiedy używać poszczególnych rozwiązań

Oto kilka wskazówek:

• Używaj interfejsów do definiowania struktur obiektów oraz wtedy, gdy potrzebne jest scalanie deklaracji.
• Używaj aliasów typów dla unii, przecięć lub podczas definiowania typów funkcji.

Wskazówka: Wybierz rozwiązanie, które najlepiej pasuje do danego przypadku użycia, aby zachować przejrzystość i spójność!

Świetna robota!

Gratulacje! Nauczył(a) się Pan/Pani o podobieństwach i różnicach między aliasami typów a interfejsami w TypeScript, a także o tym, kiedy używać każdego z nich. W następnej lekcji pozna Pan/Pani zaawansowane funkcje TypeScript, takie jak typy warunkowe. Kontynuujmy programowanie!