Ts的一些基础和技巧-优快云博客

本文链接：https://blog.youkuaiyun.com/w20041213/article/details/146152948

枚举类型使用技巧

常量枚举优化性能

常量枚举在编译阶段会被完全移除，直接内联其值，从而减少运行时的开销，适合在只需要枚举值而不需要枚举类型本身的场景使用。

typescript

const enum Direction {
    Up,
    Down,
    Left,
    Right
}

let myDirection = Direction.Up;
// 编译后不会有 Direction 这个对象，myDirection 直接是 0

字符串枚举增强可读性

字符串枚举为每个成员赋予一个字符串值，相比数字枚举，增强了代码的可读性，特别是在需要明确标识的场景。

typescript

enum Color {
    Red = "RED",
    Green = "GREEN",
    Blue = "BLUE"
}

let favoriteColor: Color = Color.Red;
console.log(favoriteColor); // 输出 "RED"

类型工具使用技巧

`Partial<T>`

Partial<T> 用于创建一个新类型，该类型的所有属性都是可选的。常用于处理部分更新对象的场景。

typescript

interface User {
    name: string;
    age: number;
    email: string;
}

function updateUser(user: User, partialUser: Partial<User>) {
    return { ...user, ...partialUser };
}

let user: User = { name: 'Alice', age: 25, email: 'alice@example.com' };
let updatedUser = updateUser(user, { age: 26 });

`Required<T>`

与 Partial<T> 相反，Required<T> 会将类型 T 的所有可选属性变为必需属性。

typescript

interface Options {
    color?: string;
    size?: number;
}

type RequiredOptions = Required<Options>;
// 现在 RequiredOptions 中的 color 和 size 都是必需属性

`Readonly<T>`

Readonly<T> 用于创建一个只读类型，即该类型的所有属性都不能被重新赋值。

typescript

interface Config {
    apiKey: string;
    timeout: number;
}

const readonlyConfig: Readonly<Config> = {
    apiKey: "12345",
    timeout: 5000
};
// 下面这行代码会报错，因为 readonlyConfig 是只读的
// readonlyConfig.apiKey = "newKey";

`Pick<T, K>`

Pick<T, K> 从类型 T 中选取一组属性 K 来构造一个新类型。

typescript

interface Person {
    name: string;
    age: number;
    address: string;
}

type PersonInfo = Pick<Person, 'name' | 'age'>;
// PersonInfo 只包含 name 和 age 属性

`Omit<T, K>`

Omit<T, K> 从类型 T 中移除一组属性 K 来构造一个新类型。

typescript

interface Product {
    id: number;
    name: string;
    price: number;
    description: string;
}

type ProductWithoutDesc = Omit<Product, 'description'>;
// ProductWithoutDesc 不包含 description 属性

异步编程技巧

为异步函数和 Promise 明确类型

在使用异步函数和 Promise 时，明确指定返回值的类型，有助于提高代码的可读性和可维护性。

typescript

async function fetchData(): Promise<string> {
    return new Promise((resolve) => {
        setTimeout(() => {
            resolve('Data fetched');
        }, 1000);
    });
}

(async () => {
    let data = await fetchData();
    console.log(data);
})();

处理异步错误

在异步代码中，使用 try...catch 块来捕获和处理错误，确保代码的健壮性。

typescript

async function getData() {
    try {
        let response = await fetch('https://example.com/api/data');
        let data = await response.json();
        return data;
    } catch (error) {
        console.error('Error fetching data:', error);
        throw error;
    }
}

类型推导与类型约束技巧

利用类型推导简化代码

TypeScript 具有强大的类型推导能力，在很多情况下可以省略类型注解，让代码更简洁。

typescript

let num = 10; // TypeScript 会自动推导 num 的类型为 number
function multiply(a: number, b: number) {
    return a * b;
}
let result = multiply(2, 3); // result 的类型会被推导为 number

泛型约束确保类型安全

在使用泛型时，通过约束泛型类型来确保泛型参数满足特定的条件。

typescript

interface HasLength {
    length: number;
}

function getLength<T extends HasLength>(arg: T) {
    return arg.length;
}

let strLength = getLength('hello');
let arrLength = getLength([1, 2, 3]);
// 下面这行代码会报错，因为数字没有 length 属性
// let numLength = getLength(123);

代码组织与架构技巧

分层架构设计

将项目按照功能划分为不同的层次，如数据访问层、业务逻辑层和表示层。在 TypeScript 中，可以使用类和接口来实现各层之间的解耦。

typescript

// 数据访问层
interface UserRepository {
    getUserById(id: number): Promise<User>;
}

class UserRepositoryImpl implements UserRepository {
    async getUserById(id: number) {
        // 模拟从数据库获取用户数据
        return { id, name: 'User' };
    }
}

// 业务逻辑层
class UserService {
    constructor(private userRepository: UserRepository) {}

    async getUserInfo(id: number) {
        let user = await this.userRepository.getUserById(id);
        return `User name: ${user.name}`;
    }
}

// 表示层
async function main() {
    let userRepository = new UserRepositoryImpl();
    let userService = new UserService(userRepository);
    let info = await userService.getUserInfo(1);
    console.log(info);
}

main();