TypeScript Academy · Lekcja

Bezpieczna typowo obsługa unknown

Zawężaj wartości unknown, zanim zaczniesz bezpiecznie ich używać

Lekcja 4 z 413 kroki

Bezpieczna typowo obsługa unknown to bezpłatna lekcja TypeScript Academy na CoddyKit. To lekcja 4 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.

Bezpieczna praca z unknown

Określenie typu danych zewnętrznych jako unknown to dopiero połowa zadania. Druga połowa polega na zawężeniu ich do konkretnego typu przed użyciem. W tej lekcji omówiono najważniejsze techniki zawężania.

function describe(v: unknown): string {
  if (typeof v === 'string') return 'string: ' + v;
  if (typeof v === 'number') return 'number: ' + v;
  return 'other';
}
console.log(describe('hi'), describe(7), describe(true));

Zawężanie za pomocą typeof

Sprawdzanie za pomocą typeof jest najprostszym narzędziem. Zawęża unknown do typów prymitywnych: string, number, boolean, function, object i innych.

function double(v: unknown): number {
  if (typeof v === 'number') {
    return v * 2; // v is number here
  }
  return 0;
}
console.log(double(21), double('no'));

Zawężanie za pomocą instanceof

W przypadku instancji klas należy użyć instanceof. Zawęża ono unknown do konkretnej klasy, bezpiecznie udostępniając jej metody i właściwości.

function handle(v: unknown): string {
  if (v instanceof Date) {
    return v.toISOString(); // v is Date
  }
  return 'not a date';
}
console.log(handle(new Date(0)));

Zawężanie za pomocą operatora in

Operator in sprawdza, czy właściwość istnieje w obiekcie, zawężając wartości typu obiektowego. Najpierw należy potwierdzić, że wartość jest obiektem innym niż null, a następnie sprawdzić jej klucze.

function getName(v: unknown): string {
  if (typeof v === 'object' && v !== null && 'name' in v) {
    return String((v as { name: unknown }).name);
  }
  return 'anonymous';
}
console.log(getName({ name: 'Ada' }), getName(5));

Własne strażniki typu

Własny strażnik typu to funkcja, której typ zwracany ma postać value is T. Gdy funkcja zwróci true, TypeScript zawęża argument do typu T w miejscu wywołania.

function isString(v: unknown): v is string {
  return typeof v === 'string';
}

function shout(v: unknown): string {
  return isString(v) ? v.toUpperCase() : '?';
}
console.log(shout('hey'), shout(9));

Strażniki kształtu obiektu

Własne strażniki są szczególnie przydatne do sprawdzania kształtu obiektów. Wystarczy napisać jedną funkcję sprawdzającą wszystkie wymagane pola, aby reszta kodu mogła zaufać zawężonemu typowi.

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

function isUser(v: unknown): v is User {
  return typeof v === 'object' && v !== null &&
    'id' in v && 'name' in v;
}
console.log(isUser({ id: 1, name: 'Sam' }), isUser({}));

JSON.parse zwraca dane podobne do unknown

Funkcja JSON.parse ma zadeklarowany typ zwracany any, który po cichu omija mechanizmy bezpieczeństwa. Najlepsza praktyka to przechwycenie wyniku jako unknown i sprawdzenie go przed uznaniem jego kształtu za poprawny.

function parseConfig(text: string): unknown {
  return JSON.parse(text);
}
const raw = parseConfig('{"port":8080}');
console.log(typeof raw);

Sprawdzanie sparsowanego JSON

Połącz JSON.parse ze strażnikiem typu, aby bezpiecznie przekształcić niezaufany tekst w wartość o określonym typie. Jeśli sprawdzanie się nie powiedzie, obsłuż błąd zamiast ufać nieprawidłowym danym.

type Config = { port: number };

function isConfig(v: unknown): v is Config {
  return typeof v === 'object' && v !== null &&
    'port' in v && typeof (v as any).port === 'number';
}

const data: unknown = JSON.parse('{"port":8080}');
if (isConfig(data)) console.log('Port:', data.port);

Łączenie wielu strażników

W przypadku złożonych danych należy łączyć strażniki: najpierw sprawdzić ogólny kształt, a następnie go doprecyzować. Każdy strażnik zawęża typ nieco bardziej, krok po kroku tworząc precyzyjne i bezpieczne typy.

function process(v: unknown): string {
  if (Array.isArray(v)) {
    if (v.every((x) => typeof x === 'string')) {
      return v.join('-');
    }
  }
  return 'invalid';
}
console.log(process(['a', 'b']), process([1, 2]));

Zgłaszanie wyjątku dla nieprawidłowych danych

Jeśli sprawdzanie wymaganych danych się nie powiedzie, należy zgłosić wyjątek. W połączeniu z pomocniczą funkcją zwracającą never pozwala to zachować przejrzystą ścieżkę poprawnego wykonania z właściwie określonymi typami.

function asNumber(v: unknown): number {
  if (typeof v === 'number') return v;
  throw new Error('Expected a number');
}
console.log(asNumber(42));
try { asNumber('x'); } catch (e) { console.log('rejected'); }

Połączenie wszystkich elementów

Pełny wzorzec wygląda następująco: odebrać dane jako unknown, zawęzić je za pomocą strażników, a następnie operować na precyzyjnym typie. Jest to bezpieczna granica między nietypowanym światem zewnętrznym a kodem korzystającym z typów.

type Point = { x: number; y: number };
function isPoint(v: unknown): v is Point {
  return typeof v === 'object' && v !== null &&
    'x' in v && 'y' in v;
}
const input: unknown = { x: 1, y: 2 };
if (isPoint(input)) console.log(input.x + input.y);

Szybkie sprawdzenie

Sprawdź zrozumienie bezpiecznej obsługi unknown.

Odpowiedz w interaktywnej lekcji

Podsumowanie: obsługa unknown

W tym rozdziale poznano zawężanie unknown za pomocą:

typeof dla typów prymitywnych oraz instanceof dla instancji klas.
Operatora in do sprawdzania właściwości obiektów.
Własnych strażników typu zwracających value is T.
Sprawdzania wyników JSON.parse przed uznaniem ich za zaufane.

Następny kurs: asercje typów i rzutowanie.

function isNonEmpty(v: unknown): v is string {
  return typeof v === 'string' && v.length > 0;
}
console.log(isNonEmpty('hi'), isNonEmpty(''));

Bezpłatny start

Ucz się TypeScript dzięki korepetycjom AI — za darmo

Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.

Kursy: 101
Lekcje: 352

Zacznij naukę bezpłatnie Wyświetl pełny kurs

Często zadawane pytania

Czy lekcja „Bezpieczna typowo obsługa unknown” jest bezpłatna?

Tak — pełny tekst „Bezpieczna typowo obsługa unknown” 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 „Bezpieczna typowo obsługa unknown”?

Zawężaj wartości unknown, zanim zaczniesz bezpiecznie ich używać Ć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 4 z 4.

Ile czasu zajmuje lekcja „Bezpieczna typowo obsługa unknown”?

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