TypeScript 类型守卫不充分的解决策略 | 确保类型安全

在 TypeScript 中，类型守卫（Type Guards）是确保类型安全的重要机制。如果类型守卫不充分，可能会导致运行时错误或类型推断不准确。以下是一些解决类型守卫不充分问题的策略：

1. 使用更精确的类型守卫

• typeof 和 instanceof：确保使用 typeof 和 instanceof 来检查基本类型和类的实例。
• 自定义类型守卫：通过自定义类型守卫函数来更精确地判断类型。

function isString(value: unknown): value is string {
    return typeof value === 'string';
}

function isNumber(value: unknown): value is number {
    return typeof value === 'number';
}

function processValue(value: unknown) {
    if (isString(value)) {
        console.log(value.toUpperCase());
    } else if (isNumber(value)) {
        console.log(value.toFixed(2));
    } else {
        console.log('Unsupported type');
    }
}

2. 使用联合类型和交叉类型

• 联合类型：通过联合类型明确可能的类型范围。
• 交叉类型：通过交叉类型组合多个类型的特性。

type StringOrNumber = string | number;

function processValue(value: StringOrNumber) {
    if (typeof value === 'string') {
        console.log(value.toUpperCase());
    } else {
        console.log(value.toFixed(2));
    }
}

3. 使用 in 操作符

• in 操作符：用于检查对象是否具有特定属性。

interface Dog {
    bark(): void;
}

interface Cat {
    meow(): void;
}

function isDog(pet: Dog | Cat): pet is Dog {
    return 'bark' in pet;
}

function makeSound(pet: Dog | Cat) {
    if (isDog(pet)) {
        pet.bark();
    } else {
        pet.meow();
    }
}

4. 使用 as 断言

• 类型断言：在确保类型安全的情况下，使用 as 进行类型断言。

function processValue(value: unknown) {
    if (typeof value === 'string') {
        const strValue = value as string;
        console.log(strValue.toUpperCase());
    }
}

5. 使用 never 类型

• never 类型：用于确保所有可能的类型都被处理。

function assertNever(value: never): never {
    throw new Error(`Unexpected value: ${value}`);
}

function processValue(value: string | number) {
    if (typeof value === 'string') {
        console.log(value.toUpperCase());
    } else if (typeof value === 'number') {
        console.log(value.toFixed(2));
    } else {
        assertNever(value); // 确保所有类型都被处理
    }
}

6. 使用 unknown 类型

• unknown 类型：比 any 更安全，需要显式类型检查。

function processValue(value: unknown) {
    if (typeof value === 'string') {
        console.log(value.toUpperCase());
    } else if (typeof value === 'number') {
        console.log(value.toFixed(2));
    } else {
        console.log('Unsupported type');
    }
}

7. 使用 TypeScript 的严格模式

• 严格模式：启用 TypeScript 的严格模式（strict: true），可以捕获更多潜在的类型错误。

{
    "compilerOptions": {
        "strict": true
    }
}

8. 使用工具函数和库

• 工具函数：使用像 lodash 或 ramda 这样的库提供的类型检查工具函数。
• 类型检查库：使用 io-ts 或 zod 等库进行更复杂的类型验证。

import * as t from 'io-ts';

const User = t.type({
    id: t.number,
    name: t.string,
});

type User = t.TypeOf<typeof User>;

function processUser(user: unknown) {
    if (User.is(user)) {
        console.log(user.name);
    } else {
        console.log('Invalid user');
    }
}

9. 代码审查和测试

• 代码审查：通过代码审查确保类型守卫的充分性。
• 单元测试：编写单元测试覆盖所有可能的类型情况，确保类型守卫的正确性。

10. 使用 TypeScript 的高级类型

• 条件类型：使用条件类型进行更复杂的类型推断。
• 映射类型：使用映射类型动态生成类型。

type NonNullable<T> = T extends null | undefined ? never : T;

function processValue<T>(value: T) {
    if (value !== null && value !== undefined) {
        const nonNullableValue: NonNullable<T> = value;
        console.log(nonNullableValue);
    }
}

通过以上策略，可以有效地解决 TypeScript 中类型守卫不充分的问题，确保代码的类型安全和可靠性。