How can I make a generic type optional?

Question

I have the following logging method:

private logData<T, S>(operation: string, responseData: T, requestData?: S) {
    this.logger.log(operation + ' ' + this.url);
    if (requestData) {
        this.logger.log('SENT');
        this.logger.log(requestData);
    }
    this.logger.log('RECEIVED');
    this.logger.log(responseData);
    return responseData;
}

The requestData is optional. I want to be able to call logData without having to specify the S type when I don't send the requestData to the method: instead of: this.logData<T, any>('GET', data), I want to call this.logData<T>('GET', data).

Is there a way to achieve this?

Maybe overload the function instead? Or maybe try using a default parameter. — Luka Jacobowitz, May 30 '16 at 12:00
I don't think it's possible to overload, if I do something like `private logData(operation: string, responseData: T)` and `private logData(operation: string, responseData: T, requestData: S)` I will get an duplicate function definition error — Marius, May 30 '16 at 12:04

score 260 · Answer 1 · answered May 04 '17 at 08:24

260

As of TypeScript 2.3, you can use generic parameter defaults.

private logData<T, S = {}>(operation: string, responseData: T, requestData?: S) {
  // your implementation here
}

answered May 04 '17 at 08:24

kimamula

11,427
8
35
29

15

Curious if using `S = never` would enforce the type get specified when the optional parameter is used. – cchamberlain Jul 20 '17 at 06:16
7

`S = any` should allow any type – Josiah Ruddell Aug 17 '17 at 06:15
@cchamberlain Unfortunately, you can not have type definitions with this approach – georgekrax Dec 08 '20 at 08:51
5

Don't use `{}` as a type. `{}` actually means "any non-nullish value". eslint(@typescript-eslint/ban-types) – Pierre C. Dec 30 '21 at 14:46
@cchamberlain you can do `S extends T = never`, not sure if that was your question – netotz Aug 31 '23 at 21:34

Siraj Alam · Answer 2 · 2020-10-08T04:55:01.163

129

TS Update 2020: Giving void will make the generic type optional.

type SomeType<T = void> = OtherType<T>;

The answer above where a default value as the object is given make it optional but still give value to it.

Example with default type value is {}:

type BaseFunctionType<T1, T2> = (a:T1, b:T2) => void;

type FunctionType<T = {}> = BaseFunctionType<{name: string}, T>

const someFunction:FunctionType = (a) => {

}

someFunction({ name: "Siraj" });
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
// Expected 2 arguments, but got 1.(2554)

Playground Link

Example with default generic type value is void

type BaseFunctionType<T1, T2> = (a:T1, b:T2) => void;

type FunctionType<T = void> = BaseFunctionType<{name: string}, T>

const someFunction:FunctionType = (a) => {

}

someFunction({ name: "Siraj" })

This is a good read on making generics optional.

Optional generic type in Typescript

Playground Link

edited Oct 08 '20 at 04:55

answered Jun 09 '20 at 10:49

Siraj Alam

9,217
9
53
65

If you want to have the type mandatory, but limit the types the generic can accept, you can also put `` etc. – amphetamachine Jun 14 '20 at 18:10
Right @amphetamachine . I'm aware. – Siraj Alam Jun 15 '20 at 06:05
1

Lovely, thanks. Where is this documented (officially)? – Dr. Jan-Philip Gehrcke Oct 02 '20 at 12:32
@amphetamachine Unfortunately, I cannot implement it with type definitions – georgekrax Dec 08 '20 at 08:51

score 26 · Accepted Answer · answered Apr 21 '17 at 12:55

As per TypeScript 2.2 (you can try it in the TS Playground), calling this.logData("GET", data) (with data of type T) gets inferred succesfully as this.logData<T, {}>("GET", data).

The overload suggested by David Bohunek can be applied if the inference fails with the TS version you use. Anyway, ensure that the second signature is before declared and then defined, otherwise it would not participate in the available overloads.

// Declarations
private logData<T>(operation: string, responseData: T);
private logData<T, S>(operation: string, responseData: T, requestData?: S);
// Definition
private logData<T, S>(operation: string, responseData: T, requestData?: S) {
    // Body
}

How do I avoid to specify the second type when I want to use the `requestData` parameter? 'Cause when I use this one I need to pass a second type — Felipe Gustavo, Oct 09 '22 at 11:53

score 14 · Answer 4 · answered May 20 '21 at 07:25

If you're looking for an optional generic type within a Type/Interface declaration, this might help.

(came looking for this, only found answers dealing with generic function declarations. Siraj's answer got me on the right track.)

type ResponseWithMessage = {
  message: string;
};

interface ResponseWithData<T> extends ResponseWithMessage {
  data: T;
}

export type ResponseObject<T = void> = T extends void
  ? ResponseWithMessage
  : ResponseWithData<T>;

score 4 · Answer 5 · answered Aug 03 '21 at 08:01

4

How about Partial?

Constructs a type with all properties of Type set to optional. This utility will return a type that represents all subsets of a given type.

answered Aug 03 '21 at 08:01

Anton Kotliarenko

45
4

cotneit · Answer 6 · 2022-03-10T20:09:10.730

void doesn't play well where some kind of object is expected. Edit: plays perfectly well, you just have to consider the fact that void will override anything you merge it with (void & string is basically void) - this is probably the one you want
unknown
{} basically the same as unknown

interface OffsetPagination {
    offset: number;
    limit: number;
}

interface PagePagination {
    page: number;
    size: number;
}

type HttpListParams<
    PaginationType extends OffsetPagination | PagePagination | void = void,
    Params = {
        filter?: string;
    },
> = PaginationType extends void ? Params : PaginationType & Params;

ts playground

Hi! Correct will be ```PaginationType = void extends void ? Params : PaginationType & Params;``` — Gennady Magomaev, Aug 10 '23 at 06:25

score 3 · Answer 7 · answered May 30 '16 at 16:37

You can write the overloading method like this:

private logData<T>(operation: string, responseData: T);
private logData<T, S>(operation: string, responseData: T, requestData?: S) {
    this.logger.log(operation + ' ' + this.url);
    if (requestData) {
        this.logger.log('SENT');
        this.logger.log(requestData);
    }
    this.logger.log('RECEIVED');
    this.logger.log(responseData);
    return responseData;
}

But I don't think you really need it, because you don't have to write this.logData<T, any>('GET', data) instead just write this.logData('GET', data). The T type will be infered

I'd be careful with generic and the conditional statement of this code. If the generic `S` is of type boolean or number it will fail to go inside the `if(requireData)` because the boolean value false and the number value 0 will be false. It would be more resilient to use `if(requestData !== undefined)`. — Patrick Desjardins, Mar 21 '18 at 17:55

How can I make a generic type optional?

7 Answers7

Linked

Related