移除TypeScript代码中的'as'关键字，优化update方法实现

原代码里的as关键字是因为TypeScript无法关联changedValues集合与可选参数的存在性。通过引入中间变量存储处理后的有效值，能让类型推导更清晰，无需再用as做类型断言，同时保留原有代码结构：

export class AccessProfile {
    id!: number;
    active!: boolean;
    name!: string;
    createdAt!: Date;
    createdBy!: User | null;
    createdFrom!: SystemModule;
    updatedAt!: Date;
    updatedBy!: User | null;
    updatedFrom!: SystemModule;
    hierarchy!: number | null;
    permissions!: Set<string>;

    public update(
        {
            updatedFrom,
            updatedBy = null,
            name,
            active,
            hierarchy,
            permissions
        }: {
            updatedFrom: SystemModule,
            updatedBy?: DiphycUser | null,
            name?: string,
            active?: boolean,
            hierarchy?: number | null,
            permissions?: Set<string>,
        }
    ) {
        const changedValues = new Set<string>();
        // 定义中间变量存储处理后的有效值
        let processedName: string | undefined;
        let processedActive: boolean | undefined;
        let processedHierarchy: number | null | undefined;
        let processedPermissions: Set<string> | undefined;

        if (name !== undefined) {
            processedName = AccessProfile.sanitizeName(name);
            if (this.name !== processedName) {
                AccessProfile.validateName(processedName);
                changedValues.add("name");
            }
        }

        if (active !== undefined && this.active !== active) {
            processedActive = active;
            changedValues.add("active");
        }

        if (hierarchy !== undefined) {
            processedHierarchy = AccessProfile.sanitizeHierarchy(hierarchy);
            if (this.hierarchy !== processedHierarchy) {
                AccessProfile.validateHierarchy(processedHierarchy);
                changedValues.add("hierarchy");
            }
        }

        if (permissions !== undefined && !permissionsAreEqual(permissions, this.permissions)) {
            processedPermissions = permissions;
            changedValues.add("permissions");
        }

        // 校验逻辑：中间变量类型明确，无需as
        if (changedValues.has("hierarchy") && changedValues.has("permissions")) {
            AccessProfile.validateHierarchyAndPermissions({
                hierarchy: processedHierarchy!,
                permissions: processedPermissions!
            });
        } else if (changedValues.has("hierarchy")) {
            AccessProfile.validateHierarchyAndPermissions({
                hierarchy: processedHierarchy!,
                permissions: this.permissions
            });
        } else if (changedValues.has("permissions")) {
            AccessProfile.validateHierarchyAndPermissions({
                hierarchy: this.hierarchy,
                permissions: processedPermissions!
            });
        }

        this.updatedFrom = updatedFrom;
        this.updatedBy = updatedBy;

        // 赋值逻辑：直接使用中间变量，无需as
        if (changedValues.has("name")) this.name = processedName!;
        if (changedValues.has("active")) this.active = processedActive!;
        if (changedValues.has("hierarchy")) this.hierarchy = processedHierarchy!;
        if (changedValues.has("permissions")) this.permissions = processedPermissions!;

        this.updatedAt = new Date();

        return this;
    }
}

关键改动说明 #

1. 中间变量存储处理结果：新增processedXxx系列变量，将每个可选参数清洗、校验后的结果单独存储，让TypeScript能明确跟踪变量类型。
2. 非空断言替代as：当changedValues包含对应键时，说明该参数已经过处理且必然有值，此时用非空断言!比as更精准，避免强制类型转换带来的风险。
3. 保留原有逻辑结构：所有清洗、校验、变更判断的逻辑完全保留，仅通过中间变量优化类型推导，不改动核心业务逻辑。

内容的提问来源于stack exchange，提问作者Cristofer