[TypeScript] 将部分类型改写为向上兼容

1.首先

子类型是理解 TypeScript 的一个关键概念。

然而，

“哪一部分是哪一部分？”
“如果〇〇类型是◇◇类型的子类型，为什么〇〇类型的值可以是◇◇类型的值？”

因此，为了抑制亚型的轮廓，“书籍：面向有抱负的专业人士的 TypeScript 简介我写了一篇文章参考。

我不聪明，所以我很难理解它。

如果您有同样的情况，如果您能看到它，我将不胜感激。

如果您能指出我误解的地方，我将不胜感激。

2. 内容

1.首先
2. 内容
3.这篇文章会告诉你什么
4.环境
5、部分模具
　5.1. 什么是子类型？
　5.2. 部分类型是向上兼容的
　5.3. 向上兼容的条件（部分类型）
　5.4. 稍微复杂的向上兼容（部分类型）
六，结论
7. 参考

3.你可以从这篇文章中学到什么

• 亚型特征
• 子类型的条件
• 将子类型改写为向上兼容

4.环境

• 打字稿：4.7.4
• Node.js：16.15.1

5、部分模具

现在，让我们谈谈主题，“将部分类型重新表述为向上兼容的感觉很好。”

5.1. 什么是子类型？

这是一个表达两者相容性的概念。如果类型 S 的值也是类型 T 的值，则类型 S 是类型 T 的子类型。

书：面向有抱负的专业人士的 TypeScript 简介 Ryota Suzuki [作者]

作者也在书中写道
当我看到这个词时，我无法理解。

这个部分类型关于，
我想看看下面部分类型示例代码中的非工程师（NotEngineer）和工程师（Engineer）的例子。

部分类型示例代码

type NotEngineer = {
    name: string;
    year: number;
}

type Engineer = {
    name: string;
    year: number;
    programmingSkill: string;
}

const kakedashi: Engineer = {
    name: 'daishi',
    year: 1,
    programmingSkill: 'JavaScript'
};

const eigyou: NotEngineer = kakedashi;
console.log(eigyou); // { name: 'daishi', year: 1, programmingSkill: 'JavaScript' }

Engineer 类型是 NotEngineer 类型的子类型。

5.2. 子类型是向上兼容的

现在，让我们在查看前面代码的同时查看子类型关系。

部分类型示例代码

type NotEngineer = {
    name: string;
    year: number;
}

type Engineer = {
    name: string;
    year: number;
    programmingSkill: string;
}

const kakedashi: Engineer = {
    name: 'daishi',
    year: 1,
    programmingSkill: 'JavaScript'
};

const eigyou: NotEngineer = kakedashi;
console.log(eigyou); // { name: 'daishi', year: 1, programmingSkill: 'JavaScript' }

什么是部分类型？然而，如前所述
Engineer 类型是 NotEngineer 类型的子类型。

这就是为什么，
const eigyou: NotEngineer = kakedashi;
不会导致编译错误。

“为什么会出现编译错误？”
我认为这将是

（eigyo（销售），但是你有和kakedashi（新手工程师）一样的技能吗？←我觉得很正常……）

这是，
kakedasi 属于Engineer 类型，但也具有NotEngineer 类型的特征。

NotEngineer 类型是

• name 属性为 string 类型
• year（多年经验）属性为number类型

变成。

NotEngineer 类型没有定义除 name 和 year 之外的任何内容。
所以，除了name 和year有还是没有没问题。

然而，也许不吧不幸的是，访问该属性将导致编译错误。

（可能是“哪一个?”，但请这样想w）

Engineer 类型是

• name 属性与 string 类型相同 ← NotEngineer 类型
• year（多年经验）属性与number类型相同←NotEngineer类型
• programmingSkill（编程技巧）属性为string类型

是。

Engineer 类型满足 NotEngineer 类型。

这种类型的关系满足条件是子类型关系。

图表看起来像这样。

换句话说，

Engineer 类型是 NotEngineer 类型向上兼容是。

（这是一个看起来很火的内容，但这只是一个例子w）

这个向上兼容表达式是为有抱负的专业人士介绍 TypeScript”中描述的
"Engineer 类型是 NotEngineer 类型部分类型而不是表达“是
"Engineer 类型是 NotEngineer 类型向上兼容说“是”不是更合适吗？

（不知道是不是只有我一个人……）

5.3. 向上兼容的条件（部分类型）

向上兼容（部分类型）的条件是

