转换通用json响应时是否应使用“ any”

如何解决转换通用json响应时是否应使用“ any”

我不确定为打字稿项目中的函数在输入/输出中创建任何类型的函数是否很好，以及如何在“严格类型检查”和“灵活性”之间取得平衡。

现在，我正在尝试创建一个辅助函数，以删除graphQL响应中的边缘和节点，以便更轻松地处理视图组件，举个例子：

// Input A
{
    "students": {
        "edges": [
            {
                "node": {
                    "name": "Peter","age": 12
                }
            },{
                "node": {
                    "name": "Mike","age": 12
                }
            }
        ]
    }
}

// Input B
{
    "teachers": {
        "edges": [
            {
                "node": {
                    "name": "Mary","age": 40
                }
            },{
                "node": {
                    "name": "John","age": 35
                }
            }
        ]
    }
}

我建议的辅助函数：

const simpleConnectionsHandler = (obj: any): any => {
// Some logic to remove edges and nodes
...
}

期待我能从函数（输出）中得到什么：

// Output A
{
    "students": [
        { "name": "Peter","age": 12 },{ "name": "Mike","age": 12 }
    ]
}

// Output B
{
    "teachers": [
        { "name": "Mary","age": 40 },{ "name": "John","age": 35 }
    ]
}

在我的视图组件中，我将采用以下简化形式的响应：

const studentList: studentsSimplified = simpleConnectionsHandler(inputA); 
const teacherList: teachersSimplified = simpleConnectionsHandler(inputB);

这样做的原因是，我想防止为响应json声明两个类型的版本，一个是带有边和节点的响应，一个是没有边和节点的响应。

我想知道将输入接受为“ any”并为输出返回“ any”是否很好，当我在调用方获得结果时，我转换回简化的响应版本。 / p>

解决方法

这似乎不是泛型的工作，因为所有类型的定义都是明确的。

我建议自己定义节点类型，然后按如下方式描述图形格式：

type MyNode = { name: string,age: number };
type graph = {
    [x: string]: {
        edges: Array<{
            node: MyNode
        }>
    }
};

function name(params: graph): { [x: string]: MyNode[] } {
    return {...}
}

用您拥有的任何已知密钥替换通用[x: string]。

如您在此代码片段中所看到的，我已经用所有期望的字段描述了整个输入，因此不仅可以输入任何js对象。

我已经定义了一种MyNode类型，它可以用来组成图的其余部分，以及组成返回类型。

如果您甚至想限制[x: string]可以成为什么，您可以在这里看到：
Typescript: How to use a generic parameter as object key

并实际上编写一个通用函数来保证结果具有相同的键。

例如：

type knownKeys = 'teacher' | 'student';
type MyNode = { name: string,age: number };
type graph<T extends knownKeys> = {
    [x in T]: {
        edges: Array<{
            node: MyNode
        }>
    }
};

function myFunction<T extends knownKeys>(params: graph<T>): { [x in T]: MyNode[] } {
    return {}
}

// use
const a = myFunction<'teacher'>({
    teacher: {
        edges: [
            { node: { name: 'hi',age: 42,} },],}
});

,

这就是泛型的用途。

const simpleConnectionsHandler = <T>(obj: any): T => {
// Some logic to remove edges and nodes
...
}

const studentList: studentsSimplified = simpleConnectionsHandler<studentsSimplified>(responseA); 
const teacherList: teachersSimplified = simpleConnectionsHandler<teachersSimplified>(responseB);

注意：您可以像这样隐含变量类型：

const studentList = simpleConnectionsHandler<studentsSimplified>(responseA); 
const teacherList = simpleConnectionsHandler<teachersSimplified>(responseB);