Подробное руководство по обработке нулевых и неопределенных значений в TypeScript с использованием AssertNonNullish и Nullish Coalescing для обеспечения безопасности типов.
В TypeScript понятия nullish, не nullish и assertNonNullish связаны с обработкой значений null и undefined. Эти концепции помогают писать более надежный и типобезопасный код, предоставляя явные способы обработки значений, допускающих значение NULL.
К концу этого поста вы получите четкое представление об этих концепциях и обнаружите явные методы эффективной обработки значений, допускающих значение NULL.
нулевой
В TypeScript термин нулевой относится к значениям, равным null или undefined. Эти значения представляют отсутствие значения.
По умолчанию переменные обнуляются (это означает, что они могут содержать эти нулевые значения), если вы явно не укажете их как не обнуляемые с помощью аннотаций типа или параметр компилятора strictNullChecks.
Параметр компилятора strictNullChecks применяет строгие проверки нулей, что означает, что вы получите ошибки времени компиляции, если попытаетесь присвоить значение null или undefined переменной, которая явно помечена как необнуляемый.
Чтобы включить проверку строгого нуля, либо передайте флаг --strictNullChecks при вызове компилятора TypeScript через командную строку:tsc --strictNullChecks yourfile.ts
Или настроить прямо в tsconfig файле:
{
"compilerOptions": {
"strictNullChecks": true
}
}
Ненулевой
Термин «ненулевой» противоположен термину «нулевой». Он относится к значениям, отличным от null или undefined, другими словами, к значениям, которые существуют и имеют определенное состояние.
Когда переменная объявляется с ненулевым типом (когда вы указываете тип для переменной, которая не допускает значение NULL), TypeScript гарантирует, что ей никогда не будет присвоено значение null или undefined.
Вот пример, когда ненулевая проверка может быть полезна:
function greetUser(name?: string): void {
const userName = name ?? "Guest";
console.log(`Hello, ${userName}!`);
}
greetUser(); // Output: Hello, Guest!
greetUser("John"); // Output: Hello, John!
В этом примере у нас есть функция greetUser, которая принимает необязательный параметр name (используя символ ?), который представляет имя приветствуемого пользователя. Внутри функции мы используем нулевой оператор объединения (??), чтобы проверить, является ли параметр name нулевым.
Нулевой оператор объединения возвращает правое значение выражения, если левое значение равно null или undefined. Во всех других ложных случаях, таких как 0, пустые строки или false, вместо значения по умолчанию возвращается значение переменной.
Здесь переменная userName всегда будет иметь ненулевое значение. Используя ??, мы предоставляем резервное значение («Гость»), когда параметр имени имеет нулевое значение, гарантируя отображение правильного приветственного сообщения. Это предотвращает любые потенциальные проблемы или ошибки, которые могут возникнуть, если мы напрямую используем нулевое значение.
AssertNonNullish
assertNonNullish — это не встроенная конструкция TypeScript, а скорее концепция, представляющая метод, гарантирующий, что значение не является нулевым. Это способ сообщить компилятору TypeScript, что переменная будет иметь ненулевое значение в определенной точке кода, даже если ее тип предполагает обратное.
Один из распространенных способов подтвердить ненулевое значение — использовать оператор ! (восклицательный знак), также известный как оператор ненулевого утверждения. Когда вы добавляете ! к переменной или свойству, вы, по сути, сообщаете TypeScript, что знаете лучше, чем компилятор (способ временно переопределить strictNullChecks), и что значение не будет null или undefined в этой конкретной точке кода.
Вот реальный пример, где может быть полезен ненулевой оператор утверждения (!):
interface User {
id: number;
name: string;
email: string | null;
}
function sendEmailToUser(user: User): void {
// Ensure user email is non-null before sending email
const userEmail = user.email!;
if (userEmail !== null) {
// Sending email logic...
console.log(`Sending email to ${user.name} at ${userEmail}`);
} else {
// Handle the case where the email address is missing
console.log(`Cannot send email to ${user.name}. Email address is missing.`);
}
}
const userWithValidEmail: User = {
id: 1,
name: "John Doe",
email: "[email protected]",
};
const userWithMissingEmail: User = {
id: 2,
name: "Jane Smith",
email: null,
};
sendEmailToUser(userWithValidEmail); // Sending email to John Doe at [email protected]
sendEmailToUser(userWithMissingEmail); // Cannot send email to Jane Smith. Email address is missing.
Обязательно используйте оператор ! с осторожностью и только тогда, когда вы абсолютно уверены, что значение не будет null или undefined. Неправильное использование может привести к ошибкам времени выполнения, если утверждение неверно.
В приведенном выше примере, используя ненулевое утверждение, мы сообщаем компилятору TypeScript, что мы уверены, что user.email не будет null в этой конкретной точке кода. Тем не менее, как показано, по-прежнему важно выполнять надлежащие проверки нулевых значений, чтобы корректно обрабатывать неожиданные нулевые значения.
Резюме
Понятия nullish, non-nullish и assertNonNullish присущи TypeScript и могут использоваться без какой-либо дополнительной настройки. Включение strictNullChecks рекомендуется для перехвата ошибок null и undefined во время компиляции.
Мы обсудили технику assertNonNullish с использованием оператора !, который помогает обойти строгие проверки null в определенных ситуациях. Кроме того, мы изучили нулевой оператор объединения (??), который позволяет плавно переходить к значениям по умолчанию в выражениях, делая ваш код более понятным и более надежным.
Я надеюсь, что вы нашли этот пост полезным. ✨
Следите за новостями! Если вы впервые здесь, не стесняйтесь изучать другие мои статьи и рассмотрите возможность подписаться на меня для будущих обновлений и более ценных идей.
Дополнительные материалы на PlainEnglish.io.
Подпишитесь на нашу бесплатную еженедельную рассылку новостей. Подпишитесь на нас в Twitter, LinkedIn, YouTube и Discord .
