TypeScript 中的非破坏性类型断言

Question

I am looking for a good way of constraining a literal value in TypeScript to certain type without loosing inferred type information.

Let's consider a type Named that is guaranteed to have a name.

type Named = {
  name: string
};

Using a type annotation creates an error for the extra field born in the literal used to define the const cat1 .

const cat1: Named = {
  name: 'Findus',
  born: 1984,  // this is an error
};
const name1 = cat1.name;
const born1 = cat1.born;  // this is an error

By using a typecast I can define the const cat2 but it looses type information for the field born which creates a problem while trying to access that field later on.

const cat2 = {
  name: 'Findus',
  born: 1984,
} as Named;
const name2 = cat2.name;
const born2 = cat2.born;  // this is an error

One way to solve the problem is to use an IIFE to type check the literal while defining the const cat3 .

const cat3 = (<C extends Named>(c: C) => c)({
  name: 'Findus',
  born: 1984,
});
const name3 = cat3.name;
const born3 = cat3.born;

Is this the intended way of doing the constraining, or are there better alternative ways of writing compatible code?

Answer 1

Simply say that your type is a record with one required parameter name

interface Named extends Record<string, any> {
    name: string
}

Or you can use something like this

type Named<T> = T & {
    name: string
}


const a: Named<{ surname: string } > = {
    name: 'hello',
    surname: 'world'
};