TypeScript Academy · Lekcja

Wymuszanie wymaganych kroków

Uniemożliwiaj wywołanie build(), dopóki wszystkie wymagane pola nie zostaną ustawione

Wymuszanie wymaganych kroków to bezpłatna lekcja TypeScript Academy na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej TypeScript Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs TypeScript Academy zawiera 4 lekcji w sumie.

Blokowanie przedwczesnego wywołania build()

Teraz wykorzystamy zgromadzony stan, aby zabronić wywołania build(), dopóki wymagane pola nie zostaną ustawione. To system typów, a nie sprawdzenie w czasie działania programu, blokuje niekompletne budowanie.

Definiowanie końcowej struktury

Najpierw należy zadeklarować kompletny obiekt oraz wskazać, które klucze są obowiązkowe. Builder zezwoli na wywołanie build() dopiero wtedy, gdy stan będzie zawierać wszystkie te klucze.

interface Config {
  url: string;   // required
  method: string; // required
  timeout?: number; // optional
}
type Required = { url: string; method: string };

Warunkowa sygnatura build

Udostępniamy build tylko wtedy, gdy zgromadzony stan S rozszerza wymagane klucze. Typ warunkowy zwraca prawdziwą metodę albo metodę, której nie można użyć.

class Builder<S> {
  build(this: Builder<Required>): Config {
    return this.d as Config;
  }
  private d: Record<string, unknown> = {};
}

Użycie parametru this

Parametr this: Builder<Required> ogranicza to, które instancje buildera mogą wywołać build. Jeśli S nie spełnia wymagań typu Required, wywołanie powoduje błąd typów.

// Only a Builder whose S includes url and method
// can legally invoke build().

Powiązanie setterów ze stanem

Każdy setter rozszerza S tak jak wcześniej. Po wykonaniu obu wymaganych setterów S w końcu rozszerza Required, a build staje się dostępne.

class Builder<S> {
  private d: Record<string, unknown> = {};
  url(u: string): Builder<S & { url: string }> { this.d.url = u; return this as any; }
  method(m: string): Builder<S & { method: string }> { this.d.method = m; return this as any; }
  build(this: Builder<{ url: string; method: string }>): Config { return this.d as Config; }
}

Poprawna ścieżka się kompiluje

Gdy obecne są oba wymagane kroki, łańcuch przechodzi sprawdzanie typów i działa. Kompilator ma pewność, że S zawiera każdy wymagany klucz.

const cfg = new Builder<{}>().url("/x").method("GET").build();
console.log(cfg.url, cfg.method);

Błędna ścieżka kończy się niepowodzeniem

Jeśli pominie się wymagany krok, build() przestaje przechodzić sprawdzanie typów, ponieważ S buildera nie rozszerza Required. Błąd zostaje wykryty podczas kompilacji.

// const bad = new Builder<{}>().url("/x").build();
// Error: 'build' can only be called when method is set too.

Dlaczego to lepsze niż zabezpieczenia w czasie działania

Instrukcja if (!this.url) throw w czasie działania programu kończy się niepowodzeniem dopiero wtedy, gdy kod zostanie uruchomiony. Podejście z parametrem this kończy się błędem już podczas sprawdzania typów, dzięki czemu niekompletne konstrukcje nigdy nie trafiają do wdrożenia.

Opcjonalne pola pozostają opcjonalne

Opcjonalne kroki, takie jak timeout, nigdy nie należą do Required, więc nie warunkują wywołania build(). Można je swobodnie uwzględnić albo pominąć.

const ok = new Builder<{}>().method("PUT").url("/y").build();
console.log("order of required steps does not matter");

Skalowanie do wielu wymagań

Wystarczy dodać więcej obowiązkowych kluczy do struktury Required i parametru this, aby kompilator wymuszał je wszystkie. Ten wzorzec skaluje się do dowolnej liczby wymaganych kroków.

Ograniczenia

Gwarancja zależy od uczciwego przekazywania S przez każdy setter oraz stosowania typowania parametru this. Rzutowania należy ograniczyć do setterów, aby kod wywołujący pozostał w pełni bezpieczny typowo.

Szybkie sprawdzenie

Szybkie sprawdzenie wiadomości z tej lekcji.

Podsumowanie

Aby wymusić wykonanie wymaganych kroków, należy nadać typowi build parametr this: Builder<Required>. Metoda przejdzie sprawdzanie typów dopiero wtedy, gdy zgromadzony stan S będzie zawierać każdy wymagany klucz, zamieniając niekompletną konstrukcję w błąd kompilacji.

Często zadawane pytania

Czy lekcja „Wymuszanie wymaganych kroków” jest bezpłatna?

Tak — pełny tekst „Wymuszanie wymaganych kroków” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu TypeScript Academy, przejdź na CoddyKit PRO. Kurs TypeScript Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Wymuszanie wymaganych kroków”?

Uniemożliwiaj wywołanie build(), dopóki wszystkie wymagane pola nie zostaną ustawione Ćwiczysz TypeScript Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć TypeScript Academy?

Nie wymagamy żadnego doświadczenia. TypeScript Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.

Ile czasu zajmuje lekcja „Wymuszanie wymaganych kroków”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji TypeScript Academy?

Tak. Każda lekcja TypeScript Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do TypeScript Academy