Что такое Never?

Тип Never в TypeScript

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

Основные характеристики Never

• Невозможность иметь значение: Переменная типа never не может иметь ни одного значения.
• Подтип всех типов: never является подтипом всех типов в системе, но никакой тип не является подтипом never (кроме самого never).
• Нельзя присвоить: Значение типа never нельзя присвоить никакой другой переменной, кроме как типа never.

Основные случаи использования

1. Функции, которые всегда выбрасывают исключение

Функции, которые завершаются выбросом ошибки или работают бесконечно, возвращают never.

function throwError(message: string): never {
    throw new Error(message);
}

function infiniteLoop(): never {
    while (true) {
        // Бесконечный цикл
    }
}

2. Функции с exhaustive checks (исчерпывающей проверкой)

Never особенно полезен при работе с discriminated unions (размеченные объединения) для обеспечения безопасности типов.

type Shape = 
    | { kind: 'circle'; radius: number }
    | { kind: 'square'; side: number }
    | { kind: 'triangle'; base: number; height: number };

function getArea(shape: Shape): number {
    switch (shape.kind) {
        case 'circle':
            return Math.PI * shape.radius ** 2;
        case 'square':
            return shape.side ** 2;
        case 'triangle':
            return 0.5 * shape.base * shape.height;
        default:
            // Здесь shape имеет тип never
            // Это гарантирует, что мы обработали все случаи
            const exhaustiveCheck: never = shape;
            throw new Error(`Необработанный тип: ${exhaustiveCheck}`);
    }
}

3. Обработка ситуаций, которые никогда не должны произойти

type Status = 'success' | 'error';

function handleStatus(status: Status): string {
    if (status === 'success') {
        return 'Успешно';
    } else if (status === 'error') {
        return 'Ошибка';
    } else {
        // TypeScript знает, что сюда нельзя попасть
        const unexpectedStatus: never = status;
        return unexpectedStatus; // Ошибка компиляции
    }
}

Различия между never, void и unknown

• void: Функция возвращает undefined или ничего не возвращает.
• never: Функция никогда не возвращает управление.
• unknown: Тип для значений, о которых мы ничего не знаем.

// void - возвращает undefined
function logMessage(): void {
    console.log('Сообщение');
    // Неявно возвращает undefined
}

// never - никогда не возвращает управление
function crashApp(): never {
    throw new Error('Крах!');
}

// unknown - может быть чем угодно
let userInput: unknown;

Практическое применение

Гарантия полноты проверки в Redux-редьюсерах

type Action = 
    | { type: 'INCREMENT' }
    | { type: 'DECREMENT' }
    | { type: 'RESET' };

function reducer(state: number, action: Action): number {
    switch (action.type) {
        case 'INCREMENT':
            return state + 1;
        case 'DECREMENT':
            return state - 1;
        case 'RESET':
            return 0;
        default:
            // Если мы добавим новый action type и забудем обработать его,
            // TypeScript выдаст ошибку на этой строке
            const exhaustiveAction: never = action;
            return state;
    }
}

Защита от непредвиденных ситуаций

function assertNever(value: never): never {
    throw new Error(`Непредвиденное значение: ${value}`);
}

type Direction = 'up' | 'down' | 'left' | 'right';

function move(direction: Direction): void {
    switch (direction) {
        case 'up': console.log('Вверх'); break;
        case 'down': console.log('Вниз'); break;
        case 'left': console.log('Влево'); break;
        case 'right': console.log('Вправо'); break;
        default: assertNever(direction); // Защита на будущее
    }
}

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

1. Безопасность типов: Помогает выявлять ошибки на этапе компиляции.
2. Само-документирование кода: Четко указывает на намерения разработчика.
3. Поддержка рефакторинга: При изменении типов TypeScript автоматически укажет на места, требующие обновления.
4. Исчерпывающая проверка: Гарантирует обработку всех возможных случаев в объединениях типов.

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