Typescript Typeguard check if array is of type

Question

I want to write a typeguard to check if all children of array are of type T thus making it an Array where T is a generic type

TS Playground

// Assume arr of any type but Array
const arr: any[] = [
  {
    foo: "bleh1",
    bar: 1
  },
  {
    foo: "bleh2",
    bar: 2
  },
]

interface newType {
  foo: string
  bar: number
}

// Check that arr is an array of newType , ie arr: newType[]
const isArrayOf = <T,>(arr: any): arr is Array<T> => {
  // TypeScript mastery needed here
  return true
}

if(isArrayOf<newType>(arr)){
  arr
}

Got suggestion from GitHub Copilot but couldnt understand the 2nd argument typescript const isArrayOf = <T>(arr: any[], type: new (...args: any[]) => T): arr is T[] => { return arr.every((item) => item instanceof type) } — Solaris
– Solaris, Commented Dec 1, 2021 at 20:48
The type system does not exist at runtime. You cannot check if something conforms to a generic type because there is no "geneics" nor "types" when the function runs. — VLAZ
– VLAZ, Commented Dec 1, 2021 at 20:48
The suggestion is to use a concrete type and pass in a class. However, that's not possible when the type is an interface. — VLAZ
– VLAZ, Commented Dec 1, 2021 at 20:49
I think its possible like described [here] (2ality.com/2020/06/…) but I fail to understand its working thus would like some explanation about the function arguments — Solaris
– Solaris, Commented Dec 1, 2021 at 20:57
Again, this works if you have a concrete type. Something that exists at runtime. A class. Not if you have an interface - that only exists at compiletime. — VLAZ
– VLAZ, Commented Dec 1, 2021 at 20:59

Guerric P · Accepted Answer · 2021-12-01 21:26:24Z

4

The best thing you could do is this:

const arr: NewType[] = [
  {
    foo: "bleh1",
    bar: 1
  },
  {
    foo: "bleh2",
    bar: 2
  },
]

interface NewType {
  foo: string
  bar: number
}

type TypeOfArrayElements<T> = T extends Array<infer U> ? U : never;

type ArrayType = TypeOfArrayElements<typeof arr>;

TypeScript will never be able to guess that the array typed as any[] actually contains NewType elements. Like everything in TypeScript, type predicates are static and won't return a type dynamically based on what is passed as a parameter at runtime. But if you type it as NewType[], then you can extract the NewType type from it.

edited Dec 1, 2021 at 21:26

answered Dec 1, 2021 at 21:14

Guerric P

32k6 gold badges61 silver badges109 bronze badges

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

Comments

Solaris · Accepted Answer · 2021-12-02 18:14:31Z

0

Edit 1:

This answer has two shortcomings (mentioned in comments)

The property needs not be own for it to exist on the object x = {a: 1}; y = Object.create(x); y.b = 2
The function requires you to manually enumerate all the keys of the object. Thus can introduce human error

I think the solution can still be used as workaround in specific circumstances

Original:

If an array a is of type newType[] then every element of a , consider x = a[0] will be of type newType. x is of type newType because x satisfies all properties and methods of type newType.

Thus if reversed , if x y z are of type newType and they are the only and all elements of array a, Thus every element of a are of type newType, which satisfies the condition for a to be of type newType[]

// Check if obj has all keys props[]
const hasAllProperties = <T,>(obj: any, props: (keyof T)[]): obj is T => {
  return props.every((prop) => {
    // console.log(prop)
    return Object.prototype.hasOwnProperty.call(obj, prop)})
}

// Check that arr is an array of newType , ie arr: newType[]
const isArrayOf = <T,>(obj: any[], props: (keyof T)[]): obj is T[] => {
  // Check if every elements have all keys in props
  return obj.every((ele) => {
    // console.log(ele)
    return hasAllProperties<T>(ele,props)
  }
  )
}

if (isArrayOf<newType>(arr, ["foo", "bar"])) {
  console.log("arr is of newType[]")
}

TS Playground

edited Dec 2, 2021 at 18:14

answered Dec 2, 2021 at 9:54

Solaris

7841 gold badge9 silver badges27 bronze badges

3 Comments

VLAZ Over a year ago

Object.prototype.hasOwnProperty.call(obj, prop)}) - the property needs not be own for it to exist on the object. Consider x = {a: 1}; y = Object.create(x); y.b = 2 now y has both fields a and b thus satisfies interface AB { a: number; b: number; } however a is not an own property. Consider using prop in obj

VLAZ Over a year ago

There is also a problem with the function invocation being isArrayOf<newType>(arr, ["foo", "bar"]) - that requires you to manually enumerate all the keys of the object. However, it's not a compilation error if you don't, thus isArrayOf<newType>(arr, ["foo"]) would claim that arr = [{foo: "hello}, {foo: "world"}] is newType[] when it is not. This could be an issue if the interface changes, for example. Maybe the invocation was correct once but in the future somebody adds or removes a property - they now have to go and change all invocations of isArrayOf

Solaris Over a year ago

The 2nd drawback can we avoided with stackoverflow.com/questions/43909566/…

Collectives™ on Stack Overflow

Typescript Typeguard check if array is of type

2 Answers 2

Comments

Edit 1:

Original:

3 Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Comments

Edit 1:

Original:

3 Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related