软件系统定制开发TypeScript面试题

与JavaScript软件系统定制开发有什么不同

1.TypeScript 支持ES6
2.软件系统定制开发它支持强类型或静态类型、模块、软件系统定制开发可选参数等。
3.软件系统定制开发它支持面向对象的编程概念，如类、接口、继承、泛型等。
4.TypeScript软件系统定制开发有可选的参数特性。
5.软件系统定制开发它编译代码并在开发期软件系统定制开发间突出显示错误。
6.TypeScript支持模块。
7.TypeScript软件系统定制开发在编译时提供了错误检查功能。软件系统定制开发它将编译代码，软件系统定制开发如果发现任何错误，软件系统定制开发它将在运行脚本之前突软件系统定制开发出显示这些错误。

软件系统定制开发为什么要使用TypeScript?TypeScript相对于JavaScript的优势是什么？

TypeScript是JavaScript的超集，具有可选的类型并可以编译为纯JavaScript。

从技术上讲TypeScript就是具有静态类型的 JavaScript 。

向JavaScript添加静态类型的原因是什么？我想原因至少有三个：

• 您可以避免经典的错误 ‘undefined’ is not a function.
• 在不严重破坏代码的情况下，重构代码更容易。
• 使大型、复杂的应用程序源码更易阅读。

动态类型的自由特性经常会导致错误，这些错误不仅会降低程序员的工作效率，而且还会由于增加新代码行的成本增加而使开发陷入停顿。

TypeScript的优点

1.Typescript能够编译出一个能在所有浏览器上运行的JavaScript版本。
2.TypeScript总是在编译时强调错误，而JavaScript在运行时指出错误。
3.TypeScript支持强类型或静态类型
4.它使用基于类的面向对象编程。
5.它有助于代码结构。

TypeScript的缺点

1.TypeScript需要很长时间来编译代码
2.要使用任何第三方库，必须使用定义文件。并不是所有第三方库都有可用的定义文件。
3.类型定义文件的质量是一个问题，即如何确保定义是正确的?

TypeScript的内置类型

number、string、boolean、undefined、null、void

如何编译typeScript文件

tsc hello.ts

如何将多个ts文件合并为一个js文件

tsc --outFile comman.js file1.ts file2.ts file3.ts
这样就将三个ts文件合并到comman.js文件中

tsc --outFile file1.ts file2.ts file3.ts 
1

当我们不提供输出文件名像上面的命令，然后file2.ts和file3.ts将被编译，并将输出放在file1.ts中，现在是file1.ts包含JavaScript代码

如何自动编译ts文件，并且自动修改ts文件

tsc --watch file1.ts

TS的接口是什么意思？

接口是在我们的应用程序中充当契约的结构,它定义了要遵循的类的语法，这意味着实现接口的类必须实现它的所有成员.它不能被实例化，但是可以被实现它的类对象引用。

