javascript - JS/TS判断一个JSON对象是否实现类或接口(interface)

Question

我有一个从字符串中解析出来的 JSON 对象。
假设这个对象有一个名为“Name”的属性，它的值可以是一个简单的字符串或一个字符串数组，甚至可以是一个存储一些关于它的信息的对象。

在运行时，我希望能够找到值类型(字符串/数组/对象)，如果它是一个对象，则将其转换为正确的类并运行基于该类的方法。

我知道我将如何处理这个问题，但唯一的问题是我不确定如何将对象转换为正确的类型。

例如，我有一个类接受两个字符串，另一个类接受一个字符串和一个数字。我希望程序查看它匹配的是哪一个，然后将其转换为正确的类。

希望我说得足够清楚，如果需要更多信息，请告诉我。

编辑:

这是我用来完成这项工作的解决方案(至少对我来说，它可能不是在所有情况下都是最好的解决方案)。

我有一个名为 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;
    }
}

它有方法 validateData，它接受一个对象(通常是 JSON 对象)并验证它是否具有解析器具有的所有变量。 如果数据有效，它将调用一个名为 cloneObject 的 protected 抽象方法。

这是一个名为 MinMaxParrser 的简单类，它扩展了 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;
        }
    }

如您所见，它具有 cloneObject 方法，该方法基本上返回一个新的 MinMaxParser 实例

最后，在主程序中，通过声明一个“示例”对象，我得到了一个包含所有可用解析器的常量数组

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

当我想找到一个有效的解析器时，我使用这个方法

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

    return found;
}

findValidParser 返回一个解析器或 null，我检查是否为 null，如果它不为 null，我可以安全地调用我创建的 parse() 方法。

Answer 1

使用 typeof 和函数重载以获得更好的类型提示:

// 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);
 } /*...*/
}