I have a list of numbers that I know is never empty. Is it possible to define an array in Typescript that is never empty?
I know that it is possible with tuples like [ number, number ] but this will not work as my array can be any size.
I guess what I am looking for is a NonEmptyArray<number> type.
Does it exist? :)
A feature request for allowing you to just check array.length > 0 to guard against empty arrays, microsoft/TypeScript#38000, was declined as being too complex. Essentially you cannot usually simply check length in TypeScript to convince the compiler about the availability of properties at given numeric keys.
You can define a non-empty array type like this:
type NonEmptyArray<T> = [T, ...T[]];
const okay: NonEmptyArray<number> = [1, 2];
const alsoOkay: NonEmptyArray<number> = [1];
const err: NonEmptyArray<number> = []; // error!
This is due to support added in TS 3.0 for rest elements in tuple types. I'm not sure what your use case is... It's probably more annoying to use that type than you expect, though:
function needNonEmpty(arr: NonEmptyArray<number>) {}
function needEmpty(arr: []) {}
declare const bar: number[];
needNonEmpty(bar); // error, as expected
if (bar.length > 0) {
needNonEmpty(bar); // ugh, still error!
}
If you want a length check to work, you'll need to use something like a user-defined type guard function, but it's still annoying to use:
function isNonEmptyArray<T>(arr: T[]): arr is NonEmptyArray<T> {
return arr.length > 0;
}
if (isNonEmptyArray(bar)) {
needNonEmpty(bar); // okay
} else {
needEmpty(bar); // error!! urgh, do you care?
}
head() and last() instead of during or after.
const foo = {a: [1]}; const bar: { [key: string]: NonEmptyArray<any> } = foo yields error Type 'number[]' is not assignable to type 'NonEmptyArray<any>'.I've also wondered about this and came up with a different solution:
type NonEmptyArray<T> = T[] & { 0: T };
type NonEmpty<T> = T extends Array<infer U> ? U[] & {'0': U} : never;. Usage: const x: NonEmpty<string[]> = ["myString"];. This separates the NonEmpty part from the Array part.
arr as having the type NonEmptyArray<number | undefined> in that case. Depends on how you define the type you actually want to use.
Note for a happy reader. None of the above solutions is viable.
type NonEmptyArray<T> = T[] & { 0: T }
// type NonEmptyArray<T> = [T, ...T[]] -- same behavior
// ISSUE 1: map does not preserve Non-Emptiness
const ns: NonEmptyArray = [1]
const ns2 = ns.map(n => n) // number[] !!!
// ISSUE 2: length check does not make an array Non-Empty
function expectNonEmpty<T>(ts: NonEmptyArray<T>): any {}
if (ns2.length > 0) {
expectNonEmpty(ns2) // type error
}
Just FYI, so you know why it's unlikely to see NonEmptyArray in practice. The above replies should have mention this.
is keyword: function isNonEmpty<T>(array: T[]): array is NonEmptyArray<T> {return array.length > 0}. It will make your codebase more verbose but also more type safe ;)Although type [T, ...T[]] cover most cases, it won't accept arrays like [...anotherArray, 'element']. I personally use type as presented below, to cover wider spectrum of cases:
export type NonEmptyArray<T> = [T, ...T[]] | [...T[], T] | [T, ...T[], T];
Excludefor this, but althoughtype NonEmptyNumberArray = Exclude<number[], []>;parses, the result is just an alias fornumber[].MyArray = [ number, number ]. Just for n items instead of only two.