TypeScript：实用程序类型

本篇文章主要是结合我之前面试的各种经历和实战开发中遇到的问题解决经验整理的，希望这篇《TypeScript：实用程序类型》对你有很大帮助！欢迎收藏，分享给更多的需要的朋友学习~

实用程序类型简介

typescript 中的实用程序类型允许您通过包含、排除或修改属性将现有类型转换为新类型。当您需要创建针对特定用例定制的类型定义而不重复代码时，这非常有用。

在 typescript 中使用 returntype 和 awaited

使用 typescript 时，您可能经常需要确定函数的返回类型。为此，typescript 提供了一种名为 returntype 的便捷实用程序类型。让我们来看看如何使用它，包括处理异步函数。

1。 获取函数的返回类型

要获取函数的返回类型，您可以使用 returntype 实用程序类型。这是一个例子：

function foo() {
const something:string = ""
return something;
}

function async foowithasync() {
const something:string = ""
return something;
} // will return promise<?> 

在此示例中：

foo 函数返回一个字符串。

returntype ：提取 foo 的返回类型，即 string。

2。 处理异步函数

处理异步函数时，返回类型是 promise。这是一个例子：

type myreturntype = returntype<typeof foo>

在此示例中：

foowithasync 函数返回一个解析为字符串的 promise。

returntype 提取返回类型，即 promise。

3。 使用 awaited 实现异步函数

如果您想获取异步函数返回的 promise 的解析类型，可以使用 awaited 实用程序类型。方法如下：

type myasyncreturntype = awaited<returntype<typeof foo>>

在此示例中：

returntype 提供 promise。

等待<returntype<typeof foowithasync>> 
// 将 promise 解析为其基础类型，即字符串。

摘要：

returntype：提取函数的返回类型。
等待：解析 promise 的类型。

export const getevents = async (user: user): promise<apiresponse> => {
const eventsapiurl: string = `${promos_end_points.events}`;
const apiinstance: axiosinstance = getaxiosinstance(user, api_services.promotions);
const response: axiosresponse = await apiinstance.get(eventsapiurl);
return response.data;
};

type offerevent = awaited<returntype<typeof getevents>>;

const initevent:offerevent = {event:[]}

通过组合这些实用程序类型，您可以有效地确定 typescript 中同步和异步函数的返回类型。

在 typescript 中使用条件类型提取返回类型

在 typescript 中，您可以使用条件类型和类型推断从函数类型中动态提取返回类型。这对于创建灵活且可重用的类型实用程序特别有用。让我们探讨一下它如何与 myreturntypewithcondition 类型别名一起使用。

type myreturntypewithcondition<t> = t extends (...args: any[]) => infer r ? r : never;

分解

conditional check: t extends (...args: any[]) => infer r

• 这部分检查 t 是否是函数类型。
• ...args: any[] 语法与任何函数签名匹配。
• infer r 关键字将函数的返回类型捕获到类型变量 r 中。

结果：？ r：从来没有

• 如果 t 是函数类型，则类型别名解析为 r，即函数的返回类型。
• 如果 t 不是函数类型，则解析为 never。

实际示例

考虑以下示例来查看其实际效果：

type examplefunction = (x: number, y: string) => boolean;
type returntype = myreturntypewithcondition<examplefunction>; 
// returntype will be boolean

在上面的示例中，returntype 将是布尔值，因为
示例函数是返回布尔值的函数类型。如果您使用非函数类型，则 returntype 将永远不会。

这种方法允许您创建高度适应性的类型实用程序，可以根据类型的结构推断和操作类型。这是 typescript 的一个强大功能，可以增强类型安全性和代码可维护性。

在 typescript 中组合和美化类型

使用 typescript 时，您经常需要组合多种类型或接口来创建更复杂的结构。这有时会导致类型难以阅读和管理。本文档将探讨如何组合两种类型、使嵌套类型更漂亮以及检查合并类型是否相等。

1。 结合两种类型

在 typescript 中组合两种类型是一项常见任务。您可以使用交集类型 (&) 来实现此目的。假设您有两个接口：offersummarywithoutconfig 和 offertypeconfiguration，并且您想要将它们组合起来。

export interface offersummarywithoutconfig {
  id: string;
  auditinfo: auditinfo;
  offerbasicinfo: offerbasicinfo;
  metadata: metadata;
  conditiongroupssummary: conditiongroupssummary[];
  rewardgroupssummary: rewardgroupssummary[];
  useroperations: actionpermission;
}

export interface offertypeconfiguration {
  id: number;
  name: string;
  description: string;
  configuration: configuration;
}

您可以使用交集类型 (&) 组合这两个接口：

type combinedtype = offersummarywithoutconfig & {
  offertypeconfiguration: offertypeconfiguration;
};

这将创建一个新类型，其中包含 offersummarywithoutconfig 和 offertypeconfiguration 中的所有属性。

2. 美化嵌套类型

合并类型时，生成的类型有时看起来很混乱且难以阅读。为了使这些类型更具可读性，您可以使用名为 prettify 的实用程序类型。

输入 prettify<t> = {[k in keyof t]: t[k]};

此实用程序类型迭代 t 类型的键并重建它，使类型定义更清晰、更易于阅读。

组合类型后，您可以使用 prettify 实用程序类型来清理生成的类型

type viewsummarywithconfiguration = prettify<combinedtype>;

3. 检查合并类型是否相等

为了确保合并后的类型完全符合您的预期，您可以使用实用程序类型来检查两个类型是否相同、精确或相等。

isexact：检查两种类型是否完全相同。

类型 isexact<t, u> = [t] 扩展 [u] ? ([u] 延伸 [t] ? true : false) : false;

isidentical：使用条件类型来比较两种类型。

