Is there a way without type hinting to create a tuple in Typescript.
If I simply do
const tuple = [1, 2];
the type of Tuple number[]
The closest I can get to a oneliner is
const tuple: [number, number] = [1, 2];
Am I missing something, or is this the only way?
With typescript 3.0, you can have your own utility function:
const tuple = <T extends any[]>(...args: T): T => args
And use it this way:
const tup = tuple(1, 2) // tup type is [number, number]
string[]) is making [...string], which is effectively a string arrayTypescript will not infer tuple types from array literals. You can specify the type explicitly, as you have, or you can create a helper function to make it a bit easier and still get some inference.
const tuple = <T extends [any] | any[]>(args: T): T => args
tuple(["A", "B"]) // [string, string]
Edit
Starting from 3.4 you can also use an as const assertion. This does have the advantage of not needing the extra function but it will generate a read-only tuple:
var t = [1, ''] as const;
t[0] = 1 //err
Starting from 3.0 you can also use tuples in rest parameter to infer tuples:
const tuple = <T extends any[]>(...args: T): T => args
tuple("A", "B") // [string, string]
as const assertion that return mutable tuple? Something like [Number()] as MutableConst which give [number] instead of readonly [number]
<T extends [] | any[]> and <T extends [] | {}> are shorter and work too.As of TypeScript 3.4, you can add simply as const at the end.
const tuple = [1, 2] as const;
Full credit to @bela53's answer, which has a better example and link to TS playground.
readonly keywords on every attribute. The other solutions are better.TypeScript 4.0 has an additional way to implictly infer tuple types:
The type
[...T], whereTis an array-like type parameter, can conveniently be used to indicate a preference for inference of tuple types[:] (docs)
const tuple = <T extends unknown[]>(args: [...T]): T => args
tuple(["A", "B"]) // [string, string]
I am adding this answer for reference as I found it to be a pain that as const creates readonly tuples and that other techniques widen the types of the values
const tuple = <T extends any[]>(xs: readonly [...T]): T => xs as T;
it can be used in 2 ways:
const a = tuple(['foo', 10] as const)
a is of type ["foo", 10], is not readonly andtypeof a[number] is "foo" | 10
const b = tuple(['foo', 10]);
b is of type [string, number] and typeof b[number] is string | number
I would recommend defining a type for the tuple because it's more expressive.
type TreeHouse = [location: Location, name: string, capacity: number];
and then use
<TreeHouse>[new Location(…), "Treeston", 6]
From what I tried this tuple literal cannot use parameter names unfortunately.
Take care of precedence! <TreeHouse>(…) has not the same precedence like new TreeHouse(…).
tuple.push(123)[number, number]then you can only push number type in the array. The purpose of declaring an array as tuple is restrict the types of known one or more array elements .