Kurs JavaScript i TypeScript · Moduł 10: TypeScript w praktyce
Template literal types - manipulacja stringami w typach
W tej lekcji3
Wyobraź sobie system etykiet próbek DNA, w którym każda nazwa ma format dna-gatunek-numer. Zwykły string przepuści każdą literówkę, a ręczne wypisanie wszystkich wariantów zajęłoby tygodnie. Template literal types to funkcja TypeScript 4.1+, która pozwala tworzyć typy stringowe składnią template literals z JavaScript. Kompilator sprawdza wtedy format napisu, zanim kod trafi do laboratorium.
Podstawy template literal types
Składnia podstawowa
Zapis przypomina zwykły template literal, ale w miejscu wartości stoi typ: ${string} oznacza dowolny napis, a ${number} dowolną liczbę zapisaną tekstem:
// Podstawowe template literal types
type Greeting = `Hello ${string}`;
type Welcome = `Welcome to ${string}!`;
// Przykłady użycia
const greeting1: Greeting = "Hello World"; // OK
const greeting2: Greeting = "Hello TypeScript"; // OK
// const greeting3: Greeting = "Hi World"; // Błąd! Musi zaczynać się od "Hello "
// Łączenie literal types
type EventName = "click" | "focus" | "blur";
type EventHandler = `on${Capitalize<EventName>}`;
// type EventHandler = "onClick" | "onFocus" | "onBlur"
// Praktyczny przykład - CSS units
type CSSUnit = "px" | "%" | "em" | "rem" | "vh" | "vw";
type CSSValue = `${number}${CSSUnit}`;
const width: CSSValue = "100px"; // OK
const height: CSSValue = "50vh"; // OK
const margin: CSSValue = "2rem"; // OK
// const padding: CSSValue = "10"; // Błąd! Brakuje jednostki
// Zagnieżdżone template literals
type BreakpointSize = "sm" | "md" | "lg" | "xl";
type Breakpoint = `@${BreakpointSize}`;
type ResponsiveProp<T extends string> = T | `${T}${Breakpoint}`;
type Display = ResponsiveProp<"block" | "none" | "flex">;
// "block" | "none" | "flex" | "block@sm" | "none@sm" | "flex@sm" |Greeting akceptuje każdy napis zaczynający się od Hello , a nie dosłownie tekst ze znakiem dolara. Gdy wstawisz unię, TypeScript wygeneruje unię wszystkich kombinacji, więc EventHandler to trzy nazwy, a Display aż piętnaście wariantów.
Pattern matching z template literal types
Połączenie z typami warunkowymi i słowem infer pozwala rozbierać napisy na części, podobnie jak wyrażenie regularne, tylko w czasie kompilacji:
// Wyciąganie części stringów
type ExtractId<T> = T extends `id-${infer Id}` ? Id : never;
type UserId = ExtractId<"id-123">; // "123"
type PostId = ExtractId<"id-abc-def">; // "abc-def"
type Invalid = ExtractId<"user-123">; // never
// Bardziej złożone pattern matching
type ParseRoute<T> = T extends `/${infer Module}/${infer Action}`
? { module: Module; action: Action }
: never;
type Route1 = ParseRoute<"/users/create">; // { module: "users"; action: "create" }
type Route2 = ParseRoute<"/posts/edit">; // { module: "posts"; action: "edit" }
// Rekursywne parsowanie
type Split<S extends string, D extends string> =
S extends `${infer T}${D}${infer U}`
? [T, ...Split<U, D>]
: [S];
type PathSegments = Split<"users/123/posts/456", "/">;
// ["users", "123", "posts", "456"]
// Wyciąganie parametrów z URL
type ExtractParams<T extends string> = T extends `${infer Start}:${infer Param}/${infer Rest}`
? { [K in Param]: string } & ExtractParams<Rest>
: T extends `${infer Start}:${infer Param}`
? { [K in Param]: string }
: {};
type RouteParams = ExtractParams<"/users/:userId/posts/:postId">;
// { userId: string; postId: string }infer Id łapie resztę napisu po prefiksie id-, a Split wywołuje sam siebie, aż skończą się separatory. Rekurencja w typach ma jednak limit głębokości, więc bardzo długie napisy mogą przerosnąć kompilator.
Wbudowane string manipulation types
TypeScript ma cztery wbudowane typy do zmiany wielkości liter: Uppercase, Lowercase, Capitalize i Uncapitalize. Nie ma na przykład typu Reverse, taki musiałbyś napisać sam:
// TypeScript udostępnia wbudowane typy do manipulacji stringami
// Tak są zadeklarowane w lib.es5.d.ts (nie deklaruj ich ponownie, bo dostaniesz Duplicate identifier):
// type Uppercase<T extends string> = intrinsic;
// type Lowercase<T extends string> = intrinsic;
// type Capitalize<T extends string> = intrinsic;
// type Uncapitalize<T extends string> = intrinsic;
// Przykłady użycia
type Shout = Uppercase<"hello world">; // "HELLO WORLD"
type Whisper = Lowercase<"HELLO WORLD">; // "hello world"
type Title = Capitalize<"typescript">; // "Typescript"
type CamelCase = Uncapitalize<"TypeScript">; // "typeScript"
// Praktyczne zastosowanie - generowanie event handlers
type DOMEventName = "click" | "focus" | "blur" | "change" | "submit";
type EventHandlerName<T extends DOMEventName> = `on${Capitalize<T>}`;
type ClickHandler = EventHandlerName<"click">; // "onClick"
type FocusHandler = EventHandlerName<"focus">; // "onFocus"
// Automatyczne mapowanie event handlers
type EventHandlers = {
[E in DOMEventName as EventHandlerName<E>]: (event: Event) => void;
};
// {
// onClick: (event: Event) => void;
// onFocus: (event: Event) => void;
// onBlur: (event: Event) => void;
// onChange: (event: Event) => void;
// onSubmit: (event: Event) => void;
// }Słowo intrinsic oznacza, że implementację dostarcza kompilator, dlatego deklaracje są w komentarzu, a Ty tylko z nich korzystasz. Klauzula as w typie mapowanym zmienia nazwy kluczy, więc z listy zdarzeń powstaje obiekt z polami onClick, onFocus i kolejnymi.
Zaawansowane wzorce
Transformacje nazw właściwości
API często zwraca pola w stylu snake_case, a w kodzie wolisz camelCase. Typy mogą przeliczyć nazwy za Ciebie:
// Snake case to camel case
type SnakeToCamelCase<S extends string> = S extends `${infer T}_${infer U}`
? `${T}${Capitalize<SnakeToCamelCase<U>>}`
: S;
type CamelCased = SnakeToCamelCase<"hello_world_typescript">; // "helloWorldTypescript"
// Camel case to snake case
type CamelToSnakeCase<S extends string> = S extends `${infer C}${infer Rest}`
? C extends Lowercase<C>
? `${C}${CamelToSnakeCase<Rest>}`
: `_${Lowercase<C>}${CamelToSnakeCase<Rest>}`
: S;
type SnakeCased = CamelToSnakeCase<"helloWorldTypeScript">; // "hello_world_type_script"
// Praktyczne zastosowanie - konwersja API response
type SnakeToCamelCaseNested<T> = T extends object
? {
[K in keyof T as SnakeToCamelCase<K & string>]: SnakeToCamelCaseNested<T[K]>
}
: T;
interface APIResponse {
user_id: number;
first_name: string;
last_name: string;
created_at: string;
user_settings: {
email_notifications: boolean;
dark_mode: boolean;
};
}
type CamelCasedResponse = SnakeToCamelCaseNested<APIResponse>;
// {
// userId: number;
// firstName: string;
// lastName: string;
// createdAt: string;
// userSettings: {
// emailNotifications: boolean;
// darkMode: boolean;
// };
// }CamelToSnakeCase sprawdza znak po znaku i każdą wielką literę zamienia na podkreślnik z małą literą. To tylko typy: dane w runtime przekształcasz osobną funkcją, a typ jedynie opisuje wynik.
Walidacja i ograniczenia
Typy potrafią też sprawdzać format napisów. Tak wygląda walidacja adresu email, numeru telefonu i koloru szesnastkowego:
// Walidacja formatu email
type ValidateEmail<T extends string> = T extends `${infer Local}@${infer Domain}`
? Domain extends `${infer Name}.${infer Extension}`
? Extension extends "com" | "org" | "net" | "pl" | "edu"
? T
: never
: never
: never;
type ValidEmail = ValidateEmail<"user@example.com">; // "user@example.com"
type InvalidEmail = ValidateEmail<"invalid-email">; // never
// Walidacja numerów telefonów
type ValidatePhoneNumber<T extends string> =
T extends `+${infer CountryCode}-${infer Rest}`
? CountryCode extends `${number}`
? Rest extends `${number}-${number}-${number}`
? T
: never
: never
: never;
type ValidPhone = ValidatePhoneNumber<"+48-123-456-789">; // "+48-123-456-789"
type InvalidPhone = ValidatePhoneNumber<"123-456-789">; // never
// Walidacja hex color
type HexDigit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "A" | "B" | "C" | "D" | "E" | "F" | "a" | "b" | "c" | "d" | "e" | "f";
type HexColor<T extends string> = T extends `#${HexDigit}${HexDigit}${HexDigit}${infer Rest}`
? Rest extends `${HexDigit}${HexDigit}${HexDigit}`
? T
: Rest extends ""
? T
: never
: never;
type ValidHex1 = HexColor<"#FF5733">; // "#FF5733"
type ValidHex2 = HexColor<"#F53">; // "#F53"
type InvalidHex = HexColor<"#GG5733">; // neverNieprawidłowy napis daje never, więc funkcja przyjmująca taki typ go odrzuci. Działa to dla literałów znanych w czasie kompilacji, a tekst wpisany przez użytkownika nadal sprawdzasz w runtime.
Dynamiczne generowanie typów
Mapa tras opisana typem daje routerowi kontrolę nad parametrami, a unie tabel i kolumn generują poprawne zapytania SQL:
// System routingu z type safety
type RouteDefinition = {
"/": {};
"/users": {};
"/users/:id": { id: string };
"/users/:id/posts": { id: string };
"/posts/:postId/comments/:commentId": { postId: string; commentId: string };
};
type ExtractRouteParams<T extends string> =
T extends keyof RouteDefinition
? RouteDefinition[T]
: T extends `${infer Start}/:${infer Param}/${infer Rest}`
? { [K in Param]: string } & ExtractRouteParams<`${Start}/${Rest}`>
: T extends `${infer Start}/:${infer Param}`
? { [K in Param]: string }
: {};
// Router z type safety
class TypedRouter<Routes extends Record<string, any>> {
navigate<T extends keyof Routes & string>(
path: T,
params: Routes[T]
): void {
console.log(`Navigating to ${path} with params:`, params);
}
}
const router = new TypedRouter<RouteDefinition>();
router.navigate("/", {}); // OK
router.navigate("/users/:id", { id: "123" }); // OK
router.navigate("/posts/:postId/comments/:commentId", { // OK
postId: "456",
commentId: "789"
});
// router.navigate("/users/:id", {}); // Błąd! Brakuje id
// router.navigate("/users/:id", { id: "123", extra: "field" }); // Błąd! Dodatkowe pole
// Generowanie SQL queries
type Table = "users" | "posts" | "comments";
type Column<T extends Table> =
T extends "users" ? "id" | "name" | "email" | "created_at" :
T extends "posts" ? "id" | "title" | "content" | "author_id" :
T extends "comments" ? "id" | "text" | "post_id" | "user_id" :
never;
type SelectQuery<T extends Table> = `SELECT ${Column<T> | "*"} FROM ${T}`;
type WhereClause<T extends Table> = `WHERE ${Column<T>} = ?`;
type FullQuery<T extends Table> = `${SelectQuery<T>} ${WhereClause<T>}`;
type UserQuery = SelectQuery<"users">;
// "SELECT id FROM users" | "SELECT name FROM users" | ... | "SELECT * FROM users"
type PostQueryWithWhere = FullQuery<"posts">;
// "SELECT id FROM posts WHERE id = ?" | "SELECT title FROM posts WHERE title = ?" |navigate wymaga dokładnie takich parametrów, jakie opisuje trasa, więc brakujące albo nadmiarowe pole to błąd kompilacji. Uważaj na rozmiar unii: iloczyn kilku dużych unii rośnie lawinowo, a TypeScript odmawia pracy przy uniach liczących ponad 100 000 elementów.
Praktyczne zastosowania
CSS-in-JS z type safety
System design tokenów to klasyczne zastosowanie: nazwy powstają z połączenia koloru i odcienia, więc literówka nie przejdzie:
// System design tokens
type Color = "primary" | "secondary" | "success" | "danger" | "warning";
type Shade = 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900;
type ColorToken = `color-${Color}-${Shade}`;
type Spacing = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 8 | 10 | 12 | 16 | 20 | 24 | 32;
type SpacingToken = `spacing-${Spacing}`;
type DesignToken = ColorToken | SpacingToken;
// Funkcja pomocnicza z type safety
function token(tokenName: DesignToken): string {
return `var(--${tokenName})`;
}
const primaryColor = token("color-primary-500"); // OK
const spacing = token("spacing-4"); // OK
// const invalid = token("color-invalid-999"); // Błąd!
// Responsive props system
type Breakpoint = "sm" | "md" | "lg" | "xl";
type ResponsiveValue<T> = T | { [K in Breakpoint]?: T };
type FlexDirection = "row" | "column" | "row-reverse" | "column-reverse";
type JustifyContent = "start" | "end" | "center" | "between" | "around" | "evenly";
interface FlexProps {
direction?: ResponsiveValue<FlexDirection>;
justify?: ResponsiveValue<JustifyContent>;
gap?: ResponsiveValue<Spacing>;
}
// Generowanie klas CSS
function generateClasses<T extends string>(
prefix: string,
value: ResponsiveValue<T>
): string[] {
if (typeof value === "object") {
return Object.entries(value).map(([breakpoint, val]) =>
`${prefix}-${val}@${breakpoint}`
);
}
return [`${prefix}-${value}`];
}Pięć kolorów i dziewięć odcieni daje 45 nazw, których nie wypisujesz ręcznie.
API client z type safety
Klucze w postaci "METODA /ścieżka" opisują endpointy, a klient wyprowadza z nich typ odpowiedzi i ciała żądania:
// Definicja endpointów API
type APIEndpoints = {
"GET /users": { response: User[]; params: {} };
"GET /users/:id": { response: User; params: { id: string } };
"POST /users": { response: User; params: {}; body: CreateUserDto };
"PUT /users/:id": { response: User; params: { id: string }; body: UpdateUserDto };
"DELETE /users/:id": { response: void; params: { id: string } };
};
// Wyciąganie metody i ścieżki
type ExtractMethod<T> = T extends `${infer Method} ${infer Path}` ? Method : never;
type ExtractPath<T> = T extends `${infer Method} ${infer Path}` ? Path : never;
// Type-safe API client
class APIClient {
async request<T extends keyof APIEndpoints>(
endpoint: T,
options: {
params?: APIEndpoints[T]["params"];
body?: "body" extends keyof APIEndpoints[T] ? APIEndpoints[T]["body"] : never;
} = {}
): Promise<APIEndpoints[T]["response"]> {
const method = endpoint.split(" ")[0];
const path = endpoint.split(" ")[1];
// Zastąp parametry w ścieżce
let url = path;
if (options.params) {
Object.entries(options.params).forEach(([key, value]) => {
url = url.replace(`:${key}`, value as string);
});
}
console.log(`${method} ${url}`, options.body);
// Symulacja API call
return {} as APIEndpoints[T]["response"];
}
}
// Użycie
const api = new APIClient();
api.request("GET /users"); // OK
api.request("GET /users/:id", { params: { id: "123" } }); // OK
api.request("POST /users", { body: { /* ... */ } }); // OK
// api.request("GET /users/:id"); // Kompiluje się! params jest opcjonalne
// api.request("GET /users", { body: {} }); // Błąd! GET nie ma bodyWywołanie GET /users z ciałem to błąd, bo body ma wtedy typ never. Parametry są jednak opcjonalne, więc GET /users/:id bez params się skompiluje, a wymuszenie ich wymagałoby przeciążeń albo typu warunkowego dla całych opcji.
Internacjonalizacja z type safety
Na koniec klucze tłumaczeń: z zagnieżdżonego obiektu powstaje unia ścieżek w stylu user.profile.title:
// System tłumaczeń z zagnieżdżonymi kluczami
type TranslationKeys = {
common: {
yes: string;
no: string;
cancel: string;
};
user: {
profile: {
title: string;
edit: string;
};
settings: {
title: string;
notifications: {
email: string;
push: string;
};
};
};
};
// Generowanie ścieżek do kluczy
type PathsToStringProps<T> = T extends string
? []
: {
[K in keyof T]: [K, ...PathsToStringProps<T[K]>];
}[keyof T];
type TranslationPath = PathsToStringProps<TranslationKeys>;
// ["common", "yes"] | ["common", "no"] | ["user", "profile", "title"] |
// Konwersja tablicy do stringa z kropkami
type JoinPath<T extends string[]> = T extends []
? ""
: T extends [infer First]
? First
: T extends [infer First, ...infer Rest]
? First extends string
? Rest extends string[]
? `${First}.${JoinPath<Rest> & string}`
: never
: never
: never;
type TranslationKey = JoinPath<TranslationPath>;
// "common.yes" | "common.no" | "user.profile.title" |
// Funkcja tłumaczenia z type safety
function t(key: TranslationKey): string {
// Implementacja pobierania tłumaczenia
return key;
}
const title = t("user.profile.title"); // OK
const email = t("user.settings.notifications.email"); // OK
// const invalid = t("user.invalid.key"); // Błąd!
// Tłumaczenia z parametrami
type TranslationWithParams = {
"welcome": { name: string };
"items_count": { count: number };
"date_format": { date: Date };
};
function tWithParams<K extends keyof TranslationWithParams>(
key: K,
params: TranslationWithParams[K]
): string {
// Implementacja z podstawianiem parametrów
return `${key} with ${JSON.stringify(params)}`;
}
tWithParams("welcome", { name: "Jan" }); // OK
tWithParams("items_count", { count: 5 }); // OK
// tWithParams("welcome", { count: 5 }); // Błąd! Nieprawidłowe parametryZapis JoinPath<Rest> & string mówi kompilatorowi, że wynik rekurencji jest napisem. Bez tego wstawienie go do szablonu kończy się błędem typu.
Template literal types to potężne narzędzie, które przenosi manipulację stringami na poziom systemu typów. Pozwala to tworzyć bardziej ekspresywne i bezpieczne API, szczególnie w routingu, internacjonalizacji i systemach stylowania. Moja rada: używaj ich tam, gdzie format napisu jest kontraktem, na przykład w nazwach zdarzeń i tokenów, a nie do walidowania danych od użytkownika. W edytorze poniżej poeksperymentujesz z przykładami, a w kolejnej lekcji wykorzystasz tę wiedzę w typowanym systemie zdarzeń.
Pamiętaj: template literal type to szablon etykiety na probówce, który nie wpuści do laboratorium próbki opisanej w złym formacie.
Kod do tej lekcji: index.ts
// Przykłady template literal types w TypeScript
// 1. Podstawowe template literal types
type Greeting = `Hello ${string}`;
type ErrorMessage = `Error: ${string}`;
const greeting: Greeting = "Hello TypeScript!"; // OK
const error: ErrorMessage = "Error: File not found"; // OK
// const invalid: Greeting = "Hi there!"; // Błąd!
// 2. CSS wartości z type safety
type CSSUnit = "px" | "%" | "em" | "rem" | "vh" | "vw";
type CSSValue = `${number}${CSSUnit}`;
const width: CSSValue = "100px";
const height: CSSValue = "50vh";
const margin: CSSValue = "2.5rem";
// 3. Event handlers - automatyczne generowanie nazw
type EventName = "click" | "focus" | "blur" | "change";
type EventHandlerName<T extends EventName> = `on${Capitalize<T>}`;
type ClickHandler = EventHandlerName<"click">; // "onClick"
type FocusHandler = EventHandlerName<"focus">; // "onFocus"
// Mapowanie event handlers
type EventHandlers = {
[E in EventName as EventHandlerName<E>]: (event: Event) => void;
};
// 4. Snake case to camel case
type SnakeToCamelCase<S extends string> = S extends `${infer T}_${infer U}`
? `${T}${Capitalize<SnakeToCamelCase<U>>}`
: S;
// Konwersja właściwości obiektu
type SnakeToCamelCaseNested<T> = T extends object
? {
[K in keyof T as SnakeToCamelCase<K & string>]: SnakeToCamelCaseNested<T[K]>
}
: T;
// API response transformation
interface APIUserResponse {
user_id: number;
first_name: string;
last_name: string;
email_address: string;
created_at: string;
}
type CamelCasedUser = SnakeToCamelCaseNested<APIUserResponse>;
// Wynik: { userId, firstName, lastName, emailAddress, createdAt }
// 5. Routing z type safety
type Route<T extends string> = T extends `/users/${infer UserId}/posts/${infer PostId}`
? { userId: UserId; postId: PostId }
: T extends `/users/${infer UserId}`
? { userId: UserId }
: T extends `/posts/${infer PostId}`
? { postId: PostId }
: never;
// Test routingu
type UserPostRoute = Route<"/users/123/posts/456">; // { userId: "123"; postId: "456" }
type UserRoute = Route<"/users/789">; // { userId: "789" }
type PostRoute = Route<"/posts/101">; // { postId: "101" }
// 6. Praktyczny system tłumaczeń
type TranslationKey =
| "common.yes"
| "common.no"
| "common.cancel"
| "user.profile.title"
| "user.profile.edit"
| "errors.notFound"
| "errors.unauthorized";
// Funkcja tłumaczenia z type safety
function t(key: TranslationKey): string {
const translations: Record<TranslationKey, string> = {
"common.yes": "Tak",
"common.no": "Nie",
"common.cancel": "Anuluj",
"user.profile.title": "Profil użytkownika",
"user.profile.edit": "Edytuj profil",
"errors.notFound": "Nie znaleziono",
"errors.unauthorized": "Brak autoryzacji"
};
return translations[key];
}
// Użycie z pełnym type safety
console.log(t("common.yes")); // "Tak"
console.log(t("user.profile.title")); // "Profil użytkownika"
// console.log(t("invalid.key")); // Błąd kompilacji!
// 7. CSS-in-JS design tokens
type Color = "primary" | "secondary" | "success" | "danger";
type Shade = 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900;
type ColorToken = `color-${Color}-${Shade}`;
type Spacing = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 8 | 10 | 12;
type SpacingToken = `spacing-${Spacing}`;
type DesignToken = ColorToken | SpacingToken;
function token(name: DesignToken): string {
return `var(--${name})`;
}
// Użycie design tokens
const primaryColor = token("color-primary-500");
const dangerColor = token("color-danger-700");
const smallSpace = token("spacing-2");
const largeSpace = token("spacing-8");
console.log("Design tokens:", {
primaryColor,
dangerColor,
smallSpace,
largeSpace
});
// 8. Walidacja formatu
type Email<T extends string> = T extends `${string}@${string}.${string}` ? T : never;
type ValidEmail = Email<"user@example.com">; // "user@example.com"
type InvalidEmail = Email<"not-an-email">; // never
// Funkcja z walidacją email
function sendEmail<T extends string>(email: Email<T>, subject: string): void {
console.log(`Wysyłam email do ${email} z tematem: ${subject}`);
}
sendEmail("user@example.com" as Email<"user@example.com">, "Witaj!");
// sendEmail("invalid", "Test"); // Błąd kompilacji!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. Co tworzy typ type Greeting =
Hello ${string}w TypeScript?2. Który z poniższych NIE jest wbudowanym string manipulation type w TypeScript?
Zadania praktyczne w grze
- Edytor kodu
Stwórz typy oparte na template literal types.
- Klikanie w kolejności
Ułóż elementy template literal type:
- Układanie w pionie
Ułóż etapy tworzenia template literal type:
- Układanie w poziomie
Ułóż elementy template literal type w odpowiedniej kolejności:
- Edytor kodu
Stwórz type do parsowania URL paths.
Zadania po tej lekcji
- PytanieTemplate literal types
- PytanieString manipulation types
- Zadanie z kodemĆwiczenie: Template literal types
- Kliknij w kolejnościSortowanie: Template literal type
- Ułóż w kolejnościTworzenie template literal type
- Ułóż w kolejnościKolejność: Template literal type
- Zadanie z kodemPattern matching w template literals