Function overloading with interface argument

Question

I'm trying to make a function overloading for the search() function. This method must have different search actions.

search with only string type.
- search(key: string): IPagination<Employee[]>;
search with BasicFilter type:
- search(x: BasicFilter): IPagination<Employee[]>;
search with PaginatedFilter type:
- search(y: PaginatedFilter): IPagination<Employee[]>;

How can i check the type of this interfaces in search(args: any): any; method?

Tried doing the following:

  if (typeof args === BasicFilter) {
    console.log('searched with basic filter arguments');
  }

TS message: 'BasicFilter' only refers to a type, but is being used as a value here.

Error message: BasicFilter is not defined

Here are the following codes:

The Interfaces

interface PageData {
  pageIndex: number;
  pageSize: number;
}

interface Employee {
  id: number;
  name: string;
}

interface BasicFilter {
  key: string;
  is_archived: boolean;
}

interface PaginatedFilter {
  key: string;
  is_archived: boolean;
  page: PageData;
}

interface IPagination<T> {
  length: number;
  list: T;
}

The Class

class Service {

  constructor(public name) {}

    search(x: BasicFilter): IPagination<Employee[]>;
    search(y: PaginatedFilter): IPagination<Employee[]>;
    search(key: string): IPagination<Employee[]>;
    search(args: any): any {

      if (typeof args === 'string') {
        console.log('searched with keyword only');
      }

      if (typeof args === 'object') {
        console.log('searched with object arguments');
      }

    }

}

Usage

const service = new Service('Serbisyo publiko');

service.search({ key: 'some key', is_archived: false });

const default_page: PageData = { pageIndex: 0, pageSize: 15 };

service.search({ key: 'some queries', is_archived: true, page: default_page });

service.search('filtering data..');

The Output

searched with object arguments
searched with object arguments
searched with keyword only

DEMO

Titian Cernicova-Dragomir · Accepted Answer · 2018-06-20 06:50:20Z

2

Since interfaces don't exist at runtime you can't type guard them them with typeof (which works for primitive types) or instanceof (which would work for classes). You can use an in type guard which discriminates a union based on the existence of a fields. Also I would use a union of the possible parameter types for the implementation signature so type guards work correctly and you have full type safety. In your case the page field appers to be a good candidate for this:

search(x: BasicFilter): IPagination<Employee[]>;
search(y: PaginatedFilter): IPagination<Employee[]>;
search(key: string): IPagination<Employee[]>;
search(args: BasicFilter | PaginatedFilter | string): any {

    if (typeof args === 'string') {
        console.log('searched with keyword only');
        args // is typed to string here
    }
    else if ('page' in  args) {
        console.log('searched with object arguments');
        args // is typed to PaginatedFilter here
    }else {
        args // is typed to BasicFilter here
    }
}

Note Order of type guards matters, you have to remove the string from the union first as the in type guard will only work if all types in the union are objects.

edited Jun 20, 2018 at 6:50

answered Jun 20, 2018 at 6:29

Titian Cernicova-Dragomir

253k37 gold badges464 silver badges394 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

Shift 'n Tab Over a year ago

A fine answer with good explanation regarding interface doesn't compile in runtime show up!

Amit Saxena · Accepted Answer · 2018-06-20 06:45:03Z

0

From your question it can be seen that currently there are three search possibilities exposed through different interface like Basic Filter, Paginated Filter etc and also string. Tommorow it may so happen that you may need to come up with another interface that has diferent search filter.

To provide extensibilty and a comon searching terminolgy that helps you achieve OCP, please have all your interfaces derive from another dummy interface like IFilterCriteria. This means Basic Filter, Paginated Filter will now derive from IFilterCriteria. Also to provide for strign based search creater another interface called StringFilter will also derive from IFilterCriteria.

IFilterCriteria interface will be defined as:

interface IFilterCriteria {
}

This means it do not hold any state. It is just a marker interface

BasicFilter interface now will be defined as

interface BasicFilter extends IFilterCriteria {
    key: string;
    is_archived: boolean;
}

Similarly we can have modified definition of

interface PaginatedFilter extends IFilterCriteria {
    key: string;
    is_archived: boolean;
    page: PageData;
}

Thus this provides common ground all current and future filtering possibilities.

And now the search function becomes more type safe and its signature will be:

search(args: IFilterCriteria): any;

Since now search takes this IFilterCriteria interface as parameter it can safely be type-casted and checked within function body

answered Jun 20, 2018 at 6:45

Amit Saxena

11 bronze badge

1 Comment

Titian Cernicova-Dragomir Over a year ago

Not really a typescript solution. Since typescript uses structural compatibility, this function search(args: IFilterCriteria): any; will take any argument, ex service.search({ anything: true })

Collectives™ on Stack Overflow

Function overloading with interface argument

2 Answers 2

1 Comment

1 Comment

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

1 Comment

1 Comment

Your Answer

Sign up or log in

Post as a guest

Related