Як перевірити, що блок перемикачів є вичерпним у TypeScript?


98

У мене є код:

enum Color {
    Red,
    Green,
    Blue
}

function getColorName(c: Color): string {
    switch(c) {
        case Color.Red:
            return 'red';
        case Color.Green:
            return 'green';
        // Forgot about Blue
    }

    throw new Error('Did not expect to be here');
}

Я забув розглянути Color.Blueсправу, і вважаю за краще отримати помилку компіляції. Як я можу структурувати свій код таким чином, щоб TypeScript позначив це як помилку?


1
Просто хотів повідомити людей, що двоканальне рішення від @Carlos Gines, якщо ви прокрутите вниз досить далеко.
— Ноуменон

Відповіді:


122

Для цього ми використаємо neverтип (представлений у TypeScript 2.0), який представляє значення, які "не повинні" відбуватися.

Першим кроком є ​​написання функції:

function assertUnreachable(x: never): never {
    throw new Error("Didn't expect to get here");
}

Потім використовуйте його у defaultфутлярі (або еквівалентно, поза перемикачем):

function getColorName(c: Color): string {
    switch(c) {
        case Color.Red:
            return 'red';
        case Color.Green:
            return 'green';
    }
    return assertUnreachable(c);
}

На цьому етапі ви побачите помилку:

return assertUnreachable(c);
       ~~~~~~~~~~~~~~~~~~~~~
       Type "Color.Blue" is not assignable to type "never"

Повідомлення про помилку вказує випадки, які ви забули включити у свій вичерпний перемикач! Якщо ви зупинили кілька значень, ви побачите помилку, наприклад Color.Blue | Color.Yellow.

Зверніть увагу, що якщо ви використовуєте strictNullChecks, це вам знадобиться returnперед assertUnreachableдзвінком (інакше це необов’язково).

Ви можете отримати трохи фантазії, якщо хочете. Наприклад, якщо ви використовуєте дискримінований союз, може бути корисно відновити дискримінантне властивість у функції твердження для налагодження. Це виглядає так:

// Discriminated union using string literals
interface Dog {
    species: "canine";
    woof: string;
}
interface Cat {
    species: "feline";
    meow: string;
}
interface Fish {
    species: "pisces";
    meow: string;
}
type Pet = Dog | Cat | Fish;

// Externally-visible signature
function throwBadPet(p: never): never;
// Implementation signature
function throwBadPet(p: Pet) {
    throw new Error('Unknown pet kind: ' + p.species);
}

function meetPet(p: Pet) {
    switch(p.species) {
        case "canine":
            console.log("Who's a good boy? " + p.woof);
            break;
        case "feline":
            console.log("Pretty kitty: " + p.meow);
            break;
        default:
            // Argument of type 'Fish' not assignable to 'never'
            throwBadPet(p);
    }
}

Це приємний зразок, оскільки ви отримуєте безпеку під час компіляції, щоб переконатися, що вирішили всі випадки, які ви очікували. І якщо ви отримаєте справді властивість, яка не входить в область дії (наприклад, якийсь абонент JS створив нового species), ви можете надіслати корисне повідомлення про помилку.


3
Якщо strictNullChecksвключено, чи недостатньо визначити тип повернення функції як, взагалі stringне потребуючи assertUnreachableфункції?
— dbandstra

1
@dbandstra Ви, звичайно, можете це зробити, але як загальний шаблон шаблон assertUnreachable є більш надійним. Він працює навіть без, strictNullChecksа також продовжує працювати, якщо є умови, коли ви хочете повернутися невизначеним ззовні перемикача.
— Летаріон

Здається, це не працює, коли перелік визначається у зовнішньому файлі d.ts. Принаймні, я не можу змусити його працювати з переліченням Office.MailboxEnums.RecipientType з API надбудови Microsofts Office JS.
— Søren Boisen

наведене вище рішення працює для базового прикладу в оригінальному описі, однак я не впевнений, що це загальноприйнятий шаблон. Поміняйте перелік кольорів на, type InDiscriminant = { a: string } | { b: string }і як можна діяти далі? Простий перемикач більше не знає всіх жорстких значень, і серед типів членів об’єднання немає загальних властивостей, які можна розрізнити. Чи існує ідіоматичне рішення для цієї справи?
— cdaringe

noUnusedParameterstsconfig, встановлений, видасть помилку "x ніколи не використовується", яку ви можете виправити, function assertUnreachable(_x: never): never { throw new Error("Didn't expect to get here"); }
— поставивши

34

Вам не потрібно використовувати neverабо додавати що-небудь до кінця вашого switch.

Якщо

  • Ваше switchтвердження повертається в кожному випадку
  • У вас strictNullChecksувімкнено прапор компіляції машинопису
  • Ваша функція має вказаний тип повернення
  • Тип повернення не є undefinedабоvoid

Ви отримаєте повідомлення про помилку, якщо ваша switchзаява не є вичерпною, оскільки буде випадок, коли нічого не буде повернуто.

З вашого прикладу, якщо ви це робите

