Как проверить, является ли ввод фирменным типом в TypeScript?

Система типов TypeScript во многом является структурной , а не номинальной . Это означает, что два типа, имеющие одинаковую структуру, считаются идентичными типами. Не имеет значения, имеют ли эти два типа разные имена или были объявлены в разных местах. TypeScript позволяет создавать псевдонимы типов, но это просто другое имя для существующего типа и не служит для различения типов или создания нового типа. Это просто другое название одного и того же:

type MyString = string;
const x: string = "abc";
const y: MyString = x; // okay, no difference between string and MyString

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

Для примитивов , таких как string, вы даже не можете добавить такую ​​структуру во время выполнения, потому что они на самом деле не содержат свойств (кажется, у них есть методы и свойства через автоупаковку, но это просто дает вам материал на прототип класса-обертки, например String ). Но это не мешает нам писать такой тип так, как если бы он существовал, и это дает нам фирменные примитивы:

type MyString = string & { __myString: true };
const x: string = "abc";
const y: MyString = x; // error!
//    ~ <-- Type 'string' is not assignable to type 'MyString'.

Теперь тип MyString структурно отличается от string тем, что предположительно обладает свойством __myString типа true. И поэтому вы больше не сможете случайно назначить stringMyString. В __myString и true тоже нет ничего особенного. Это просто что-то случайное, что вы добавляете туда, чтобы отличить это от других вещей. Если вы хотите создать другие типы фирменных строк, вам следует выбрать другое свойство бренда.

Все это нормально, за исключением того, что мы не можем получить значение типа MyString во время выполнения. Примитивы не могут хранить свойства так, как объекты:

y.__myString = true; // you can write this, but it doesn't work
// 💥 TypeError! can't assign to property "__myString" on "abc": not an object 

Вы можете солгать компилятору, что у вас есть один из этих фирменных примитивов, используя утверждение типа :

const z: MyString = "def" as MyString; // okay

и это позволяет вам перемещать значения, как если бы они были фирменными, но при этом эффект времени выполнения нулевой. Вся система типов TypeScript стирается при компиляции, поэтому as MyString исчезает. В TypeScript есть утверждения типов, а не приведение типов (или, по крайней мере, тот тип приведения, который он имеет, не следует путать с приведением в других языках, таких как Java или C, которые на самом деле что-то делают во время выполнения).

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

Итак, ваша brandString функция

function brandString(value: string): BrandedString {
  return value as BrandedString;
}

просто возвращает свои входные данные и не имеет никакого эффекта во время выполнения. Вы не можете написать охранную функцию типа isBrandedString() , которая работает:

function isBrandedString(value: string): value is BrandedString {
  // impossible
}

Весь смысл чего-то вроде BrandedString в том, чтобы не дать вам случайно перепутать разные «типы» строк в вашем собственном коде. Это больше похоже на мысленный тег, который вы добавляете к типу, чтобы помочь вам отслеживать события. Тег существует только в вашем представлении о значении, а не о фактическом значении.

Итак, теперь вам нужно решить, почему вы это делаете. Если вам действительно нужно пометить значение во время выполнения, чтобы можно было отличить string от BrandedString во время выполнения, то вам в значительной степени придется отказаться от примитивов. Вы можете использовать тип объекта, например

type BrandedString = { value: string; __brand: true };

function brandString(value: string): BrandedString {
    return { value, __brand: true };
}

function isBrandedString(value: unknown): value is BrandedString {
    return !!value && typeof value === "object"
        && "__brand" in value && value.__brand === true;
}

let x = brandString("hello");
console.info("brandString", x, isBrandedString(x)); // returns true

Но, конечно, теперь вы просто держите string в контейнере и клеймите контейнер, а не веревку. Возможно, это не то, что вы хотели сделать, но у этого есть то преимущество, что оно действительно работает.

Детская площадка, ссылка на код