如何键入接收通用联合类型数组的递归 function？ （打字稿）

Question

我正在编写一个 function ，它将遍历一系列对象，每个对象都包含一个数组。 数组中的每个项目都可能有一个condition function 检查是否应该添加它。

在尝试了一段时间并阅读了 generics 之后，我仍然卡住了！

我看到的错误： 'Property 'condition' / 'items' / 'sections' does not exist on type 'T'

谁能帮我完成这项工作？ 谢谢！

类型

export interface ContractDetailBO {
  sections: ContractSectionBO[];
  condition?: Function;
}

export interface ContractSectionBO {
  items: ContractSectionItemBO[];
  condition?: Function;
}

export interface ContractSectionItemBO {
  label: string;
  condition?: Function;
}




export interface ContractBO {
  encryptedContractId: string;
}

export type AnyBO = ContractDetailBO | ContractSectionBO | ContractSectionItemBO;

递归 Function

export const isOfType = <T>(
  varToBeChecked: any,
  propertyToCheckFor: keyof T
): varToBeChecked is T =>
  (varToBeChecked as T)[propertyToCheckFor] !== undefined;

export function populate<T extends AnyBO>(inputArray: T[], config: Config): T[] {
    const returnItems: T[] = [];
    inputArray.map((item: T) => {
        // include this item if the condition passes or is not defined
        if (item.condition === undefined || item.condition(config)) {
            const itemToPopulate = { ...item };

            // check type of item so we know the next array to iterate

            if (isOfType<ContractDetailBO>(item, 'sections')) {
                const nextArray: ContractSectionBO[] = populate(item.sections, config);
                itemToPopulate.sections = nextArray;
            }
            if (isOfType<ContractSectionBO>(item, 'items')) {
                const leaves: ContractSectionItemBO[] = populate(item.items, config);
                itemToPopulate.items = leaves;
            }
            returnItems.push(itemToPopulate);
        }
    });
    return returnItems;
}

const populatedBOs:ContractDetailBO = populate(myContractDetailBO, myContractBO)

Answer 1

你可以试试这个。

export type Config = {};

export interface BaseBO {
    condition?: (config: Config) => boolean;
}

export interface ContractDetailBO extends BaseBO {
    sections: ContractSectionBO[];
}

export interface ContractSectionBO extends BaseBO {
    items: ContractSectionItemBO[];
}

export interface ContractSectionItemBO extends BaseBO {
    label: string;
}

export type AnyBO = ContractDetailBO | ContractSectionBO | ContractSectionItemBO;

function isContractDetailBO(target: AnyBO): target is ContractDetailBO {
    return (target as ContractDetailBO).sections != null;
}
function isContractSectionBO(target: AnyBO): target is ContractSectionBO {
    return (target as ContractSectionBO).items != null;
}

export function populate<T extends AnyBO>(inputArray: T[], config: Config): T[] {
    const returnItems: T[] = [];
    for (const item of inputArray) {
        // include this item if the condition passes or is not defined
        if (!item.condition || item.condition(config)) {
            const itemToPopulate = { ...item };

            // check type of item so we know the next array to iterate

            if (isContractDetailBO(itemToPopulate)) {
                const nextArray: ContractSectionBO[] = populate(itemToPopulate.sections, config);
                itemToPopulate.sections = nextArray;
            }
            if (isContractSectionBO(itemToPopulate)) {
                const leaves: ContractSectionItemBO[] = populate(itemToPopulate.items, config);
                itemToPopulate.items = leaves;
            }
            returnItems.push(itemToPopulate);
        }
    }
    return returnItems;
}