TypeScript Academy · Lekcja

Zrozumienie unknown i any

Dlaczego unknown jest bezpieczną typowo alternatywą dla any

Zrozumienie unknown i any to bezpłatna lekcja TypeScript Academy na CoddyKit. To lekcja 1 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.

Dwa typy najwyższe

TypeScript ma dwa typy, które mogą przechowywać dowolną wartość: any i unknown. Wyglądają podobnie, ale działają zupełnie inaczej. Wybór właściwego typu to podstawowa umiejętność potrzebna do tworzenia bezpiecznego typowo kodu.

let a: any = 5;
let u: unknown = 5;
console.log(a, u);

any wyłącza sprawdzanie typów

any to wyjście awaryjne, które wyłącza sprawdzanie typów dla danej wartości. Można odwołać się do dowolnej właściwości lub wywołać tę wartość jak funkcję — kompilator pozostanie cichy, nawet jeśli kod zakończyłby się błędem w czasie działania programu.

const a: any = 'hello';
console.log(a.toUpperCase()); // OK
// a.doesNotExist(); // no compile error, but crashes at runtime

unknown wymusza sprawdzenie

unknown również akceptuje dowolną wartość, ale nie można jej użyć, dopóki nie zostanie ustalone, czym jest. Kompilator blokuje dostęp do właściwości i wywołania, dopóki typ nie zostanie zawężony.

const u: unknown = 'hello';
// console.log(u.toUpperCase()); // Error: u is unknown
console.log(typeof u);

Zawężanie unknown za pomocą typeof

Warunek ochronny typeof zawęża unknown do konkretnego typu wewnątrz bloku. Po zawężeniu wszystkie metody tego typu stają się bezpiecznie dostępne.

function shout(value: unknown): string {
  if (typeof value === 'string') {
    return value.toUpperCase(); // safe here
  }
  return 'not a string';
}
console.log(shout('hi'), shout(42));

Dlaczego unknown jest bezpieczniejszy

unknown oznacza uczciwą niepewność: „Jeszcze nie wiem, czym to jest”. Zmusza do sprawdzenia wartości przed użyciem, wykrywając błędy podczas kompilacji. any jedynie ukrywa niepewność i błędy.

function len(value: unknown): number {
  if (typeof value === 'string') return value.length;
  if (Array.isArray(value)) return value.length;
  return 0;
}
console.log(len('abc'), len([1, 2]), len(99));

Przypisywanie do unknown i z unknown

Każdą wartość można przypisać do typu unknown. Jednak unknown można przypisać wyłącznie do unknown lub any — nie do konkretnych typów bez zawężenia. Ta asymetria zapewnia bezpieczeństwo.

let u: unknown = 10;
u = 'now a string';
u = true;
const anyVal: any = u; // allowed
console.log(anyVal);
// const s: string = u; // Error

any rozprzestrzenia się w kodzie

Niebezpieczną cechą any jest jego rozprzestrzenianie się. Gdy wartość ma typ any, wszystko, co zostanie z niej wyprowadzone, również otrzymuje typ any, po cichu osłabiając bezpieczeństwo typów w całym programie.

const a: any = { count: 5 };
const total = a.count + 10; // total is any
const flag = total.whatever; // still any, no error
console.log(total);

unknown ogranicza ryzyko

W przypadku unknown niepewność pozostaje na swoim miejscu. Na każdej granicy trzeba jawnie zawęzić typ, dzięki czemu niebezpieczne operacje nie mogą przedostać się dalej. Ryzyko pozostaje tam, gdzie powinno.

const u: unknown = { count: 5 };
if (typeof u === 'object' && u !== null && 'count' in u) {
  console.log('Has count property');
}

Typowanie granic API i JSON

Dane zewnętrzne — JSON, odpowiedzi sieciowe i dane wprowadzane przez użytkownika — nie dają żadnych gwarancji. Oznaczenie ich jako unknown zamiast any wymusza sprawdzenie przed zaufaniem tym danym, co jest bezpiecznym ustawieniem domyślnym.

function parse(text: string): unknown {
  return JSON.parse(text);
}
const data = parse('{"id":1}');
if (typeof data === 'object' && data !== null) {
  console.log('Got an object');
}

Kiedy any jest akceptowalne

any bywa pragmatycznym rozwiązaniem — w szybkich prototypach, podczas stopniowej migracji z JavaScriptu lub we współpracy z bibliotekami bez typów. Należy jednak traktować je jako tymczasowe oznaczenie, a nie nawyk. Zawsze, gdy to możliwe, należy preferować unknown.

// Migration placeholder, to be typed later
let legacy: any = getLegacyValue();
function getLegacyValue() { return { x: 1 }; }
console.log(legacy.x);

Praktyczne porównanie

Porównanie obok siebie: wersja z any kompiluje się, ale może zakończyć się błędem; wersja z unknown odmawia kompilacji niebezpiecznego dostępu. Kompilator wykonuje swoją pracę — chroni Państwa kod.

const a: any = 42;
console.log(a.toFixed(2)); // OK by luck

const u: unknown = 42;
if (typeof u === 'number') {
  console.log(u.toFixed(2)); // checked, safe
}

Szybkie sprawdzenie

Sprawdź swoją wiedzę na temat unknown i any.

Podsumowanie: unknown i any

Najważniejsze informacje:

any wyłącza sprawdzanie typów i rozprzestrzenia się na wyprowadzane wartości.
unknown akceptuje dowolną wartość, ale blokuje jej użycie do momentu jej zawężenia.
Używaj unknown dla danych zewnętrznych (JSON, API, danych użytkownika), aby wymusić ich sprawdzenie.
Zachowaj any na potrzeby migracji lub współpracy z kodem bez typów, jako tymczasowe oznaczenie.

W następnym kroku poznamy typ pusty: never.

function safeLen(v: unknown): number {
  return typeof v === 'string' ? v.length : 0;
}
console.log(safeLen('hello'), safeLen(123));

Często zadawane pytania

Czy lekcja „Zrozumienie unknown i any” jest bezpłatna?

Tak — pełny tekst „Zrozumienie unknown i any” 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 „Zrozumienie unknown i any”?

Dlaczego unknown jest bezpieczną typowo alternatywą dla any Ć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 1 z 4.

Ile czasu zajmuje lekcja „Zrozumienie unknown i any”?

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