function getColorName(c: Color): string {
    switch(c) {
        case Color.Red:
            return 'red';
        case Color.Green:
            return 'green';
        // Forgot about Blue
    }
}

Ви отримаєте таку помилку компіляції:

Функція не має закінчуваного оператора return, а тип повернення не включає undefined.


Це рішення вимагає явного вказівки всіх можливих повернутих значень функції. В інших випадках ми можемо їх опустити і дозволити компілятору робити висновки про тип.
— Олексій

так, компілятор скаржиться, але ви також повинні врахувати, що ви все одно можете отримати неправильне значення під час виконання. У такому випадку я віддаю перевагу
— надсилати

6
Ідея полягає не в поверненні undefined, а в створенні відсутньої гілки виписки справи. Таким чином, ви не отримаєте помилку під час виконання, і не потрібно нічого кидати.
— Марсело Лазароні,

3
Код працює точно так, як описано. Якщо ви ігноруєте тип і вважаєте, що це cможе бути що завгодно, немає жодної причини використовувати TypeScript взагалі. Якщо це значення cможе бути нульовим або невизначеним, тип повинен це сказати, а реалізація це буде враховувати.
— Марсело Лазароні

1
Це рішення працює, щоб викликати помилку машинопису, але помилка не завжди ясна. Я вважаю за краще використовувати defaultрегістр із невикористовуваною змінною, як neverіз поясненням коментаря "hey bud, if you're getting an error here, you forgot to add a case". YMMV.
— Маттіас,

21

Рішення

Що я роблю, це визначаю клас помилки:

export class UnreachableCaseError extends Error {
  constructor(val: never) {
    super(`Unreachable case: ${JSON.stringify(val)}`);
  }
}

а потім викиньте цю помилку у випадку за замовчуванням:

enum Color {
    Red,
    Green,
    Blue
}

function getColorName(c: Color): string {
  switch(c) {
      case Color.Red:
          return 'red, red wine';
      case Color.Green:
          return 'greenday';
      case Color.Blue:
          return "Im blue, daba dee daba";
      default:
          // Argument of type 'c' not assignable to 'never'
          throw new UnreachableCaseError(c);
  }
}

Я думаю, це легше читати, ніж функціональний підхід, рекомендований Райаном, оскільки в throwпункті є підсвічування синтаксису за замовчуванням.

Підказка

Бібліотека ts-essentials має клас UnreachableCaseError саме для цього випадку використання

Міркування про час роботи

Зверніть увагу, що код машинопису переводиться в javascript: Отже, всі перевірки набору тексту на машинці працюють лише під час компіляції і не існують під час виконання: тобто немає гарантії, що змінна cсправді має тип Color.
Це відрізняється від інших мов: наприклад, Java також перевірятиме типи під час виконання і видаватиме значущу помилку, якщо ви спробуєте викликати функцію з аргументом неправильного типу - але javascript цього не робить.

Це причина, чому важливо викинути значущий виняток у defaultвипадку: Stackblitz: викинути значущу помилку

Якщо ви цього не зробите, функція getColorName()неявно повертається undefined(при виклику з несподіваним аргументом): Stackblitz: повертає будь

У наведених вище прикладах ми безпосередньо використовували змінну типу anyдля ілюстрації проблеми. Сподіваємось, цього не відбудеться в реальних проектах - але є багато інших способів, за допомогою яких ви можете отримати змінну неправильного типу під час виконання.
Ось декілька, що я вже бачив (і я сам зробив деякі з цих помилок):

  • за допомогою кутових форм - вони не є безпечними для типу: усі значення поля форми мають тип any
    ng-форми Приклад Stackblitz
  • допускається неявний будь-який
  • зовнішнє значення використовується і не перевіряється (наприклад, http-відповідь сервера просто передається на інтерфейс)
  • ми зчитуємо значення з локального сховища, яке написала старіша версія програми (ці значення змінилися, тому нова логіка не розуміє старого значення)
  • ми використовуємо деякі сторонні бібліотеки, які не є безпечними для типу (або просто мають помилку)

Тож не полінуйтеся і напишіть цей додатковий випадок за замовчуванням - це може запобігти вам чимало головних болів ...


зауважте, що наразі ви не можете використовувати instanceofперевірки для підкласів Error: див. випуск # 13965, в якому також згадується обхідний шлях
— TmTron

Я перевірив, і зараз він працює правильно. TypeScript 3.5.1.
— Олексій

1
Оооо, це прекрасно, і майже так само, як я писав би код, якби я писав простою JS.
— Піт

Як компілятор знаходить це?
— jocull

@jocull не впевнений, про що ти просиш. Можливо, ви хочете прочитати про дискриміновані спілки ?
— TmTron

18

Спираючись на відповідь Райана, я виявив тут, що немає потреби в додаткових функціях. Ми можемо зробити безпосередньо:

function getColorName(c: Color): string {
  switch (c) {
    case Color.Red:
      return "red";
    case Color.Green:
      return "green";
    // Forgot about Blue
    default:
      const _exhaustiveCheck: never = c;
      throw new Error("How did we get here?");
  }
}

