Kurs JavaScript i TypeScript · Moduł 7: Zaawansowany TypeScript
Ograniczenia generyczne (constraints)
W tej lekcji9
"W Parku Jurajskim nie wszystkie dinozaury mogą być umieszczone w tych samych zagrodach," tłumaczy Dr. Alan Grant, główny paleontolog parku. "Roślinożerne triceratopsy mogą żyć razem, ale nie możemy umieścić ich z drapieżnymi welociraptorami. Potrzebujemy jasnych zasad, które dinozaury mogą być gdzie umieszczone."
W TypeScript ograniczenia generyczne (generic constraints) działają na podobnej zasadzie - pozwalają określić wymagania dla typów, które mogą być użyte z generycznymi funkcjami lub klasami. Dzięki nim możemy tworzyć bardziej precyzyjne i bezpieczne API, zapewniając, że tylko odpowiednie typy danych są akceptowane.
Podstawy ograniczeń generycznych
Ograniczenia generyczne tworzymy przy użyciu słowa kluczowego extends. Pozwala to na ograniczenie zakresu możliwych typów, które mogą być użyte jako argumenty typu.
Przykład: Proste ograniczenie generyczne
Rozważmy funkcję, która ma wyświetlać podstawowe informacje o dinozaurze. Zamiast akceptować dowolny typ, chcemy mieć pewność, że typ przekazany do funkcji ma przynajmniej właściwości name i species:
// Ograniczenie generyczne - typ T musi mieć przynajmniej właściwości name i species
function displayDinosaurInfo<T extends { name: string; species: string }>(dino: T): void {
console.log(`Nazwa: ${dino.name}, Gatunek: ${dino.species}`);
}
// Działa, ponieważ obiekt zawiera wymagane właściwości
displayDinosaurInfo({ name: "Blue", species: "Velociraptor", age: 5 });
// Działa również z bardziej złożonymi obiektami, o ile zawierają wymagane właściwości
displayDinosaurInfo({
name: "Rex",
species: "Tyrannosaurus Rex",
age: 7,
weight: 8000,
dangerLevel: "Extreme"
});
// Błąd kompilacji - brak wymaganej właściwości 'species'
// displayDinosaurInfo({ name: "Charlie", age: 4 });W tym przykładzie T extends { name: string; species: string } oznacza, że typ generyczny T musi zawierać co najmniej właściwości name i species odpowiedniego typu. Możemy przekazać obiekt z dodatkowymi właściwościami, ale te dwie są wymagane.
Ograniczenia na interfejsach i typach
Często definiujemy interfejsy lub typy, a następnie używamy ich jako ograniczeń dla naszych typów generycznych:
// Definiujemy interfejs podstawowy
interface DinosaurBase {
id: string;
name: string;
species: string;
age: number;
}
// Funkcja z ograniczeniem generycznym opartym na interfejsie
function addToRegistry<T extends DinosaurBase>(dino: T): void {
console.log(`Dodano do rejestru: ${dino.name} (ID: ${dino.id})`);
// Tutaj moglibyśmy dodać dinozaura do bazy danych, itp.
}
// Działa, ponieważ obiekt implementuje DinosaurBase
addToRegistry({
id: "V-001",
name: "Delta",
species: "Velociraptor",
age: 6,
trainingLevel: 3 // Dodatkowa właściwość jest ok
});
// Błąd kompilacji - brak wymaganej właściwości 'age'
// addToRegistry({
// id: "T-001",
// name: "Rexy",
// species: "Tyrannosaurus"
// });Ograniczenia dla klas generycznych
Ograniczenia generyczne są szczególnie przydatne w klasach generycznych, gdzie chcemy zapewnić, że typy użyte z klasą będą spełniać określone wymagania:
// Interfejs dla zwierząt, które mogą być monitorowane
interface Trackable {
id: string;
lastKnownLocation: { x: number; y: number };
attachTracker(trackerId: string): void;
}
// Klasa generyczna z ograniczeniem
class DinosaurTracker<T extends Trackable> {
private trackedEntities: T[] = [];
addEntity(entity: T): void {
// Możemy bezpiecznie używać metod z interfejsu Trackable
entity.attachTracker(`TRK-${Date.now()}`);
this.trackedEntities.push(entity);
console.log(`Rozpoczęto śledzenie: ID ${entity.id} na pozycji (${entity.lastKnownLocation.x}, ${entity.lastKnownLocation.y})`);
}
updateLocation(id: string, x: number, y: number): void {
const entity = this.trackedEntities.find(e => e.id === id);
if (entity) {
entity.lastKnownLocation = { x, y };
console.log(`Zaktualizowano pozycję ${id}: (${x}, ${y})`);
}
}
getEntities(): readonly T[] {
return [...this.trackedEntities];
}
}
// Implementacja klasy dinozaura, która spełnia wymagania interfejsu Trackable
class Velociraptor implements Trackable {
id: string;
name: string;
lastKnownLocation: { x: number; y: number };
private tracker: string | null = null;
constructor(id: string, name: string, initialX: number, initialY: number) {
this.id = id;
this.name = name;
this.lastKnownLocation = { x: initialX, y: initialY };
}
attachTracker(trackerId: string): void {
this.tracker = trackerId;
console.log(`Przypięto tracker ${trackerId} do velociraptora ${this.name}`);
}
hunt(): void {
// Logika polowania
console.log(`${this.name} poluje w okolicy (${this.lastKnownLocation.x}, ${this.lastKnownLocation.y})`);
}
}
// Użycie trackera z velociraptorami
const raptorTracker = new DinosaurTracker<Velociraptor>();
const blue = new Velociraptor("V-001", "Blue", 120, 340);
const charlie = new Velociraptor("V-002", "Charlie", 125, 330);
raptorTracker.addEntity(blue);
raptorTracker.addEntity(charlie);
// Możemy użyć metod specyficznych dla Velociraptor, ponieważ znamy konkretny typ
const raptors = raptorTracker.getEntities();
raptors.forEach(raptor => raptor.hunt());
// Symulacja ruchu
raptorTracker.updateLocation("V-001", 140, 360);Ograniczenia z wieloma wymaganiami
Czasami potrzebujemy, aby typ generyczny spełniał wymagania z wielu interfejsów lub typów. Możemy używać znaku & (intersection type) do łączenia ograniczeń:
// Dwa interfejsy reprezentujące różne aspekty dynamiki parku
interface Identifiable {
id: string;
serialNumber?: string;
}
interface Statusable {
status: "active" | "inactive" | "maintenance";
lastStatusUpdate: Date;
updateStatus(newStatus: "active" | "inactive" | "maintenance"): void;
}
// Funkcja generyczna, która wymaga, aby typ spełniał oba interfejsy
function performMaintenanceCheck<T extends Identifiable & Statusable>(entity: T): void {
console.log(`Rozpoczęcie przeglądu dla ${entity.id}`);
if (entity.status !== "maintenance") {
entity.updateStatus("maintenance");
console.log(`Status zaktualizowany do "maintenance" o ${entity.lastStatusUpdate.toLocaleTimeString()}`);
}
// Symulacja przeglądu
setTimeout(() => {
entity.updateStatus("active");
console.log(`Przegląd zakończony dla ${entity.id}. Status: active`);
}, 2000);
}
// Klasa, która implementuje oba interfejsy
class SecurityGate implements Identifiable, Statusable {
id: string;
serialNumber: string;
status: "active" | "inactive" | "maintenance";
lastStatusUpdate: Date;
constructor(id: string, serialNumber: string) {
this.id = id;
this.serialNumber = serialNumber;
this.status = "active";
this.lastStatusUpdate = new Date();
}
updateStatus(newStatus: "active" | "inactive" | "maintenance"): void {
this.status = newStatus;
this.lastStatusUpdate = new Date();
// Dodatkowa logika specyficzna dla bramy
if (newStatus === "active") {
console.log(`Brama ${this.id} jest teraz aktywna i zabezpieczona`);
} else if (newStatus === "inactive") {
console.log(`UWAGA: Brama ${this.id} jest nieaktywna. Zagrożenie bezpieczeństwa!`);
}
}
// Metoda specyficzna dla bramy
toggleLock(locked: boolean): void {
console.log(`Brama ${this.id} jest teraz ${locked ? "zablokowana" : "odblokowana"}`);
}
}
// Użycie funkcji z obiektem, który spełnia oba ograniczenia
const mainGate = new SecurityGate("GATE-001", "SN123456");
performMaintenanceCheck(mainGate);
// Dodatkowa funkcjonalność dostępna dzięki znajomości pełnego typu
mainGate.toggleLock(true);Ograniczenia z elementami wariantowymi (keyof)
Operator keyof w TypeScript pozwala nam uzyskać sumę kluczy obiektu jako typ. Możemy łączyć to z ograniczeniami generycznymi, aby tworzyć funkcje, które działają na określonych właściwościach obiektów:
// Funkcja, która pobiera obiekt i nazwę pola, a następnie zwraca wartość tego pola
function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
return obj[key];
}
// Przykładowy obiekt z danymi dinozaura
const trex = {
name: "Rexy",
species: "Tyrannosaurus Rex",
age: 7,
diet: "carnivore",
threatLevel: 9,
enclosureId: "E-005"
};
// Poprawne użycie - 'name' jest kluczem obiektu trex
const dinoName = getProperty(trex, "name");
console.log(dinoName); // "Rexy"
// Poprawne użycie - 'age' jest kluczem obiektu trex
const dinoAge = getProperty(trex, "age");
console.log(dinoAge); // 7
// Błąd kompilacji - 'habitat' nie jest kluczem obiektu trex
// const habitat = getProperty(trex, "habitat");To ograniczenie zapewnia, że klucz K jest faktycznie nazwą właściwości obiektu T. TypeScript wie również, jaki typ wartości zostanie zwrócony: T[K] (typ wartości pod kluczem K w obiekcie typu T).
Praktyczny przykład: System raportowania dla Parku Jurajskiego
Zobaczmy bardziej złożony przykład, który wykorzystuje różne aspekty ograniczeń generycznych w kontekście systemu raportowania dla Parku Jurajskiego:
// --- Definicje bazowych typów ---
// Bazowy interfejs dla wszystkich zasobów parku
interface ParkResource {
id: string;
name: string;
lastUpdated: Date;
}
// Interfejs dla generowania raportów
interface Reportable {
generateReport(): string;
}
// Interfejs dla zasobów, którymi można zarządzać
interface Manageable {
assignTo(employeeId: string): void;
getAssignee(): string | null;
}
// --- Specyficzne typy zasobów ---
interface Dinosaur extends ParkResource {
species: string;
diet: "carnivore" | "herbivore" | "omnivore";
healthStatus: "healthy" | "sick" | "critical";
enclosureId: string;
}
interface Employee extends ParkResource {
role: string;
department: "research" | "security" | "operations" | "visitor";
clearanceLevel: 1 | 2 | 3 | 4 | 5;
}
interface Facility extends ParkResource {
type: "enclosure" | "lab" | "visitor_center" | "power_plant";
status: "operational" | "maintenance" | "construction";
location: { x: number; y: number };
}
// --- Implementacja systemu raportowania ---
// Generyczna klasa bazowa dla wszystkich repozytoriów
class ResourceRepository<T extends ParkResource> {
protected resources: Map<string, T> = new Map();
add(resource: T): void {
this.resources.set(resource.id, {
...resource,
lastUpdated: new Date()
});
}
get(id: string): T | undefined {
return this.resources.get(id);
}
getAll(): T[] {
return Array.from(this.resources.values());
}
update(id: string, updates: Partial<T>): boolean {
const resource = this.resources.get(id);
if (!resource) return false;
this.resources.set(id, {
...resource,
...updates,
lastUpdated: new Date()
});
return true;
}
delete(id: string): boolean {
return this.resources.delete(id);
}
count(): number {
return this.resources.size;
}
}
// Klasa dla zarządzalnych zasobów - dodaje funkcjonalność przypisywania
class ManageableResourceRepository<T extends ParkResource & Partial<Manageable>>
extends ResourceRepository<T> {
private assignments: Map<string, string> = new Map(); // resourceId -> employeeId
assignResource(resourceId: string, employeeId: string): boolean {
const resource = this.resources.get(resourceId);
if (!resource) return false;
this.assignments.set(resourceId, employeeId);
// Jeśli zasób implementuje Manageable, wywołujemy jego metodę assignTo
if (resource.assignTo) {
resource.assignTo(employeeId);
}
return true;
}
getAssignee(resourceId: string): string | null {
// Najpierw sprawdzamy, czy zasób implementuje własną metodę getAssignee
const resource = this.resources.get(resourceId);
if (resource?.getAssignee) {
return resource.getAssignee();
}
// W przeciwnym razie korzystamy z naszej wewnętrznej mapy
return this.assignments.get(resourceId) || null;
}
getAssignedResources(employeeId: string): T[] {
const assigned: T[] = [];
this.assignments.forEach((assignedEmployeeId, resourceId) => {
if (assignedEmployeeId === employeeId) {
const resource = this.resources.get(resourceId);
if (resource) assigned.push(resource);
}
});
return assigned;
}
}
// Klasa dla zasobów, które mogą generować raporty
class ReportableResourceRepository<T extends ParkResource & Reportable>
extends ResourceRepository<T> {
generateIndividualReport(id: string): string | null {
const resource = this.resources.get(id);
if (!resource) return null;
return resource.generateReport();
}
generateSummaryReport(): string {
const allResources = this.getAll();
let report = `RAPORT ZBIORCZY
=======================
Łączna liczba zasobów: ${allResources.length}
Ostatnia aktualizacja: ${new Date().toLocaleString()}
=======================\n\n`;
allResources.forEach(resource => {
report += `${resource.name} (ID: ${resource.id}):\n`;
report += `${resource.generateReport()}\n\n`;
});
return report;
}
}
// --- Implementacje specyficznych repozytoriów ---
// Repozytorium dinozaurów
class DinosaurRepository extends ManageableResourceRepository<Dinosaur> {
// Metody specyficzne dla dinozaurów
findBySpecies(species: string): Dinosaur[] {
return this.getAll().filter(dino => dino.species === species);
}
findByDiet(diet: Dinosaur["diet"]): Dinosaur[] {
return this.getAll().filter(dino => dino.diet === diet);
}
findByEnclosure(enclosureId: string): Dinosaur[] {
return this.getAll().filter(dino => dino.enclosureId === enclosureId);
}
// Metoda generująca specjalny raport dla dinozaurów
generateHealthStatusReport(): string {
const allDinos = this.getAll();
const healthy = allDinos.filter(d => d.healthStatus === "healthy").length;
const sick = allDinos.filter(d => d.healthStatus === "sick").length;
const critical = allDinos.filter(d => d.healthStatus === "critical").length;
return `
RAPORT ZDROWIA DINOZAURÓW
=========================
Łącznie: ${allDinos.length}
Zdrowe: ${healthy} (${Math.round(healthy / allDinos.length * 100)}%)
Chore: ${sick} (${Math.round(sick / allDinos.length * 100)}%)
Stan krytyczny: ${critical} (${Math.round(critical / allDinos.length * 100)}%)
=========================
`;
}
}
// Repozytorium pracowników
class EmployeeRepository extends ManageableResourceRepository<Employee> {
// Metody specyficzne dla pracowników
findByDepartment(department: Employee["department"]): Employee[] {
return this.getAll().filter(emp => emp.department === department);
}
findByClearanceLevel(level: Employee["clearanceLevel"]): Employee[] {
return this.getAll().filter(emp => emp.clearanceLevel === level);
}
}
// --- Przykładowe klasy zasobów z implementacją raportowania ---
// Klasa dinozaura implementująca Reportable
class ReportableDinosaur implements Dinosaur, Reportable {
id: string;
name: string;
species: string;
diet: "carnivore" | "herbivore" | "omnivore";
healthStatus: "healthy" | "sick" | "critical";
enclosureId: string;
lastUpdated: Date;
// Dodatkowe właściwości
private weight: number;
private height: number;
private behaviors: string[] = [];
constructor(
id: string,
name: string,
species: string,
diet: "carnivore" | "herbivore" | "omnivore",
healthStatus: "healthy" | "sick" | "critical",
enclosureId: string,
weight: number,
height: number
) {
this.id = id;
this.name = name;
this.species = species;
this.diet = diet;
this.healthStatus = healthStatus;
this.enclosureId = enclosureId;
this.weight = weight;
this.height = height;
this.lastUpdated = new Date();
}
addBehaviorObservation(behavior: string): void {
this.behaviors.push(`${new Date().toISOString()}: ${behavior}`);
this.lastUpdated = new Date();
}
generateReport(): string {
return `
--- RAPORT DINOZAURA ---
ID: ${this.id}
Nazwa: ${this.name}
Gatunek: ${this.species}
Dieta: ${this.diet}
Stan zdrowia: ${this.healthStatus}
Zagroda: ${this.enclosureId}
Waga: ${this.weight} kg
Wysokość: ${this.height} m
Ostatnie zachowania: ${this.behaviors.length > 0 ? '\n - ' + this.behaviors.slice(-3).join('\n - ') : 'Brak zapisanych obserwacji'}
-----------------------
`;
}
}
// --- Przykład użycia ---
// Tworzenie repozytorium dla raportujących dinozaurów
const reportableDinoRepo = new ReportableResourceRepository<ReportableDinosaur>();
// Dodawanie dinozaurów do repozytorium
const rexReport = new ReportableDinosaur(
"D-001",
"Rexy",
"Tyrannosaurus Rex",
"carnivore",
"healthy",
"E-005",
8000,
5.2
);
const triceratopsReport = new ReportableDinosaur(
"D-002",
"Tricy",
"Triceratops",
"herbivore",
"sick",
"E-010",
6000,
3.0
);
// Dodawanie obserwacji zachowań
rexReport.addBehaviorObservation("Zjadła całą krowę w ciągu 15 minut");
rexReport.addBehaviorObservation("Terytorialne ryknięcie w kierunku zagrody Spinozaura");
triceratopsReport.addBehaviorObservation("Słabszy apetyt niż zwykle");
triceratopsReport.addBehaviorObservation("Oznaki gorączki i senności");
// Dodanie do repozytorium
reportableDinoRepo.add(rexReport);
reportableDinoRepo.add(triceratopsReport);
// Generowanie raportów
console.log(reportableDinoRepo.generateIndividualReport("D-001"));
console.log(reportableDinoRepo.generateSummaryReport());Ograniczenia ograniczeń generycznych
Mimo że ograniczenia generyczne są potężnym narzędziem, mają pewne ograniczenia:
Niepełna informacja o typie w czasie wykonania - TypeScript używa ograniczeń generycznych głównie w czasie kompilacji. W czasie wykonania informacje o typach są usuwane (type erasure).
Ograniczenia nominalne vs strukturalne - TypeScript używa typowania strukturalnego, co oznacza, że obiekty o tej samej strukturze są uważane za kompatybilne, nawet jeśli mają różne nazwy typów. Niektórzy programiści przyzwyczajeni do typowania nominalnego (jak w Javie czy C#) mogą uznać to za nieoczekiwane.
Brak ograniczeń negatywnych - Nie można określić, że typ generyczny NIE może mieć pewnych właściwości lub NIE może implementować określonego interfejsu.
Pomimo tych ograniczeń, ograniczenia generyczne są niezwykle przydatne w codziennej pracy z TypeScript.
Kiedy stosować ograniczenia generyczne?
Ograniczenia generyczne warto stosować, gdy:
Potrzebujesz pisać funkcje lub klasy, które działają na różnych typach, ale wymagają, aby te typy miały pewne wspólne cechy.
Chcesz być pewien, że określone metody lub właściwości będą dostępne w typach używanych z twoimi generycznymi komponentami.
Potrzebujesz stworzyć precyzyjne API, które zapewnia bezpieczeństwo typów przy zachowaniu elastyczności.
Implementujesz wzorce projektowe, takie jak repozytoria, fabryki czy serwisy, które powinny działać z różnymi, ale powiązanymi typami danych.
Podsumowanie
Ograniczenia generyczne są ważnym narzędziem w TypeScript, które pozwala na tworzenie bezpiecznych pod względem typów, ale jednocześnie elastycznych komponentów. Pozwalają określić, jakie wymagania muszą spełniać typy używane z generycznymi funkcjami i klasami, co prowadzi do bardziej precyzyjnych i niezawodnych interfejsów API.
Podobnie jak w Parku Jurajskim, gdzie musimy mieć jasne zasady, które dinozaury mogą być umieszczone w których zagrodach, ograniczenia generyczne pozwalają nam jasno określić, jakie typy mogą być używane z naszymi generycznymi komponentami. To zapewnia bezpieczeństwo i przewidywalność naszego kodu, jednocześnie zachowując elastyczność, która sprawia, że generyki są tak potężnym narzędziem.
Kod do tej lekcji: index.ts
// Ograniczenia generyczne (constraints) - Park Jurajski
console.log("=== OGRANICZENIA GENERYCZNE ===\n");
// ===========================================
// 1. extends - ograniczenie typu
// ===========================================
interface HasName {
name: string;
}
interface HasWeight {
weight: number;
}
// T musi miec pole 'name'
function printName<T extends HasName>(entity: T): void {
console.log(`Nazwa: ${entity.name}`);
}
// T musi miec zarowno 'name' jak i 'weight'
function getHeaviest<T extends HasName & HasWeight>(items: T[]): T | undefined {
if (items.length === 0) return undefined;
return items.reduce((max, item) => item.weight > max.weight ? item : max);
}
// ===========================================
// 2. keyof - bezpieczny dostep do kluczy
// ===========================================
interface DinosaurProfile {
name: string;
species: string;
weight: number;
height: number;
dangerLevel: number;
}
// K musi byc kluczem T
function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
return obj[key];
}
// Pobranie wielu wlasciwosci naraz
function pick<T, K extends keyof T>(obj: T, keys: K[]): Pick<T, K> {
const result = {} as Pick<T, K>;
keys.forEach(key => {
result[key] = obj[key];
});
return result;
}
// ===========================================
// 3. Ograniczenia z domyslnymi typami
// ===========================================
interface Sortable {
compareTo?(other: this): number;
}
function sortEntities<T extends HasName>(
items: T[],
compareFn: (a: T, b: T) => number = (a, b) => a.name.localeCompare(b.name)
): T[] {
return [...items].sort(compareFn);
}
// ===========================================
// 4. Ograniczenie konstruktora
// ===========================================
interface Constructor<T> {
new (...args: any[]): T;
}
function createInstances<T extends HasName>(
Ctor: Constructor<T>,
count: number,
...args: any[]
): T[] {
const instances: T[] = [];
for (let i = 0; i < count; i++) {
instances.push(new Ctor(...args));
}
return instances;
}
// ===========================================
// Test
// ===========================================
const dinosaurs: DinosaurProfile[] = [
{ name: "Rexy", species: "T-Rex", weight: 8000, height: 5.5, dangerLevel: 10 },
{ name: "Blue", species: "Velociraptor", weight: 15, height: 1.8, dangerLevel: 8 },
{ name: "Patty", species: "Brachiosaurus", weight: 50000, height: 16, dangerLevel: 1 },
{ name: "Cera", species: "Triceratops", weight: 6000, height: 3, dangerLevel: 3 },
];
// extends
console.log("--- extends constraint ---");
printName({ name: "Rexy" }); // OK - ma pole 'name'
// printName({ age: 5 }); // Error! - brak 'name'
const heaviest = getHeaviest(dinosaurs);
console.log(`Najciezszy: ${heaviest?.name} (${heaviest?.weight}kg)`);
// keyof
console.log("\n--- keyof constraint ---");
const rex = dinosaurs[0];
console.log("Nazwa:", getProperty(rex, "name"));
console.log("Waga:", getProperty(rex, "weight"));
// getProperty(rex, "color"); // Error! 'color' nie jest kluczem
const summary = pick(rex, ["name", "species", "dangerLevel"]);
console.log("Wybrane pola:", JSON.stringify(summary));
// Sortowanie z ograniczeniem
console.log("\n--- sortEntities ---");
const sorted = sortEntities(dinosaurs);
console.log("Alfabetycznie:", sorted.map(d => d.name).join(", "));
const byDanger = sortEntities(dinosaurs, (a, b) => b.dangerLevel - a.dangerLevel);
console.log("Po zagrozeniu:", byDanger.map(d => `${d.name}(${d.dangerLevel})`).join(", "));
// Wielokrotne ograniczenia
console.log("\n--- Multiple constraints ---");
function describeEntity<T extends HasName & HasWeight>(entity: T): string {
return `${entity.name} wazy ${entity.weight}kg`;
}
dinosaurs.forEach(d => console.log(describeEntity(d)));
console.log("\nConstraints = bezpieczne generyki z gwarancja typow!");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 oznacza zapis <T extends { length: number }> w TypeScript?
2. Czym jest constraint w generykach TypeScript?
Zadania praktyczne w grze
- Edytor kodu
Użyj constraints do bezpiecznego typowo dostępu do danych
- Układanie w poziomie
Ułóż elementy użycia keyof:
- Układanie w pionie
Uporządkuj constraints od najbardziej ogólnego do najbardziej szczegółowego: