Что такое strictNullChecks?

Что такое strictNullChecks?

strictNullChecks — это строгий режим проверки null- и undefined-Baillue в TypeScript. При включении этой опции в tsconfig.json, компилятор начинает требовать явной обработки потенциальных значений null и undefined, что значительно повышает безопасность типов и помогает избежать классических ошибок во время выполнения, таких как Cannot read property 'x' of null.

Без strictNullChecks TypeScript считает, что null и undefined являются допустимыми значениями для любого типа (как в классическом JavaScript). Это означает, что следующий код будет компилироваться без ошибок, но приведёт к ошибке во время выполнения:

// Без strictNullChecks
let name: string = null;
console.log(name.toUpperCase()); // Ошибка времени выполнения: Cannot read properties of null

С включённым strictNullChecks, null и undefined становятся отдельными типами, не присваиваемыми другим типам без явного указания. Переменная типа string теперь может содержать только строки, а не null или undefined.

Как работает strictNullChecks?

Базовый пример

// С strictNullChecks
let name: string = "Alice"; // OK
let nullableName: string | null = null; // OK, явно указан объединённый тип
let name2: string = null; // Ошибка компиляции: Type 'null' is not assignable to type 'string'

Обработка optional-параметров и свойств

strictNullChecks также меняет поведение с необязательными параметрами и свойствами:

interface User {
    id: number;
    name?: string; // name: string | undefined
}

function greet(user: User) {
    console.log(user.name.toUpperCase()); // Ошибка: Object is possibly 'undefined'
}

Почему это важно?

Преимущества использования:

• Предотвращение ошибок времени выполнения — самые частые ошибки в JavaScript связаны с доступом к свойствам null/undefined
• Улучшение документирования кода — явные типы string | null четко показывают, где могут быть отсутствующие значения
• Более точное моделирование данных — реальные API часто возвращают null для отсутствующих значений
• Лучшая поддержка современных паттернов — совместимость с optional chaining и nullish coalescing

Практические подходы при включённом strictNullChecks:

1. Явное указание объединённых типов

type Response = {
    data: string | null;
    error: string | null;
};

2. Использование optional chaining (?.)

const user = { profile: { name: "John" } };
const userName = user?.profile?.name; // string | undefined

3. Применение nullish coalescing (??)

const value = input ?? "default"; // Использует default только при null/undefined

4. Тип-гарды и проверки

function process(input: string | null) {
    if (input !== null) {
        // Здесь TypeScript знает, что input: string
        console.log(input.toUpperCase());
    }
}

5. Использование типа NonNullable<T>

type NonNullUser = NonNullable<User | null>; // Получаем просто User

Настройка в проекте

Чтобы включить strictNullChecks, добавьте в tsconfig.json:

{
    "compilerOptions": {
        "strictNullChecks": true
    }
}

Или включите всё семейство strict-опций:

{
    "compilerOptions": {
        "strict": true // Включает strictNullChecks и другие strict:
    }
}

Миграция существующего кода

При включении strictNullChecks в существующем проекте вы столкнётесь с множеством ошибок компиляции. Рекомендуемый подход:

1. Включите постепенно — используйте // @ts-ignore для временного подавления ошибок
2. Добавляйте явные проверки — везде, где возможны null/undefined
3. Рассмотрите использование strictNullChecks только для новых файлов через // @ts-strict

Заключение

strictNullChecks — это важнейшая опция TypeScript, превращающая его из "JavaScript с типами" в действительно статически типизированный язык. Хотя первоначальное включение требует усилий, долгосрочные преимущества в виде снижения количества ошибок, улучшения читаемости кода и более точного моделирования предметной области полностью окупают эти затраты. В современных TypeScript-проектах рекомендуется всегда включать strictNullChecks (обычно через strict: true), так как это соответствует лучшим практикам разработки надёжного программного обеспечения.