0Pricing
TypeScript Academy · Lekcja

Konstruktory silnie typowane

Projektowanie łańcuchowych konstruktorów gromadzących opcje z typami; zapewnianie wymaganych kroków i poprawnych kombinacji za pomocą generyków i typów warunkowych

Konstruktory silnie typowane to bezpłatna lekcja TypeScript Academy na CoddyKit. To lekcja 3 z 3. 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 3 lekcji w sumie.

Wprowadzenie

Cel: Budowanie API z możliwością łańcuchowania, w którym postęp jest zakodowany w typie. Każdy krok zwraca nowy typowany stan, dlatego nieprawidłowe kolejności są odrzucane podczas kompilacji.

  • Gromadzenie opcji w generyku
  • Kontrolowanie kroków za pomocą flag
  • Zachowanie prostej ergonomii pracy

Flagi stanu

Każdy krok zwraca nowy typ stanu; metoda build jest dostępna tylko wtedy, gdy wymagane flagi mają wartość true.

type Flags = { method: boolean; url: boolean }

type With<F extends Partial<Flags>> = { flags: F }

type True = true

type Builder<F extends Partial<Flags>, O extends Record<string, unknown>> = With<F> & {
  method<M extends "GET" | "POST">(m: M): Builder<F & { method: True }, O & { method: M }>
  url<U extends `/${string}`>(u: U): Builder<F & { url: True }, O & { url: U }>
  build(this: Builder<{ method: True; url: True }, any>): O
}

function createBuilder(): Builder<{}, {}> {
  return {
    flags: {},
    method(m) { return { ...this, flags: { ...this.flags, method: true }, method: this.method, url: this.url, build: this.build } as any },
    url(u) { return { ...this, flags: { ...this.flags, url: true }, method: this.method, url: this.url, build: this.build } as any },
    build() { return this as any }
  } as any
}

const b = createBuilder()
const good = b.method("GET").url("/users").build()   // ok
// const bad = b.build() // error: build requires method & url flags

Gromadzenie opcji

Opcje są gromadzone w generyku O; każde wywołanie zwraca typ, do którego dodawane są nowe właściwości.

type B2<F extends Partial<Flags>, O extends Record<string, unknown>> = With<F> & {
  header<K extends string, V extends string>(k: K, v: V): B2<F, O & { headers: Record<K, V> }>
  query<K extends string, V extends string>(k: K, v: V): B2<F, O & { query: Record<K, V> }>
  method<M extends "GET" | "POST">(m: M): B2<F & { method: True }, O & { method: M }>
  url<U extends `/${string}`>(u: U): B2<F & { url: True }, O & { url: U }>
  build(this: B2<{ method: True; url: True }, any>): O
}

function builder2(): B2<{}, {}> { return {} as any }

const conf = builder2()
  .method("POST")
  .url("/login")
  .header("x-id", "42")
  .query("next", "home")
  .build()

Poprawne kombinacje

Kombinacje można ograniczać za pomocą typów warunkowych: należy zezwolić na body wyłącznie dla POST.

type Method = "GET" | "POST"

type BodyIfPost<M extends Method, B> = M extends "POST" ? { body: B } : {}

type B3<F extends Partial<Flags>, O extends Record<string, unknown>> = With<F> & {
  method<M extends Method>(m: M): B3<F & { method: True }, O & { method: M }>
  url<U extends `/${string}`>(u: U): B3<F & { url: True }, O & { url: U }>
  body<B>(b: B & (O extends { method: "POST" } ? unknown : never)): B3<F, O & BodyIfPost<O extends { method: infer M } ? Extract<M, Method> : Method, B>>
  build(this: B3<{ method: True; url: True }, any>): O
}

function builder3(): B3<{}, {}> { return {} as any }

const ok = builder3().method("POST").url("/u").body({ a: 1 }).build()
// const badBody = builder3().method("GET").url("/u").body({ a: 1 }).build() // compile-time error

Wariadyczny potok

Kroki można gromadzić w kolekcji za pomocą tablicy krotek wariadycznych; wejściem i wyjściem należy zarządzać przez Parameters/ReturnType.

type Step<A extends any[], R> = (...args: A) => R

type Pipeline<P extends Step<any, any>[]> = {
  use<S extends Step<any, any>>(...s: [S]): Pipeline<[...P, S]>
  run<A extends Parameters<P[0]>>(this: Pipeline<P>, ...args: A): ReturnType<P[number]>
}

function pipeMake(): Pipeline<[]> { return {} as any }

const pipe = pipeMake()
  .use((a: string) => a.length)
  .use((n: number) => n % 2 === 0)
// pipe.run("abc") // demo; implementation omitted

Wskazówki

Wskazówki:

Stan należy przechowywać jako generyk pozorny, aby nie obciążać środowiska wykonawczego.

Warto zachować krótkie i stałe nazwy kroków (method, url).

Złożone kombinacje należy rozdzielać za pomocą typów warunkowych, aby zachować przejrzystość łańcucha.

Sprawdzenie kontroli konstruktora

Szybkie sprawdzenie: Jak zagwarantować, że .method() zostanie wywołane przed .build()?

Podsumowanie

Podsumowanie: Typowany stan jest przenoszony wzdłuż łańcucha, opcje są gromadzone w generykach, a nieprawidłowe sekwencje są wykrywane podczas kompilacji.

Często zadawane pytania

Czy lekcja „Konstruktory silnie typowane” jest bezpłatna?

Tak — pełny tekst „Konstruktory silnie typowane” 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 3 lekcji w sumie.

Co nauczysz się w „Konstruktory silnie typowane”?

Projektowanie łańcuchowych konstruktorów gromadzących opcje z typami; zapewnianie wymaganych kroków i poprawnych kombinacji za pomocą generyków i typów warunkowych Ć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 3.

Ile czasu zajmuje lekcja „Konstruktory silnie typowane”?

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

  1. Elementy rest krotek i typy curry
  2. Bezpieczne komponowanie funkcji i argumentów
  3. Konstruktory silnie typowane
← Powrót do TypeScript Academy