CODEWITHSUNDEEP
genericstypescript
Marius
Marius

Reputation: 3643

How can I make a generic type optional?

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?

Upvotes: 215

Views: 214984

Answers (7)

cotneit
cotneit

Reputation: 344

  • 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

Upvotes: 5

Anton Kotliarenko
Anton Kotliarenko

Reputation: 55

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.

Upvotes: 5

panepeter
panepeter

Reputation: 4242

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>;

Upvotes: 17

Siraj Alam
Siraj Alam

Reputation: 10025

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

Upvotes: 159

kimamula
kimamula

Reputation: 12601

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

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

Upvotes: 282

FstTesla
FstTesla

Reputation: 874

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
}

Upvotes: 28

David Bohunek
David Bohunek

Reputation: 3201

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

Upvotes: 3

Related Questions