0Pricing
TypeScript Academy · Lekcja

Wielokrotnego użytku wzorce modeli danych

Stosowanie generycznych wzorców w rzeczywistych modelach: Paginated , Result , DTO z Pick/Omit/Partial oraz mapy indeksowane przez id

Wielokrotnego użytku wzorce modeli danych 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: Pakować typowe struktury danych w typy generyczne, aby ponownie używać struktur bez utraty bezpieczeństwa typów.

  • Paginated<T>
  • Result<T,E>
  • DTO z użyciem Pick/Omit/Partial
  • Mapy indeksowane przez id

Paginated<T>

Paginated<T> centralizuje metadane i zachowuje precyzyjny typ elementu T dla list.

type Paginated<T> = {
  items: T[];
  total: number;
  page: number;
  pageSize: number;
};

type User = { id: number; name: string };

const page1: Paginated<User> = {
  items: [{ id: 1, name: "Ada" }],
  total: 10,
  page: 1,
  pageSize: 5,
};

console.log(page1.items[0].name);

Result<T,E>

Result<T,E> jawnie modeluje powodzenie i niepowodzenie za pomocą dyskryminatora (ok), umożliwiając bezpieczne rozgałęzianie.

type Ok<T> = { ok: true; data: T };
type Err<E = string> = { ok: false; error: E };

type Result<T, E = string> = Ok<T> | Err<E>;

function readUser(id: number): Result<{ id: number; name: string }> {
  return id > 0 ? { ok: true, data: { id, name: "Ada" } } : { ok: false, error: "not found" };
}

const r = readUser(1);
if (r.ok) {
  console.log(r.data.name);
} else {
  console.error(r.error);
}

Wzorce DTO

Za pomocą Pick/Omit/Partial można wyprowadzać zwięzłe typy DTO z modelu bazowego — bez powielania definicji.

type User = { id: number; name: string; email?: string; role: "user" | "admin" };

type UserCreateDto = Pick<User, "name" | "email">; // fields required to create

// Update = partial editable fields
type UserUpdateDto = Partial<Pick<User, "name" | "email">>;

const createBody: UserCreateDto = { name: "Ada", email: "a@x.io" };
const updateBody: UserUpdateDto = { name: "Ada L." };

MapById<T>

MapById<T> indeksuje encje według id, aby umożliwić szybkie wyszukiwanie. Należy ograniczyć T, aby zapewnić obecność właściwości id.

type Key = string | number;

type MapById<T extends { id: Key }> = Record<Key, T>;

const byId: MapById<{ id: number; name: string }> = {
  1: { id: 1, name: "Ada" },
  2: { id: 2, name: "Lin" },
};

console.log(byId[1].name);

Wskazówki

Wskazówki:

  • Należy utrzymywać wzorce małe i możliwe do komponowania.
    • unie dyskryminowane w przypadku automatów stanów.
  • DTO należy wyprowadzać z modeli, zamiast tworzyć ich ręczne kopie.

Sprawdzenie Paginated<T>

Szybkie sprawdzenie: Po co definiować generyczny typ Paginated<T>?

Podsumowanie

Podsumowanie: Należy uogólniać powtarzające się struktury: Paginated<T>, Result<T,E>, DTO z użyciem Pick/Omit/Partial oraz mapy indeksowane przez id. Małe funkcje pomocnicze można wykorzystywać w wielu funkcjach.

Często zadawane pytania

Czy lekcja „Wielokrotnego użytku wzorce modeli danych” jest bezpłatna?

Tak — pełny tekst „Wielokrotnego użytku wzorce modeli danych” 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 „Wielokrotnego użytku wzorce modeli danych”?

Stosowanie generycznych wzorców w rzeczywistych modelach: Paginated , Result , DTO z Pick/Omit/Partial oraz mapy indeksowane przez id Ć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 „Wielokrotnego użytku wzorce modeli danych”?

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. Generyczne interfejsy i aliasy typów
  2. Typy warunkowe — wprowadzenie — i dystrybucja po uniach
  3. Wielokrotnego użytku wzorce modeli danych
← Powrót do TypeScript Academy