TypeScript 有区别的联合

Question

I have the interfaces

interface Teacher {
    id: number;
    name: string;
    category: string;
    age: number;
    workExperience: number;
    isLikeCoffe: boolean;
}

interface CodingTeacher extends Teacher {
    category: 'coding';
    programmingLanguage: string;
}

interface MusicTeacher extends Teacher {
    category: 'music';
    instrument: string;
}

I have User-Defined Type Guards

const isMusicTeacher = (teacher: Teacher): teacher is MusicTeacher => {
    return teacher.category === "music";
}

const isCodingTeacher = (teacher: Teacher): teacher is CodingTeacher => {
    return teacher.category === "coding";
}

When i want to get all the music teachers i can do it like this

getMusicTeachers(): Array<MusicTeacher> {
  return this.getTeachers().filter(isMusicTeacher);
}

But I also need to get a lot, where only those who meet certain given criteria, and then difficulties arise. Since I only need to get music teachers who are "professional" And i do it like this

teachers: Teacher[] = [];
type TeacherCategory = "coding" | "music";

getTeachers<T extends Teacher>(category?: TeacherCategory): Array<T> {

  const activeTeachers = this.teachers.filter(t => t.workExperience > 20 && t.isLikeCoffe);

  if (!category) {
    return activeTeachers as T[];
  }

  return activeTeachers.filter(t => t.category === category) as T[];
}

or i need to get one

public findTeacherById<T extends Teacher>(id: number, category?: TeacherCategory): T {

  return this.teachers.find(t => (!category || t.category == category) && t.id == id);
}

Am I doing the correct description of the return types? In this case, when I want to get only those models knowing their category

const teacher: CodingTeacher = this.myService.findTeacherById(1, 'coding');

const teachers: MusicTeacher = this.myService.getTeachers('music');

Playground

Answer 1

In my opinion, you don't have to declare like that:

const teacher = new MyClass().findTeacherById<CodingTeacher>(1, 'coding');
// or
const teacher: CodingTeacher = this.myService.findTeacherById(1, 'coding');

Using Intersection type can help you get the type you want without declaring type or passing generics.

The following is core idea:

type TFn1 = (a: number) => number;
type TFn2 = (a: string) => string;
// be careful of this any here
const Fn: TFn1 & TFn2 = (a: number | string): any => {
  return a;
};

Fn(1); // type is (a: number) => number
Fn('2'); // type is (a: string) => string
Fn(true); // error

Then let's take findTeacherById as an example, it can be:

type T1 = (id: number, category: 'coding') => CodingTeacher;
type T2 = (id: number, category: 'music') => MusicTeacher;

...

public findTeacherById: T1 & T2 = (id: number, category: TeacherCategory): any => {
  return this.getTeachers().find((t) => (!category || t.category === category) && t.id === id);
}
...

const teacher1 = new MyClass().findTeacherById(1, 'coding'); // type returned is CodingTeacher
const teacher2 = new MyClass().findTeacherById(2, 'music'); // type returned is MusicTeacher
const teacher3 = new MyClass().findTeacherById(3, 'test'); // 'test' is not assignable
};

To unify T1 and T2 for convenience, we can declare one uniform type:

type TU<T> = (id: number, category: T extends { category: string } ? T['category'] : never) => T;

type TFindTeacherById = TU<CodingTeacher> & TU<MusicTeacher>;