Будет ли TypeScript строгой проверкой типизации?

Будет ли TypeScript строгой проверкой типизации

Это хороший вопрос, который показывает понимание TypeScript. Ответ: это зависит от конфигурации, но рекомендуется использовать полную строгую типизацию.

Что такое строгая типизация в TypeScript

ТипСкрипт имеет опции компилятора, которые контролируют уровень строгости проверки типов. Главная опция - это strict mode.

Опции типизации

1. strict: true (полная строгость)

{
  "compilerOptions": {
    "strict": true
  }
}

Когда strict: true, это включает все строгие проверки:

// strict: true
let x: any; // ошибка! any не разрешен в strict mode
let y; // ошибка! нет типа

function greet(name: string) {
  console.log(name.toUpperCase()); // ok
}

const obj: any = {}; // ошибка! any не разрешен

2. strict: false (слабая типизация)

{
  "compilerOptions": {
    "strict": false
  }
}

// strict: false
let x: any; // ok
let y; // ok - тип any

function greet(name) { // ok - тип any
  console.log(name.toUpperCase()); // ok, но может упасть
}

Что входит в strict mode

Когда ты ставишь strict: true, это включает несколько опций:

{
  "compilerOptions": {
    "strict": true,
    // Это эквивалентно:
    "noImplicitAny": true,
    "noImplicitThis": true,
    "alwaysStrict": true,
    "strictBindCallApply": true,
    "strictFunctionTypes": true,
    "strictNullChecks": true,
    "strictPropertyInitialization": true,
    "useUnknownInCatchVariables": true
  }
}

1. noImplicitAny

// noImplicitAny: true
function greet(name) { // ошибка! параметр name имеет тип any
  console.log(name);
}

// Исправление
function greet(name: string) {
  console.log(name);
}

// Или явно any, если нужно
function greet(name: any) {
  console.log(name);
}

2. strictNullChecks

// strictNullChecks: true
let name: string;
name = null; // ошибка! null не может быть присвоен string

// Исправление 1: позволить null
let name: string | null;
name = null; // ok

// Исправление 2: проверить перед использованием
let name: string;
if (name !== null && name !== undefined) {
  console.log(name.toUpperCase());
}

// Или использовать optional chaining
console.log(name?.toUpperCase()); // безопасно

3. strictPropertyInitialization

// strictPropertyInitialization: true
class User {
  name: string; // ошибка! свойство не инициализировано
  
  constructor() {
    // name не установлен
  }
}

// Исправления
class User {
  // Вариант 1: инициализация
  name: string = "";
  
  // Вариант 2: в конструкторе
  constructor() {
    this.name = "";
  }
  
  // Вариант 3: optional
  name?: string;
  
  // Вариант 4: definite assignment (не рекомендуется)
  name!: string;
}

4. strictFunctionTypes

// strictFunctionTypes: true
type Callback = (x: number | string) => void;

const callback: Callback = (x: number) => { // ошибка!
  // Здесь функция принимает только number
  // Но она может быть вызвана со string
};

// Исправление
const callback: Callback = (x: number | string) => {
  console.log(x);
};

Реальный пример: API ответ

// strict: false (небезопасно)
function handleResponse(data) { // any
  // data может быть чем угодно
  console.log(data.name); // может упасть!
  console.log(data.age.toFixed(2)); // может упасть!
}

fetch('/api/user')
  .then(r => r.json())
  .then(handleResponse);

// strict: true (безопасно)
interface User {
  name: string;
  age: number;
}

function handleResponse(data: User) {
  // TypeScript знает структуру
  console.log(data.name); // ok
  console.log(data.age.toFixed(2)); // ok
}

fetch('/api/user')
  .then(r => r.json())
  .then(data => handleResponse(data as User));

Пример: null проверка

// strictNullChecks: true
interface User {
  profile?: {
    name?: string;
  };
}

const user: User | null = null;

// Без проверки - ошибка!
console.log(user.profile.name); // ошибка!

// С проверкой - ok
if (user && user.profile && user.profile.name) {
  console.log(user.profile.name);
}

// Или с optional chaining
console.log(user?.profile?.name); // ok, вернет undefined

// Или с nullish coalescing
console.log(user?.profile?.name ?? 'Unknown');

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

Рекомендуемая конфигурация (максимальная строгость)

{
  "compilerOptions": {
    "target": "ES2020",
    "module": "ESNext",
    "lib": ["ES2020"],
    
    // Строгая типизация
    "strict": true,
    "noUnusedLocals": true,
    "noUnusedParameters": true,
    "noImplicitReturns": true,
    "noFallthroughCasesInSwitch": true,
    "noUncheckedIndexedAccess": true,
    "noPropertyAccessFromIndexSignature": true,
    
    // Модули
    "moduleResolution": "node",
    "esModuleInterop": true,
    "allowSyntheticDefaultImports": true,
    
    // Выходной файл
    "outDir": "./dist",
    "rootDir": "./src",
    "declaration": true,
    "declarationMap": true,
    "sourceMap": true
  },
  "include": ["src/**/*"],
  "exclude": ["node_modules", "dist"]
}

Миграция с нестрогой типизации

// Шаг 1: Включить strict mode постепенно
{
  "compilerOptions": {
    "strict": false,
    "noImplicitAny": true // начни с этого
  }
}

// Шаг 2: Фиксить ошибки
// Шаг 3: Включить следующую опцию
{
  "compilerOptions": {
    "strict": false,
    "noImplicitAny": true,
    "strictNullChecks": true // теперь и это
  }
}

// Шаг 4: Повторить для всех опций
// Шаг 5: Включить полный strict mode
{
  "compilerOptions": {
    "strict": true
  }
}

Когда strict: false оправдан

Редко, но есть случаи:

1. Миграция большого проекта - постепенный переход
2. Работа с плохо типизированными библиотеками - требует @ts-ignore
3. Прототипирование - быстрое тестирование идей

НО для production проектов всегда используй strict: true.

Примеры ошибок в strict mode

// Ошибка 1: неопределенный тип
let x; // error: TS7006 Variable 'x' implicitly has an 'any' type

// Ошибка 2: null это не string
let name: string = null; // error: TS2322 Type 'null' is not assignable to type 'string'

// Ошибка 3: свойство может быть undefined
const user = { name: 'John' };
console.log(user.profile.name); // error: TS2339 Property 'profile' does not exist

// Ошибка 4: неинициализированное свойство
class User {
  name: string; // error: TS2564 Property has no initializer
}

// Ошибка 5: неиспользуемый параметр
function greet(name: string, age: number) { // error: age is unused
  console.log(name);
}

Вывод

Да, TypeScript должен быть с строгой типизацией (strict: true). Это означает:

1. Максимальная безопасность - ловишь ошибки на этапе разработки
2. Лучше документация - типы служат документацией
3. Проще рефакторинг - TypeScript скажет что сломалось
4. Меньше runtime ошибок - большинство проблем найдены до production

Для новых проектов используй strict: true с самого начала. Для старых проектов постепенно включай опции строгости и фиксь ошибки.

Best practice: strict: true is not optional, it's mandatory for production code.