Optional generic type
GenericsTypescriptGenerics Problem Overview
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?
Generics Solutions
Solution 1 - Generics
As of TypeScript 2.3, you can use generic parameter defaults.
private logData<T, S = {}>(operation: string, responseData: T, requestData?: S) {
// your implementation here
}
Solution 2 - Generics
> 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)
> 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.
Solution 3 - Generics
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
}
Solution 4 - Generics
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>;
Solution 5 - Generics
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.
Solution 6 - Generics
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
Solution 7 - Generics
void
doesn't play well where some kind of object is expected. Edit: plays perfectly well, you just have to consider the fact thatvoid
will override anything you merge it with (void & string
is basicallyvoid
) - this is probably the one you wantunknown
{}
basically the same asunknown
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;