Как относишься к as в коде?

Избегать Type Assertion в большинстве случаев

В TypeScript есть оператор as для принудительного приведения типов (type assertion). Я считаю, что as нужно использовать с осторожностью, так как это обходит систему типов.

Почему as опасен

// ПЛОХО: Использование as без необходимости
const user = {
  name: "Alice"
} as any;
user.age = 25;  // TypeScript пропустит эту ошибку

// или

const data = '{"id": 1}' as any;
const id = data.id.toUpperCase();  // Ошибка в runtime!
// JSON.parse может вернуть { id: 1 }, где id число

// Или ещё хуже:
const element = document.querySelector('div') as HTMLDivElement;
element.innerText;  // Если элемента нет, будет null!

Правильное использование Type Guards

// ПЛОХО: Type Assertion
function processUser(data: unknown) {
  const user = data as User;
  console.log(user.name);
}

// ХОРОШО: Type Guard
function isUser(obj: unknown): obj is User {
  return (
    typeof obj === 'object' &&
    obj !== null &&
    'name' in obj &&
    typeof obj.name === 'string' &&
    'email' in obj &&
    typeof obj.email === 'string'
  );
}

function processUser(data: unknown) {
  if (isUser(data)) {
    console.log(data.name);  // TypeScript знает, что это User
  }
}

Type Narrowing вместо as

// ПЛОХО: as any
function handleEvent(event: Event) {
  const input = event.target as HTMLInputElement;
  console.log(input.value);
}

// ХОРОШО: Проверяем тип перед использованием
function handleEvent(event: Event) {
  if (event.target instanceof HTMLInputElement) {
    console.log(event.target.value);
  }
}

// ИЛИ: Type Guard
function isInput(el: unknown): el is HTMLInputElement {
  return el instanceof HTMLInputElement;
}

function handleEvent(event: Event) {
  if (isInput(event.target)) {
    console.log(event.target.value);
  }
}

Когда as приемлем

Есть редкие случаи, когда as оправдан:

// OK: Когда ты 100% уверен в типе и TypeScript не может это понять
const canvas = document.getElementById('my-canvas') as HTMLCanvasElement;
// TypeScript не знает, что getElementById вернёт именно canvas

// OK: При работе с const assertion
const config = {
  theme: 'dark',
  language: 'en'
} as const;  // Узкий тип вместо string

// OK: В тестах
const mockUser = {
  id: '1',
  name: 'Test'
} as User;  // Когда мокируем и уверены в структуре

Лучше использовать Generics

// ПЛОХО: Type Assertion
function getProperty(obj: any, key: string) {
  return obj[key] as string;
}

// ХОРОШО: Generics
function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
  return obj[key];
}

const user = { name: "Alice", age: 30 };
const name = getProperty(user, 'name');  // string
const age = getProperty(user, 'age');    // number

Типизировать при fetch

// ПЛОХО: as User после fetch
async function getUser(id: string) {
  const response = await fetch(`/api/users/${id}`);
  return response.json() as User;  // Не проверяем реальный тип!
}

// ХОРОШО: Runtime валидация
import { z } from 'zod';

const UserSchema = z.object({
  id: z.string(),
  name: z.string(),
  email: z.string().email()
});

type User = z.infer<typeof UserSchema>;

async function getUser(id: string): Promise<User> {
  const response = await fetch(`/api/users/${id}`);
  const data = await response.json();
  return UserSchema.parse(data);  // Выбросит ошибку если структура неверна
}

Правило большого пальца

// ЗАПРЕТИТЬ ВСЕ as any
const x = something as any;  // Никогда!

// ИЗБЕГАТЬ
const y = data as User;  // Опасно без проверки

// ДОПУСТИТЬ
const z = document.getElementById('x') as HTMLDivElement;
const config = { a: 1 } as const;  // const assertion

ESLint правило

{
  "rules": {
    "@typescript-eslint/no-explicit-any": "error",
    "@typescript-eslint/no-unsafe-type-assertion": "warn",
    "@typescript-eslint/no-unnecessary-type-assertion": "error"
  }
}

Мой подход: использую as только когда это действительно необходимо и я 100% уверен в типе. Предпочитаю type guards, narrowing и валидацию.