Как можно отключить строгую типизацию в TS для определенных мест?

Отключение строгой типизации в TypeScript

TypeScript предоставляет несколько способов отключить или ослабить строгую типизацию для конкретного кода, когда это действительно необходимо. Однако это следует использовать осторожно — чрезмерное использование может привести к потере преимуществ типизации.

1. Директива @ts-ignore

Отключает все проверки типов для следующей строки

// Ошибка: Type "string" is not assignable to type "number"
const value: number = "123"; // Ошибка TS!

// Решение: использовать @ts-ignore
// @ts-ignore
const value: number = "123"; // Больше нет ошибки

// Игнорирование конкретного свойства
const obj: { name: string } = {
  // @ts-ignore
  name: 123 // Ошибка игнорируется
};

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

• Работа с неполной или странной типизацией библиотеки
• Временное решение во время миграции на TypeScript
• Когда ты точно знаешь, что делаешь, и типизация неправильна

Минусы:

• Скрывает все ошибки на этой строке
• Трудно найти потом в больших проектах
• Не документирует причину отключения

2. Директива @ts-expect-error

Лучше чем @ts-ignore — гарантирует, что ошибка существует

// Это правильный способ, если ошибка действительно есть
// @ts-expect-error
const value: number = "123";

// Если ты удалишь неправильное присваивание и ошибки больше не будет,
// TypeScript сразу скажет: "Expected an error but found none"

Преимущества:

• Гарантирует, что здесь реальная ошибка типа
• Будет ошибка, если ты потом исправишь код и забудешь удалить @ts-expect-error
• Более явное намерение

Пример с комментарием:

// API возвращает данные в неправильном формате
// @ts-expect-error Backend отправляет string вместо number
const userId: number = JSON.parse(response).id;

3. Type casting with as

Явное приведение типов

// Ошибка без приведения
const value = "123";
const num: number = value; // Ошибка

// Решение: использовать as
const num: number = value as unknown as number; // Компилируется

// Или более безопасно
const num: number = parseInt(value, 10); // Правильно

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

• Ты знаешь тип лучше, чем TypeScript
• Работа с DOM API
• Работа с JSON из API

Пример:

// DOM API возвращает Element | null
const button = document.querySelector(".btn") as HTMLButtonElement;
button.addEventListener("click", () => {
  console.log("clicked");
});

// Или с проверкой типа (более безопасно)
const button = document.querySelector(".btn");
if (button instanceof HTMLButtonElement) {
  button.addEventListener("click", () => {});
}

4. Отключение строгой типизации в tsconfig.json

Глобально ослабить правила

{
  "compilerOptions": {
    "strict": false,
    
    "noImplicitAny": false,
    "strictNullChecks": false,
    "strictFunctionTypes": false,
    "strictBindCallApply": false,
    "strictPropertyInitialization": false,
    "noImplicitThis": false
  }
}

Минусы этого подхода:

• Теряешь все преимущества типизации
• Трудно потом вернуть strict режим
• Рекомендуется использовать только для миграции старых проектов

5. Использование any (осторожно!)

Полное отключение проверок для переменной

// Полный any — избегай этого
let value: any = "123";
value.toFixed(2); // Нет ошибки, хотя это неправильно!

// Лучше: any только где нужно
function processUnknown(data: any) {
  // Рискованно, но иногда необходимо
  return data.someMethod();
}

// Еще лучше: использовать unknown
function processUnknown(data: unknown) {
  if (typeof data === "object" && data !== null && "someMethod" in data) {
    return (data as any).someMethod();
  }
}

6. Безопасный Type Guard вместо as

Правильный способ вместо неоправданного as

// Неправильно: слепо приводим тип
function processValue(value: unknown) {
  return (value as number).toFixed(2); // Может быть ошибка в runtime
}

// Правильно: проверяем тип
function processValue(value: unknown) {
  if (typeof value === "number") {
    return value.toFixed(2);
  }
  throw new Error("Expected a number");
}

// Или с type predicate
function isNumber(value: unknown): value is number {
  return typeof value === "number";
}

function processValue(value: unknown) {
  if (isNumber(value)) {
    return value.toFixed(2);
  }
}

7. Eslint-disable для отключения проверок

Если используешь eslint-plugin-typescript

// Отключить одну строку
// eslint-disable-next-line @typescript-eslint/no-explicit-any
const value: any = someUnknownFunction();

// Отключить блок
/* eslint-disable @typescript-eslint/no-unused-vars */
const unusedVariable = 123;
/* eslint-enable @typescript-eslint/no-unused-vars */

// Отключить файл
/* eslint-disable @typescript-eslint/no-explicit-any */

8. Использование lib types для внешних библиотек

Если библиотека плохо типизирована, создай свою типизацию

// types/my-library.d.ts
declare module "my-library" {
  export function foo(): string;
  export function bar(x: number): void;
}

// Теперь foo и bar имеют правильные типы
import { foo, bar } from "my-library";
foo(); // string, как ожидается

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

Пример 1: Работа с API ответом

// Ответ API плохо типизирован
const response: any = await fetch("/api/user").then(r => r.json());

// Правильно: создай интерфейс и используй type guard
interface User {
  id: number;
  name: string;
}

function isUser(obj: unknown): obj is User {
  return (
    typeof obj === "object" &&
    obj !== null &&
    typeof (obj as any).id === "number" &&
    typeof (obj as any).name === "string"
  );
}

const response = await fetch("/api/user").then(r => r.json());

if (isUser(response)) {
  console.log(response.name); // Safe
} else {
  throw new Error("Invalid user data");
}

Пример 2: Миграция старого кода

// Временно отключи strict режим в tsconfig.json
{
  "compilerOptions": {
    "strict": false
  }
}

// Затем постепенно включай для файлов
{
  "include": ["src/**/*"],
  "exclude": ["src/legacy/**/*"]
}

// Когда миграция завершена, включи strict обратно

Пример 3: React с DOM

// Правильный способ
const inputRef = useRef<HTMLInputElement>(null);

function handleInput() {
  if (inputRef.current) {
    console.log(inputRef.current.value);
  }
}

// Или с type assertion
function handleInput() {
  const input = inputRef.current as HTMLInputElement;
  console.log(input.value);
}

Рекомендации

ИЗБЕГАЙ:

• any везде
• as unknown as Type без причины
• Отключение strict для всего проекта
• @ts-ignore без комментария

ИСПОЛЬЗУЙ:

• @ts-expect-error с объяснением
• Type guards и type predicates
• unknown вместо any
• Создание .d.ts файлов для плохо типизированных библиотек
• Постепенное включение strict режима

Заключение

Строгая типизация в TypeScript — это не враг, а защита. Перед тем как отключать её, спроси себя: "Есть ли способ сделать это типобезопасно?" В 95% случаев ответ "да". Исключения — работа с плохо типизированными библиотеками, миграция старого кода и DOM API. В этих случаях используй @ts-expect-error или type guards вместо глобального отключения типизации.