Define an array type in TypeScript

Question

I'm using TypeScript for a project and there's a case where I need to use Promise.all(...), which is returning an array of many items:

Promise.all(
  firstRequest,
  secondRequest,
  ...,
  nthRequest
)
.then((array : [FirstType, SecondType, ..., NthType]) => {
  // do things with response
});

Now, since the type [FirstType, SecondType, ..., NthType] is too long to be defined there, I wanted to define it elsewhere and use it in that point.

So I tried:

export interface ResponseParams {
  [0]: FirstType;
  [1]: SecondType;
  ...
  [n]: NthType;
}

And:

.then((array : ResponseParams) => {
  // do things with response
});

But I receive this error:

Type 'ResponseParams' is not an array type.

How can I externalise the type and make my code cleaner?

Thank you

Titian Cernicova-Dragomir · Accepted Answer · 2018-11-15 16:54:55Z

2

You can define such a type using a type alias:

type ResponseParams = [FirstType, SecondType, ..., NthType]

But I would point out that the type of array will be inferred without explicit type annotation (at least for up to 10 promises):

declare let firstRequest : Promise<{a: number}>
declare let secondRequest : Promise<{b: number}>
declare let nthRequest : Promise<{c: number}>
Promise.all([
    firstRequest,
    secondRequest,
    nthRequest
])
.then((array) => { // array is of type [{a: number;}, {b: number;}, {c: number;}]      
// do things with response
});

answered Nov 15, 2018 at 16:54

Titian Cernicova-Dragomir

253k37 gold badges464 silver badges394 bronze badges

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

2 Comments

Christian Vincenzo Traina Over a year ago

Thank you, I remembered something like this but I didn't find it googling. It can still be useful when the Promise resolve type isn't defined and you want to keep the code cleaner (at least in my opinion)

Titian Cernicova-Dragomir Over a year ago

@CristianTraìna yeah, sure, it can be useful. I was just making sure you were aware that mostly it would not be necessary to spell out the types :)

k0pernikus · Accepted Answer · 2018-11-15 17:00:03Z

0

Promise.all accepts a generic T, which gives you full control over the return type. You can thereby define the tuple for each promise that you expect back while still maintaining the types.

I would do it this way using async / await syntax:

interface Foo {
    gnarf: string;
}

interface Bar {
    poit: string;
}

const createFoo = async (): Promise<Foo> => {
    return {
        gnarf: "random",
    };
};

const createBar = async (): Promise<Bar> => {
    return {
        poit: "hurz",
    };
};

const doStuff = async () => {
    const [foo, bar] = await Promise.all<Foo, Bar>([createFoo(), createBar()]);

    return `${foo.gnarf} and ${bar.poit}`;
};

doStuff().then(console.log).catch(console.error);

answered Nov 15, 2018 at 17:00

k0pernikus

67.6k78 gold badges245 silver badges366 bronze badges

1 Comment

k0pernikus Over a year ago

@CristianTraìna Can you explicate why you think this is too much boilerplate?

Collectives™ on Stack Overflow

Define an array type in TypeScript

2 Answers 2

2 Comments

1 Comment

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

2 Comments

1 Comment

Your Answer

Sign up or log in

Post as a guest

Related