interface interface_name {              // 字段声明          // 方法声明}   
1
2
3
4

接口只是声明方法和字段，它不能用来建造任何东西。不需要将接口转换为JavaScript来执行，它们对运行时JavaScript没有任何影响。因此，它们的唯一目的是在开发阶段提供帮助。

如何理解TypeScript中的类

TypeScript是一种面向对象的JavaScript语言，支持编程特性，比如类、接口等。与Java一样，类是用于创建可重用组件的基本实体。它是一组具有公共属性的对象。类是创建对象的模板或蓝图。它是一个逻辑实体。“class”关键字用于在Typescript中声明一个类。

class Student {        studCode: number;        studName: string;        constructor(code: number, name: string) {                this.studName = name;                this.studCode = code;        }        getGrade() : string {            return "A+" ;        }    }  
1
2
3
4
5
6
7
8
9
10
11

类的特征：封装、继承、多态、抽象

TypeScript支持哪些面向对象的术语

1。模块
2.类
3.接口
4.继承
5.数据类型
6.成员函数

如何从TypeScript的子类调用基类构造函数

使用super()函数，从子类中调用父类或基类构造函数

如何在TypeScript中实现继承

继承是一种从另一个类获取一个类的属性和行为的机制。继承成员的类称为基类，继承这些成员的类称为。

class Shape {        Area:number        constructor(area:number) {           this.Area = area       }     }     class Circle extends Shape {        display():void {           console.log("圆的面积: "+this.Area)        }     }    var obj = new Circle(320);     obj.display()  
1
2
3
4
5
6
7
8
9
10
11
12
13
14

Typescript中的模块是什么

模块是创建一组相关变量、函数、类和接口等的强大方法。它可以在它们自己的范围内执行，而不是在全局范围内。换句话说，在模块中声明的变量、函数、类和接口不能在模块外部直接访问。

module module_name{      class xyz{          export sum(x, y){              return x+y;           }      }  }
1
2
3
4
5
6
7

TypeScript中的泛型

TypeScript泛型是一个提供创建可重用组件方法的工具。它能够创建可以处理多种数据类型而不是单一数据类型的组件。泛型在不影响性能或生产率的情况下提供类型安全性。泛型允许我们创建泛型类、泛型函数、泛型方法和泛型接口

function identity<T>(arg: T): T {          return arg;      }      let output1 = identity<string>("myString");      let output2 = identity<number>( 100 );    console.log(output1);    console.log(output2);  
1
2
3
4
5
6
7

TypeScript中const和readonly的区别是什么？枚举和常量的区别？

• const用于变量，readonly用于属性
• const在运行时检查，readonly在编译时检查
• 使用const变量保存的数组，可以使用push，pop等方法。但是如果使用Readonly Array声明的数组不能使用push，pop等方法

枚举和常量枚举的区别？

• 枚举会被编译时会编译成一个对象，可以被当作对象使用
• const 枚举会在 typescript 编译期间被删除，const 枚举成员在使用的地方会被内联进来，避免额外的性能开销

看看枚举和常量枚举会被编译成什么

//枚举enum Color {  Red,  Green,  Blue}var sisterAn = Color.Red// 会被编译成 JavaScript 中的 var sisterAn = Color.Red// 即在运行执行时，它将会查找变量 Color 和 Color.Red
1
2
3
4
5
6
7
8
9

// 常量枚举const enum Color {  Red,  Green,  Blue}var sisterAn = Color.Red// 会被编译成 JavaScript 中的 var sisterAn = 0// 在运行时已经没有 Color 变量
1
2
3
4
5
6
7
8
9

由此可见，使用 常量枚举 会有更好的性能。
定义的枚举，在经过编译器编译后是一个对象，这个对象我们可以在程序运行时使用，前面有说到。但有时定义枚举可能只是为了让程序可读性更好，而不需要编译后的代码，即不需要编译成对象。typescript中考虑到这种情况，所以加入了 const enum (完全嵌入的枚举)。

TS中的接口interface 和 type语句有什么区别

interface X {      a: number      b: string  }  type X = {      a: number      b: string  }
1
2
3
4
5
6
7
8

TypeScript中的类型断言？

类型断言可以手动指定一个值的类型

// 第一种let employeeCode = <number> code;//第二种let employeeCode = code as number
1
2
3
4
5

用途：
（1）类型断言用于实现覆盖编译器推断的类型。也就是说，当我们使用了类型断言，那么就相当于告诉编译器，我们比它更了解这个变量应该是什么类型，编译器不应该再继续报错
（2）将一个联合类型推断为其中一个类型
（3）将一个父类断言为更加具体的子类
（4）将任何一个类型断言为any
（5）将any断言为一个具体的类型

interface FooType{    a: string,    b: number,}const Foo = {} as FooTypeFoo.a = 'a'Foo.b = 1
1
2
3
4
5
6
7
8

类型断言不等于类型转换：

• 类型转换发生于运行时。
• 类型断言发生于编译时。

双重断言：

function handler(event: Event){    const element = (event as any) as HTMLElement}
1
2
3
4

TypeScript的as语法是什么？

as是TypeScript中类型断言的附加语法，引入as-语法的原因是原始语法()与JSX冲突

let empCode: any = 111;     let employeeCode = code as number; // 当使用带有JSX的TypeScript时，只允许as风格的断言。
1
2
3

TypeScript的Enum枚举类型？

枚举是一种数据类型，允许我们定义一组命名常量。使用枚举可以更容易地记录意图，或者创建一组不同的案例。它是相关值的集合，可以是数值或字符串值。

enum Gender {    Male,    Female    Other  }  console.log(Gender.Female); // : 1  // 我们还可以通过enum值的number值来访问它console.log(Gender[1]); // : Female 
1
2
3
4
5
6
7
8

TS中的声明合并

声明合并是编译器随后合并两个或多个独立声明的过程。将具有相同名称的声明为单个定义。这个合并的定义具有两个原始声明的特性。

• 最简单也是最常见的声明合并类型是接口合并

interface Cloner {      clone(animal: Animal): Animal;  }  interface Cloner {      clone(animal: Sheep): Sheep;  }  interface Cloner {      clone(animal: Dog): Dog;      clone(animal: Cat): Cat;  } 
1
2
3
4
5
6
7
8
9
10
11

将这三个接口合并为一个单独声明

interface Cloner {      clone(animal: Dog): Dog;      clone(animal: Cat): Cat;      clone(animal: Sheep): Sheep;      clone(animal: Animal): Animal;  } 
1
2
3
4
5
6

在TypeScript中不是所有的合并都允许。目前，类不能与其他类或变量合并。

TypeScript中?. , ?? , !： , _ , ** 等符号的含义？

• ?. 可选链
• ?? 类似与短路或，??避免了一些意外情况，0，NaN以及"",false被视为false值。只有undefind,null被视为false值。
• !. 在变量名后添加!，可以断言排除undefined和null类型
• _ , 声明该函数将被传递一个参数，但您并不关心它
• !: 待会分配这个变量，ts不要担心
• ** 求幂