I have a JSON file containing two different types of Objects in it. I want to iterate over the JSON with respect to their type. To illustrate my problem I created two different type of Object Animal and Person

Now I want to check the type of Object whether it is an Animal or Person.

type Animal = {
  name: string;
  legs: number;
}

type Person = {
  name: number;

}

const checkType = (isAnimalOrPerson: Animal | Person) =>{
  if(isAnimalOrPerson instanceof Animal){
     console.log("animal type");
  }
  else{

  }
}

Here I am getting an error on if the condition says: "Animal" only refers to a type, but is being used as a value here.

I have a JSON file containing two different types of Objects in it. I want to iterate over the JSON with respect to their type. To illustrate my problem I created two different type of Object Animal and Person

Now I want to check the type of Object whether it is an Animal or Person.

type Animal = {
  name: string;
  legs: number;
}

type Person = {
  name: number;

}

const checkType = (isAnimalOrPerson: Animal | Person) =>{
  if(isAnimalOrPerson instanceof Animal){
     console.log("animal type");
  }
  else{

  }
}

Here I am getting an error on if the condition says: "Animal" only refers to a type, but is being used as a value here.

• javascript
• typescript

• Animal is a type, not a class. That's why instanceof cannot be used. – user13258211 Commented May 13, 2022 at 9:06
• refer this georgestefanis./blog/2020/10/30/… – Tushar Wasson Commented May 13, 2022 at 9:06
• github./Microsoft/TypeScript/wiki/FAQ#what-is-type-erasure – VLAZ Commented May 13, 2022 at 9:13

4 Answers 4

The "problem" with type is that it's a concept that only exists during development; once you transpile, it disappears, and TypeScript can't foresee the shape of a runtime value you might pass (unless you do assertion, i.e. explicit checks about what properties an object has). If you want to do type checking, you have to do it in another way, for example using classes, and then the approach would only work if you actually instantiate the class (as opposed to just using it as a shape):

class Animal {
    name: string;
    age: number;
    legs: number;
}

class Person {
    name: string;
    age: number;
    job: string;
    education: string;
}

let a: Animal = new Animal();
let b: Animal = { name: "Rex", legs: 4, age: 3 };
let c = new Person();

function checkType(arg: Animal | Person): string {
    if (arg instanceof Animal) {
        return "This is an animal";
    } else if (arg instanceof Person) {
        return "This is a person";
    }

    return "Can't tell";
}

console.log(checkType(a)); // This is an animal
console.log(checkType(b)); // Can't tell
console.log(checkType(c)); // This is a person

There's varoius ways to check PersonorAnimal value is also satisfies Animal.

1. coerce by property

if ('legs' in toBeDetermined) {
  // toBeDetermined should be `Animal` in this block
}

2. give Animal a unique symbol and check them

const animalTag: unique symbol = Symbol("Animal tag");

type Animal = {
  __brand__: typeof animalTag;
  name: string;
  legs: number;
}

if (toBeDetermined.__brand__ === animalTag) {
  // toBeDetermined can be coerced manually into Animal
}

I prefer 1 because Animal has disjoint property legs.

I'm not sure will this help gonna help you

https://www.typescriptlang/docs/handbook/2/narrowing.html#using-type-predicates

update i just found this look similar to your question https://medium./ovrsea/checking-the-type-of-an-object-in-typescript-the-type-guards-24d98d9119b0

To add to user-id-14900042's first point, you can write a function that checks the fields in the object and the type of that field to narrow it down.

e.g.

function isAnimal(object: object | undefined): object is Animal {
  return !!object &&
  'name' in object &&
  typeof object.name === 'string' &&
  'legs' in object &&
  typeof object.legs === 'number';
}

Alternatively, you could cast the object and see whether the field exists

function isAnimal(object: object | undefined): object is Animal {
  return !!object && !!(object as Animal).legs;
}