TS function 的类型为 ( A | B )，具有单一返回类型 B。如何在不出现类型错误的情况下完成此操作？

Question

For example here is the simple function:

interface InputTime {
      month : number,
      year : number
}

const getMonthAndYear = (time: InputTime | Date): InputTime => {

    if(isValid(time)) {
        // time is a date object
        return {month: time.getMonth(), year: time.getFullYear()}
    } else {
        // time is a month object
        return {...time}
    }
}

So here TypeScript gives 2 errors:

1. on first return statement it says: Property 'getMonth' does not exist on type 'InputTime | Date'.

2. on Second return statement if fails due to thinking its type Date

So how can i type define this function to work as expected?

Edit:

Answering the comment about isValid function types:

Edit 2:

from further reading answers i created this function:

const _type_safe_isValidDate = (time:any):time is Date => {
    return isValid(time)
}

And error went away. But is this the only solution? Is there better way so i can write some type guard around those third party library functions that i am using in my code and not create wrapper function just for type safety?

Answer 1

TypeScript does not know from function isValid(date: any): boolean that date is definitely a Date object. It only knows that isValid returned a boolean . If you want TypeScript to treat the isValid function as a type assertion it needs to have the following syntax.

function isValid(date: any): date is Date {
   // date instanceof Date, etc
}

The relevant section of the TypeScript docs on Type Guards and Differentiating Types .

Answer 2

You can easily fix this by updating your custom type guard isValid like:

function isValid(date: any): date is Date {
    return 'getMonth' in date;
}

and then you can call getMonthAndYear() like:

console.log( getMonthAndYear(new Date()) )  
//=> {month: 4, year: 2020}

console.log( getMonthAndYear({month: 1, year: 2020}) )
//=> {month: 1, year: 2020}

---

In case you have a very complex interface with lots of properties, then you can add an additional optional prop type? to each interface like:

interface InputTime {
  type?: "input-time"
  month: number,
  year: number,
  foo: string,
  bar: boolean,
}

interface InputDate {
  type?: "input-date"
  month2: number,
  year2: number,
  foo2: string,
  bar2: boolean,
}

and then update getMonthAndYear() method like:

const getMonthAndYear = (time: InputTime | InputDate): InputTime => {

    if(time.type === 'input-time') {
        // time is a InputTime object
        return {...time}
    } else if(time.type === 'input-date'){
        // time is a InputDate object
        return {month: time.month2, year: time.year2, foo: time.foo2}
    }
}

So, time.type helps you to determine what kind of interface it is and based on that you can modify the return object to match type InputTime .