JS / TS确定JSON对象是否实现了类或接口

Question

I have a JSON object parsed from a string.
Let's say this object has a property called "Name" the value of it can be a simple string or an array of strings or even an object that store some information about it.

In runtime I want to be able to find the value type (string/array/object) and if it is an object cast it into the correct class and run a method based on that.

I have the idea on how I am going to go about this but the only problem is that I am not sure how to convert the object to the correct type.

For example, I have a class which accepts two strings and another class that accepts a string and a number. I want the program to see which one it matches and then cast it to the correct class.

Hope I was clear enough if more information is needed please let me know.

EDIT:

Here is the solution I used to make this work (at least for me, it may not be the best solution in every case).

I have an abstract class called Parser

    export abstract class Parser {
    abstract parse(): string;

    clone(dataObject: object): Parser {
        if (this.validateData(dataObject) == false) return null;
        return this.cloneObject(dataObject);
    }
    protected abstract cloneObject(dataObject: object): Parser;

    protected validateData(data: object): boolean {
        const parserKeys = Object.keys(this);
        const dataKeys = Object.keys(data);

        for (let i = 0; i < parserKeys.length; i++) {
            const parserKeyName = parserKeys[i];

            if (typeof this[parserKeyName] === "function") continue;
            const index = dataKeys.indexOf(parserKeyName);
            if (
                index == -1 ||
                typeof data[dataKeys[i]] !== typeof this[parserKeyName]
            )
                return false;
        }
        return true;
    }
}

It has the method validateData which takes an object (the JSON Object usually) and validate that it has all the variables the Parser has. If the data is valid it will call a protected abstract method called cloneObject.

Here is a simple class called MinMaxParrser that extends Parser

import { Parser } from "./Parser";
import { randomNumber } from "./utils";

export class MinMaxParser extends Parser {
        min: 0;
        max: 1;
        constructor() {
            super();
            this.min = 0;
            this.max = 1;
        }
        parse(): string {
            return randomNumber(this.min, this.max).toString();
        }

        cloneObject(dataObject: object): MinMaxParser {
            let newParser = new MinMaxParser();
            newParser.min = dataObject["min"];
            newParser.max = dataObject["max"];

            return newParser;
        }
    }

As you can see, it has the cloneObject method which basically returns an instance of a new MinMaxParser

And finally, in the main program, I have a const array of all the available parsers by declaring a "sample" object

const availableParsers: Parser[] = [new MinMaxParser()];

When I want to find a valid parser I use this method

private findValidParser(data: Object): Parser {
    let found = null;
    availableParsers.forEach(parser => {
        let clone = parser.clone(data);
        if (clone !== null) {
            found = clone;
        }
    });

    return found;
}

The findValidParser returns me a parser or null, I check for null and if it is not null i can safely call the parse() method i created.

Answer 1

Use the following to check each

 let obj = {}; let str = ''; let num = 0; let array = []; console.log(Array.isArray(array)) console.log(typeof obj === 'object') console.log(typeof str === 'string') console.log(!isNaN(num)) 

Answer 2

Use typeof and function overloads to get better type hints:

// narrow down types to get better typings
function parse(a: string, b: {}, c: string): Parser1;
//...

// implement generically
function parse(a: any, b: any, c: any): Parser {
 if(typeof a === "string" && typeof b === "object" && typeof c === "string") {
   return Parser1.parse(a, b, c);
 } /*...*/
}