类型 isidentical<t, u> = t 扩展 u ? (u 扩展 t ? true : false) : false;

isequal：确保两种类型具有相同的键。

类型 isequal<t, u> = keyof t 扩展 keyof u ？ (keyof u 扩展 keyof t ? true : false) : false;

您可以使用这些实用程序类型来检查 combinedtype 是否与其他类型 offersummary 相同、精确或相等。

要在编译时强制执行这些检查，您可以使用断言类型：

type assert<t extends true> = t;
type test1 = assert<checkisidentical>; // true checked on compile time
type test2 = assert<checkisexact>; // true checked on compile time
type test3 = assert<checkisequal>; // true checked on compile time

实际例子

让我们用一个实际的例子来总结一下：

// define the interfaces
export interface offersummarywithoutconfig {
  id: string;
  auditinfo: auditinfo;
  offerbasicinfo: offerbasicinfo;
  metadata: metadata;
  conditiongroupssummary: conditiongroupssummary[];
  rewardgroupssummary: rewardgroupssummary[];
  useroperations: actionpermission;
}

export interface offertypeconfiguration {
  id: number;
  name: string;
  description: string;
  configuration: configuration;
}

// combine the interfaces
type combinedtype = offersummarywithoutconfig & {
  offertypeconfiguration: offertypeconfiguration;
};

// prettify the combined type
type viewsummarywithconfiguration = prettify<combinedtype>;

// example usage
const example: viewsummarywithconfiguration = {
  id: '123',
  auditinfo: { /* ... */ },
  offerbasicinfo: { /* ... */ },
  metadata: { /* ... */ },
  conditiongroupssummary: [ /* ... */ ],
  rewardgroupssummary: [ /* ... */ ],
  useroperations: { /* ... */ },
  offertypeconfiguration: {
    id: 1,
    name: 'special offer',
    description: 'a special offer configuration',
    configuration: { /* ... */ }
  }
};

结论

通过使用 prettify 实用程序类型，您可以使嵌套类型更具可读性和管理性。使用交集类型 (&) 组合类型允许您创建易于使用的复杂结构。此外，使用 isexact、isidentical 和 isequal 等实用程序类型有助于确保合并的类型完全符合您的预期。

使用 typescript 实用程序类型：选择、省略、只读和部分

typescript 提供了一组强大的实用程序类型，可以帮助您创建更灵活和可重用的类型定义。我们将探讨四种基本的实用程序类型：选择、省略、只读和部分。我们将使用电子商务应用程序中的实际示例来说明如何在现实场景中应用这些实用程序。

让我们从我们将在本博文中使用的产品界面开始：

interface product {
  id: number;
  name: string;
  description: string;
  price: number;
  category: string;
  stock: number;
  createdat: date;
  updatedat: date;
} 

使用 pick 进行产品摘要

用例：在产品列表页面上显示产品摘要。

“选择”实用程序类型允许您通过从现有类型中选择特定属性来创建新类型。当您只需要属性的子集时，这非常有用。

示例：

type productsummary = pick<product, 'id' | 'name' | 'price'>;
// productsummary will only have 'id', 'name', and 'price' properties

const productsummary: productsummary = {
  id: 1,
  name: "laptop",
  price: 999.99
};

// this type is used to display a brief summary of products on the listing page.

使用 omit 用于产品表单

用例：创建用于添加新产品的产品表单，其中某些字段是自动生成的。

omit 实用程序类型允许您通过从现有类型中排除特定属性来创建新类型。当特定上下文中不需要某些属性时，这非常有用。

示例：

type productform = omit<product, 'id' | 'createdat' | 'updatedat'>;
// productform will have all properties of product except 'id', 'createdat', and 'updatedat'

const newproductform: productform = {
  name: "laptop",
  description: "a high-end gaming laptop",
  price: 999.99,
  category: "electronics",
  stock: 50
};

// this type is used for the product creation form where 'id', 'createdat', and 'updatedat' are not needed.

使用只读来获取不可变的产品详细信息

用例：确保从数据库获取产品详细信息后无法修改。

readonly 实用程序类型使类型的所有属性都变为只读，这意味着它们在设置后无法更改。这对于创建不可变对象很有用。

示例：

type readonlyproduct = readonly<product>;
// readonlyproduct will have all properties of product, but they will be read-only

const product: readonlyproduct = {
  id: 1,
  name: "laptop",
  description: "a high-end gaming laptop",
  price: 999.99,
  category: "electronics",
  stock: 50,
  createdat: new date(),
  updatedat: new date()
};

// this will cause an error because the properties are read-only
// product.price = 899.99;

// this type is used to ensure that product details fetched from the database are not modified accidentally.

使用 partial 进行产品更新

用例：更新产品详细信息，其中仅某些字段可能会更改。

部分实用程序类型使类型的所有属性都是可选的。当您需要为不需要所有属性的对象创建类型时，这非常有用。

示例：

type PartialProduct = Partial<Product>;
// PartialProduct will have all properties of Product, but they will be optional

const productUpdate: PartialProduct = {
  price: 899.99,
  stock: 45
};

// This type is used for the product update form where users can update any subset of the properties.

结论

pick、omit、readonly 和 partial 等实用程序类型是 typescript 中的强大工具，可帮助您创建更灵活和可重用的类型定义。通过理解和使用这些实用程序，您可以编写更清晰、更易于维护的代码。

请随意在您自己的项目中尝试这些实用程序类型，看看它们如何简化您的类型定义！

到这里，我们也就讲完了《TypeScript：实用程序类型》的内容了。个人认为，基础知识的学习和巩固，是为了更好的将其运用到项目中，欢迎关注golang学习网公众号，带你了解更多关于的知识点！