Для чего используется тип Unknown?

Для чего используется тип Unknown в TypeScript

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

Основная разница: any vs unknown

// any — небезопасно
const data: any = "hello";
const result = data.toUpperCase(); // Работает, но мог быть любой тип

// unknown — безопасно
const data: unknown = "hello";
const result = data.toUpperCase(); // Ошибка! Нужна проверка типа

any позволяет делать что угодно без проверок, а unknown требует явной проверки типа перед использованием.

Когда использовать unknown

1. Парсинг JSON

const parseJSON = (jsonString: string): unknown => {
  return JSON.parse(jsonString);
};

const data = parseJSON("{");

// Нужна проверка типа перед использованием
if (typeof data === "object" && data !== null && "name" in data) {
  console.log((data as {name: string}).name);
}

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

try {
  // какой-то код
} catch (error: unknown) {
  // error может быть чем угодно
  if (error instanceof Error) {
    console.log(error.message);
  } else if (typeof error === "string") {
    console.log(error);
  } else {
    console.log("Unknown error");
  }
}

3. Функции, которые получают данные с бэкенда

const fetchUserData = async (id: number): Promise<unknown> => {
  const response = await fetch(`/api/users/${id}`);
  return response.json();
};

const data = await fetchUserData(1);

// Валидация перед использованием
function isValidUser(obj: unknown): obj is {id: number; name: string} {
  return (
    typeof obj === "object" &&
    obj !== null &&
    "id" in obj &&
    "name" in obj &&
    typeof (obj as any).id === "number" &&
    typeof (obj as any).name === "string"
  );
}

if (isValidUser(data)) {
  console.log(data.name);
}

4. Generic функции

function processData<T>(data: T): T {
  if (typeof data === "object" && data !== null) {
    console.log("Object received");
  }
  return data;
}

Type Guards для unknown

1. typeof проверки

const handleInput = (value: unknown) => {
  if (typeof value === "string") {
    console.log(value.toUpperCase());
  } else if (typeof value === "number") {
    console.log(value * 2);
  } else if (typeof value === "boolean") {
    console.log(!value);
  }
};

2. instanceof проверки

const handleError = (error: unknown) => {
  if (error instanceof Error) {
    console.log(error.message);
    console.log(error.stack);
  } else if (error instanceof TypeError) {
    console.log("Type error occurred");
  }
};

3. Property проверки (in оператор)

const handleObject = (obj: unknown) => {
  if (typeof obj === "object" && obj !== null && "name" in obj) {
    console.log((obj as {name: string}).name);
  }
};

4. Custom Type Guards

// Определяем функцию-guard
function isUser(obj: unknown): obj is {id: number; email: string} {
  return (
    typeof obj === "object" &&
    obj !== null &&
    "id" in obj &&
    "email" in obj &&
    typeof (obj as any).id === "number" &&
    typeof (obj as any).email === "string"
  );
}

// Используем
const data: unknown = {id: 1, email: "user@example.com"};

if (isUser(data)) {
  console.log(data.email);
}

Практический пример: Безопасный парсер API

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

function isUser(obj: unknown): obj is User {
  if (typeof obj !== "object" || obj === null) return false;
  
  const o = obj as Record<string, unknown>;
  
  return (
    typeof o.id === "number" &&
    typeof o.name === "string" &&
    typeof o.email === "string"
  );
}

class UserService {
  async getUser(id: number): Promise<User> {
    const response = await fetch(`/api/users/${id}`);
    const data: unknown = await response.json();
    
    if (!isUser(data)) {
      throw new Error("Invalid user data from API");
    }
    
    return data;
  }
}

unknown в функциях

// Функция, которая может вернуть любой тип
function getValue(): unknown {
  return Math.random() > 0.5 ? "string" : 42;
}

const result = getValue();

// result имеет тип unknown
// Нельзя использовать без проверки:
// result.length; // Ошибка!
// result + 10; // Ошибка!

// Нужна проверка:
if (typeof result === "string") {
  console.log(result.length);
}

if (typeof result === "number") {
  console.log(result + 10);
}

any vs unknown

// any — небезопасно, нарушает типизацию
const anyValue: any = getSomething();
anyValue.foo.bar();

// unknown — безопасно, требует проверки
const unknownValue: unknown = getSomething();
if (typeof unknownValue === "object" && unknownValue !== null && "foo" in unknownValue) {
  (unknownValue as any).foo.bar();
}

Заключение

unknown — это правильный выбор когда ты не знаешь точный тип значения. Он обязывает тебя проверить тип перед использованием, что делает код более безопасным и предсказуемым. Используй unknown вместо any для лучшей типизации.