Typescript

Question

我想从 main_object 集合中检索对象“rename_fields”以使用其字段值：

export interface StdMap<T = string> {
    [key: string]: T;
}

export type StdFileBasedPluginHandlerConfiguration<
    SourceType extends StdMap<string | number>
> = {
    type: "std_file";
    data_files: string[];
    exclude_fields: string[];
    value_fields: string[];
    rename_fields: StdMap<StdMap<string>>;
    descriptor: string;
};

export type PluginHandlerConfiguration =
    | StdFileBasedPluginHandlerConfiguration<any>
    | { type: "not_required_configuration" }
    | undefined;

// export type PluginHandlerConfiguration = StdFileBasedPluginHandlerConfiguration<
//     any
// >;


export interface CollectorConfiguration {
    lastUpdate: Date;
    hashFile: string;
    code: string;
    plugin_path?: string;
    plugin_configuration: PluginHandlerConfiguration;
    related_codes?: string[];
    collections: { original: string; names: string[] };
    skipCollectData?: boolean;
    skipFlatGeneration?: boolean;
    extra_grouping_fields: string[];
    has_origins: boolean;
    force?: boolean;
    notify?: boolean;
    origins_that_generate_extra_records?: string[];
}

const main_object: CollectorConfiguration=
{ 
    "code" : "my_code", 
    "lastUpdate" : new Date("2020-01-28T00:00:00.000+0000"), 
    "collections" : {
        "original" : "collection", 
        "names" : [
            "collection_1",
            "collection_2"
        ]
    }, 
    "hashFile" : "ffc0b10ac2e7cd681f5666a474063165f5507212c45abf4ee2f85482ea866985,13c1dd232e13bc6d20ffe6213f38c5152e1f5e7f72366b461602d3cd876ef40f", 
    "extra_grouping_fields" : [
        "type"
    ], 
    "has_origins" : true, 
    "plugin_path" : "file/path_to_plugin", 
    "plugin_configuration" : {
        "type" : "std_file", 
        "data_files" : [
            "../file1.csv", 
            "../file2.csv"
        ], 
        "value_fields" : [
            "value1", 
            "value2"
        ], 
        "descriptor" : "type", 
        "exclude_fields" : [
            "excl1", 
            "excl2"
        ], 
        "rename_fields" : {
            "flat" : {
                "TEST1" : "test1", 
                "TEST2" : "test2", 
                
            }
        }
    }
}

    


Object.keys(main_object).forEach((key: Date | string | StdFileBasedPluginHandlerConfiguration<any> | boolean)=>{
    console.log(`KEY: ${key} - typeof key: ${typeof key}`);
    Object.keys(main_object).forEach((keyConfiguration) => {
        console.log(`DEBUG-->configuration keys: ${keyConfiguration}`);
        if (keyConfiguration === "plugin_configuration") {
            Object.keys(main_object[keyConfiguration]!).forEach(
                (keyPluginConfiguration: any) => {
                    console.log(
                        `DEBUG-->plugin_configuration - ${keyPluginConfiguration} --- END plugin_configuration`
                    );
                    if (keyPluginConfiguration === "rename_fields") {
                        Object.keys(
                            keyConfiguration![keyPluginConfiguration]!
                        ).forEach((keyRenameFields: any) => {
                            console.log(
                                `DEBUG-->rename_fields - ${keyRenameFields} --- END rename_fields`
                            );
                        });
                    }
                }
            );
        }
    });
});

但我遇到了错误：

test_object_loop.js:50
Object.keys(keyConfiguration[keyPluginConfiguration]).forEach(函数(keyRenameFields){ ^
TypeError：无法将 undefined 或 null 转换为对象
在 Function.keys ()
在 test_object_loop.js:50:28
在 Array.forEach ()
在 test_object_loop.js:47:56
在 Array.forEach ()
在 test_object_loop.js:44:30
在 Array.forEach ()
在对象。 (test_object_loop.js:42:26)
在 Module._compile (internal/modules/cjs/loader.js:1137:30)
在 Object.Module._extensions..js (internal/modules/cjs/loader.js:1157:10)

如何在具有特定类型的另一个对象中检索一个对象？

Answer 1

我不知道你为什么要使用如此嵌套的循环，但为了得到 rename_fields 的值，请按照以下步骤操作：

最终您可以通过 main_object.plugin_configuration.rename_fields
因为 plugin_configuration 的类型定义为 PluginHandlerConfiguration 但是...
- plugin_configuration 可能是 { type: "not_required_configuration" }
  - 如果是这样，您无法访问它的 rename_fields 因为它没有这样的字段
- plugin_configuration 可能是 undefined
  - 如果是这样，您甚至无法访问其 type 字段

所以理论代码是这样的：

// Make sure `plugin_configuration` is not undefined
if (main_object.plugin_configuration) {
  // Make sure `plugin_configuration` has `rename_fields` field
  // by checking `type` field is "std_file"
  if (main_object.plugin_configuration.type === "std_file") {
    // Now you can safely access `rename_fields`
    const renameFields = main_object.plugin_configuration.rename_fields
  }
}

这2个if条件可以组合，如下更简单实用的代码：

if (main_object.plugin_configuration && main_object.plugin_configuration.type === "std_file") {
  const renameFields = main_object.plugin_configuration.rename_fields
}

Typescript - 在另一个对象中检索一个对象

Typescript - Retrieve an object inside another object

javascript

object

types

typeguards