Что такое unknown в TypeScript?

unknown — это безопасный эквивалент any в TypeScript. Это тип, который может содержать значение любого типа, но перед тем как его использовать, вы обязаны выполнить type checking. Unknown говорит: "Я не знаю, какой это тип, проверь перед использованием."

Отличие unknown от any

// ❌ any — TYPE CHECKER ОТКЛЮЧЕН
const value: any = "hello";
const result = value.toUpperCase(); // OK (компилятор не проверяет)
const calcResult = value + 10; // OK (может быть ошибка в runtime)

// ✅ unknown — ТРЕБУЕТ TYPE CHECKING
const unknownValue: unknown = "hello";
const result2 = unknownValue.toUpperCase(); // ❌ Error: Object is of type 'unknown'
if (typeof unknownValue === 'string') {
  const result3 = unknownValue.toUpperCase(); // ✅ OK
}

Type Guards (проверка типов)

typeof guard

function processValue(value: unknown): string {
  if (typeof value === 'string') {
    return value.toUpperCase();
  }
  if (typeof value === 'number') {
    return value.toString();
  }
  if (typeof value === 'boolean') {
    return value ? 'true' : 'false';
  }
  return 'unknown type';
}

processValue("hello"); // "HELLO"
processValue(42); // "42"

instanceof guard

class User {
  constructor(public name: string) {}
}

function handleData(data: unknown) {
  if (data instanceof User) {
    console.log(`User: ${data.name}`);
  } else if (data instanceof Date) {
    console.log(`Date: ${data.toISOString()}`);
  } else {
    console.log('Unknown type');
  }
}

Custom type guard (предикат)

interface User {
  id: string;
  name: string;
  email: string;
}

function isUser(value: unknown): value is User {
  return (
    typeof value === 'object' &&
    value !== null &&
    'id' in value &&
    'name' in value &&
    'email' in value &&
    typeof value.id === 'string' &&
    typeof value.name === 'string' &&
    typeof value.email === 'string'
  );
}

function handleUser(data: unknown) {
  if (isUser(data)) {
    console.log(`User: ${data.name} (${data.email})`);
  } else {
    console.log('Not a valid user');
  }
}

Практические примеры

1. Обработка JSON парсинга

function parseJsonSafe(json: string): unknown {
  try {
    return JSON.parse(json);
  } catch (error) {
    return null;
  }
}

const result = parseJsonSafe('{"name":"John"}');
if (typeof result === 'object' && result !== null && 'name' in result) {
  console.log(result.name); // ✅ Type safe
}

2. Обработка API ответов

interface ApiResponse {
  status: number;
  data: unknown;
}

async function fetchData(url: string): Promise<ApiResponse> {
  const response = await fetch(url);
  return response.json();
}

const response = await fetchData('/api/users');
if (response.status === 200) {
  const data = response.data;
  if (Array.isArray(data)) {
    console.log(`Получено ${data.length} элементов`);
  } else if (typeof data === 'object') {
    console.log('Получен объект:', data);
  }
}

3. Обработка ошибок

try {
  riskyOperation();
} catch (error: unknown) {
  if (error instanceof Error) {
    console.log(error.message);
  } else if (typeof error === 'string') {
    console.log(error);
  } else {
    console.log('Unknown error:', error);
  }
}

4. Валидация входных данных

interface RequestData {
  userId: unknown;
  email: unknown;
}

function validateRequest(data: RequestData) {
  if (typeof data.userId !== 'string') {
    throw new Error('userId must be a string');
  }

  if (typeof data.email !== 'string') {
    throw new Error('email must be a string');
  }

  if (!isValidEmail(data.email)) {
    throw new Error('Invalid email format');
  }

  return { userId: data.userId, email: data.email };
}

unknown vs any (сравнение)

Лучшие практики

// ✅ Используй unknown для неизвестных типов
function handle(value: unknown) {
  // Проверяй тип перед использованием
}

// ✅ Используй type guards для валидации
function isValidUser(value: unknown): value is User {
  // Проверка структуры
}

// ❌ Избегай any
// ❌ Не пропускай type checking для unknown

// ✅ Комбинируй с типами
type Response<T> = { status: number; data: T };

unknown — это правильный выбор для TypeScript разработчика. Это заставляет быть осторожнее и писать более надежный код, который меньше подвержен ошибкам в runtime.