1. Engineer 类型具有以下属性全部也出现在NotEngineer 类型中
2. 对于条件 1. 中的每个属性，NotEngineer 类型中的属性类型是 Engineer 类型中的属性类型。同类型

   另请参阅：面向有抱负的专业人士的 TypeScript 简介

   简而言之，

   NotEnginner 输入全部的财产什么时候类型也属于Enigineer 类型

   是时候了。

   正如我在上一张图中所写，

   

   这种情况满足向上兼容（部分类型）的条件。

   这意味着如果要使用NotEngineer 类型，可以使用Enginner 类型。

   5.4. 稍微复杂的向上兼容（部分类型）

   作为一个小应用程序，
   使用上面的 NotEngineer 和 Engineer 类型，查看团队类型 NotEngineerTeam 和 EngineerTeam。

   EngineerTeam 类型与NotEngineerTeam 类型具有向上兼容（部分类型）关系。

   复杂子类型示例代码

   type NotEngineer = {
       name: string;
       year: number;
   }
   
   type Engineer = {
       name: string;
       year: number;
       programmingSkill: string;
   }
   
   type NotEngineerTeam = {
       teamName: string;
       director: NotEngineer;
       chief: NotEngineer;
       employee: NotEngineer;
   }
   
   type EngineerTeam = {
       teamName: string;
       director: Engineer;
       chief: Engineer;
       employee: Engineer;
   }
   
   const backEndTeam: EngineerTeam = {
       teamName: 'backEndTeam',
       director: {
           name: 'butyou',
           year: 20,
           programmingSkill: 'TypeScript',
       },
       chief: {
           name: 'katyou',
           year: 10,
           programmingSkill: 'TypeScript',
       },
       employee: {
           name: 'kakedashi',
           year: 1,
           programmingSkill: 'JavaScript',
       },
   };
   
   const eigyouTeam: NotEngineerTeam = backEndTeam;
   
   console.log(eigyouTeam);
   
   /** 実行結果
    * {
    *   teamName: 'backEndTeam',
    *   director: {name: 'butyou', year: 20, programmingSkill: 'TypeScript'},
    *   chief: {name: 'katyou', year: 10, programmingSkill: 'TypeScript'},
    *   employee: {name: 'kakedashi', year: 1, programmingSkill: 'JavaScript'}
    * }
    */
   

   和之前一样
   const eigyouTeam: NotEngineerTeam = backEndTeam;
   不会导致编译错误。

   让我们看看是否满足向上兼容（部分类型）的两个条件。

   复杂的部分类型示例代码（仅限类型）

   type NotEngineerTeam = {
       teamName: string;
       director: NotEngineer;
       chief: NotEngineer;
       employee: NotEngineer;
   }
   
   type EngineerTeam = {
       teamName: string;
       director: Engineer;
       chief: Engineer;
       employee: Engineer;
   }
   

   第一个条件是
   “NotEngineerTeam 类型中存在的所有属性都存在于EngineerTeam 类型中”
   所以见面。

   问题是条件的第二个条件1.的性质是否相同。

   NotEngineerTeam 类型和EngineerTeam 类型teamName 属性都是string 类型，所以他们很满意。

   director 类型为 NotEngineerTeam 的属性是 NotEngineer 类型，
   EngineerTeam 类型的 director 属性属于 Engineer 类型。

   虽然乍一看似乎并不满足，
   Engineer 类型向上兼容（部分类型）NotEngineer 类型。
   也就是说，向上兼容（部分类型）的Engineer类型可以使用NotEngineer类型。
   你会满足条件。

   chief 属性，employee 属性相似。

   由于条件 1 和 2 都满足，
   EngineerTeam 类型可以说是NotEngineerTeam 类型的向上兼容（部分类型）。

   六，结论

   很难掌握哪个零件类型是哪个，
   向上兼容我可以通过用表达式替换它来理解。

   更兼容类型的对象可以使用更兼容类型的对象所以
   当我看到具有这样特征的代码时，我不想感到困惑。

   现在我了解了子类型的概念，我希望 TypeScript 的世界能够进一步扩展。

   如果您也可以阅读其他文章，我会很高兴?‍♂️

   感谢您阅读到最后。

   7. 参考

   书：面向有抱负的专业人士的 TypeScript 简介 Ryota Suzuki [作者]@unday

原创声明：本文系作者授权爱码网发表，未经许可，不得转载;

原文地址：https://www.likecs.com/show-308624053.html