Ви можете побачити це в дії тут, у TS Playground


2
Я віддаю перевагу використанню змінної теж, замість того, щоб створювати функцію (хоча обидві можуть бути позбавлені під час пакету). У будь-якому випадку ваш лінтер може скаржитися на невикористовувану змінну, і вам доведеться додати щось подібне над нею:// eslint-disable-next-line @typescript-eslint/no-unused-vars
— Маттіас,

2
Або ви можете використовувати змінну в помилці, яку ви викидаєте, приблизно так:throw new Error(`Unexpected: ${_exhaustiveCheck}`);
— Nooodles

1
Хороша ідея. Ви також можете визначити анонімну функцію:default: ((x: never) => { throw new Error(c + " was unhandled."); })(c);
— Брейді Холт,

Я можу підтвердити, що рішення @Nooodles задовольняє перевірку невикористаних змінних SonarQube. Дякую. Любіть, як це стисло.
— Ноуменон

Я звернувся до деяких пов’язаних (я думаю, що це можуть бути досить часті) помилок із наведеного вище коду, наприклад:default: { const pleaseBeExhaustive: never = c; throw new Error(`Use all Color - ${pleaseBeExhaustive as string}`); }
— Джонні,


5

Як приємний neverваріант відповіді Райана, ви можете замінити його довільним рядком, щоб зробити повідомлення про помилку більш зручним для користувача.

function assertUnreachable(x: 'error: Did you forget to handle this type?'): never {
    throw new Error("Didn't expect to get here");
}

Тепер ви отримуєте:

return assertUnreachable(c);
       ~~~~~~~~~~~~~~~~~~~~~
       Type "Color.Blue" is not assignable to type "error: Did you forget to handle this type?"

Це працює, тому що neverможе бути призначено для чого завгодно, включаючи довільний рядок.


3

Спираючись на відповіді Райана та Карлоса , ви можете використовувати анонімний метод, щоб уникнути необхідності створювати окрему іменовану функцію:

function getColorName(c: Color): string {
  switch (c) {
    case Color.Red:
      return "red";
    case Color.Green:
      return "green";
    // Forgot about Blue
    default:
      ((x: never) => {
        throw new Error(`${x} was unhandled!`);
      })(c);
  }
}

Якщо ваш перемикач не є вичерпним, ви отримаєте помилку часу компіляції .


2

Щоб уникнути попереджень Typescript або linter:

    default:
        ((_: never): void => {})(c);

в контексті:

function getColorName(c: Color): string {
    switch(c) {
        case Color.Red:
            return 'red';
        case Color.Green:
            return 'green';
        default:
            ((_: never): void => {})(c);
    }
}

Різниця між цим рішенням та іншими полягає

  • немає іменних змінних без посилань
  • він не створює винятку, оскільки Typescript забезпечить виконання коду в neverбудь-якому випадку

Поясніть, що робить код детально і чим він відрізняється від інших відповідей
— Sujitmohanty30

1

У справді простих випадках, коли вам просто потрібно повернути деякий рядок за значенням переліку, простіше (IMHO) використовувати якусь константу для зберігання словника результатів замість використання перемикача. Наприклад:

enum Color {
    Red,
    Green,
    Blue
}

function getColorName(c: Color): string {
  const colorNames: Record<Color, string> = {
    [Color.Red]: `I'm red`,
    [Color.Green]: `I'm green`,
    [Color.Blue]: `I'm blue, dabudi dabudai`,   
  }

  return colorNames[c] || ''
}

Отже, тут вам доведеться згадувати кожне значення переліку в константі, інакше ви отримаєте помилку, наприклад, якщо відсутній синій:

TS2741: В типі "{[Color.Red]: властивість" Синій "відсутній: рядок; [Color.Green]: рядок; ' але обов’язковий для типу „Record”.

Однак це часто не так, і тоді насправді краще помилити помилку так само, як запропонував Райан Кавано.

Також я був трохи засмучений, коли виявив, що це теж не буде працювати:

function getColorName(c: Color): string {
    switch(c) {
        case Color.Red:
            return 'red';
        case Color.Green:
            return 'green';
    }
    return '' as never // I had some hope that it rises a type error, but it doesn't :)
}

-1

Створіть власну функцію замість використання switchоператора.

export function exhaustSwitch<T extends string, TRet>(
  value: T,
  map: { [x in T]: () => TRet }
): TRet {
  return map[value]();
}

Приклад використання

type MyEnum = 'a' | 'b' | 'c';

const v = 'a' as MyEnum;

exhaustSwitch(v, {
  a: () => 1,
  b: () => 1,
  c: () => 1,
});

Якщо пізніше додати dдо MyEnum, ви отримаєте повідомлення про помилкуProperty 'd' is missing in type ...


Це працює лише в тому випадку, якщо ваші значення перерахування є рядками, оскільки їх потрібно закодувати як ключі в параметрі об'єкта map.
— Will Madden,
Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.