TS是什么？

TypeScript（简称 TS）是微软公司开发的一种基于 JavaScript （简称 JS）语言的编程语言。
它的目的并不是创造一种全新语言，而是增强 JavaScript 的功能，使其更适合多人合作的企业级项目。
TypeScript 可以看成是 JavaScript 的超集（superset），即它继承了后者的全部语法，所有 JavaScript 脚本都可以当作 TypeScript 脚本（但是可能会报错），此外它再增加了一些自己的语法。
TypeScript 对 JavaScript 添加的最主要部分，就是一个独立的类型系统。

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

---

Ts编译

JavaScript 的运行环境（浏览器和 Node.js）不认识 TypeScript 代码。所以，TypeScript 项目要想运行，必须先转为 JavaScript 代码，这个代码转换的过程就叫做“编译”（compile）。

TypeScript 官方没有做运行环境，只提供编译器。编译时，会将类型声明和类型相关的代码全部删除，只留下能运行的 JavaScript 代码，并且不会改变 JavaScript 的运行结果。
因此，TypeScript 的类型检查只是编译时的类型检查，而不是运行时的类型检查。一旦代码编译为 JavaScript，运行时就不再检查类型了。

TypeScript 代码只涉及类型，不涉及值。所有跟“值”相关的处理，都由 JavaScript 完成。

在线编译TS:
官网的在线编译页面: TypeScript Playground。

tsc 编译器:
TypeScript 官方提供的编译器称为 tsc，用于将 TypeScript 脚本编译成 JavaScript 脚本。要在本地编译 TypeScript 代码，必须安装 tsc。根据约定，TypeScript 脚本文件使用 .ts 后缀名，而 JavaScript 脚本文件使用 .js 后缀名。tsc 的主要作用就是将 .ts 文件转换为 .js 文件。

---

Ts编译选项:

TypeScript 编译器 tsc 提供了多种选项来控制编译过程。以下是一些常用的选项和功能：

1. 实时监听文件变化
要实时监听 TypeScript 文件的变化，并在文件更改时自动重新编译，可以使用 -w（或 --watch）选项：

tsc app.ts -w

这会在文件修改时自动检测重新编译 app.ts。

2. 创建 tsconfig.json 文件
为了更方便地管理 TypeScript 项目的编译选项，可以创建一个 tsconfig.json 文件。通过在终端中运行以下命令，可以自动生成该文件：

tsc --init

生成的 tsconfig.json 文件包含了默认的编译选项

3. 监视所有 TypeScript 文件
在创建了 tsconfig.json 文件后，可以直接运行 tsc，它会监视所有在配置文件中指定的 TypeScript 文件的变化：

tsc

根据配置文件中的设置编译项目中的所有 TypeScript 文件，并在文件发生变化时自动重新编译。

4. 常用编译选项
–outDir : 指定输出目录，将编译后的文件放在指定的文件夹中。例如：

tsc --outDir dist

–target : 指定编译的目标 JavaScript 版本，如 ES5、ES6、ES2017 等。例如：

tsc --target ES6

–module : 指定使用的模块系统，如 commonjs、amd、es2015 等。例如：

tsc --module commonjs

–strict: 启用所有严格类型检查选项。这是一个很实用的选项，可以帮助提高代码的类型安全性。
–sourceMap: 生成源映射文件，便于调试 TypeScript 代码。
5. 其他常用命令
编译整个项目（使用 tsconfig.json）：

tsc

生成类型声明文件：

tsc --declaration

指定多个文件进行编译：

tsc file1.ts file2.ts

如何在项目中使用Ts?

1. 安装 TypeScript:

npm install typescript --save-dev

或者

yarn add typescript --dev

2. 创建 TypeScript 配置文件
在项目根目录中，您可以使用以下命令生成 tsconfig.json 文件：
用于配置 TypeScript 编译器的选项

npx tsc --init

3. 编写 TypeScript 代码
创建一个 .ts 文件:

// example.ts
const greet = (name: string): string => {
    return `Hello, ${name}!`;
};

console.log(greet('World'));

4. 编译 TypeScript 代码
使用tsc编译：

npx tsc

根据 tsconfig.json 中的配置编译所有的 TypeScript 文件，并生成相应的 JavaScript 文件。

npx 是 Node.js 包管理工具 npm,的一部分,主要功能是方便地运行在项目或全局安装的 npm 包，而无需事先安装这些包。

5. 运行编译后的 JavaScript 代码
编译完成后，您可以使用 Node.js 运行生成的 JavaScript 文件：

node example.js

总结

• TypeScript 不能直接运行：需要编译成 JavaScript。
• 安装 TypeScript：通过 npm 或 yarn 安装。
• 使用 tsconfig.json：配置 TypeScript 编译选项。
• 编写、编译和运行：使用 tsc 编译ts代码，并用 Node.js 运行编译后的 JavaScript。

---

为什么要使用 TS ? TypeScript 相对于 JavaScript 的优势是什么？

1. 静态类型检查
提前捕获错误: TypeScript 的静态类型系统允许开发者在编译时捕获类型错误，而不是在运行时。这有助于减少潜在的运行时错误，提高代码的可靠性。

let name: string = "Alice";
// name = 42; // 编译时错误

2. 更好的代码可读性和可维护性
清晰的类型定义: 通过显式定义变量和函数的类型，TypeScript 提高了代码的可读性，开发者能够更容易理解代码的意图。

function greet(person: { name: string }) {
    return `Hello, ${person.name}`;
}

3. 增强的 IDE(集成开发环境) 支持
自动完成和重构: TypeScript 由于其类型信息，可以提供更好的 IDE 支持，包括自动完成功能、重构工具和代码提示，从而提高开发效率。
4. 接口与类型别名
定义数据结构: TypeScript 允许使用接口和类型别名来定义复杂的数据结构，使得代码更加模块化和可重用。

interface User {
    id: number;
    name: string;
}
const user: User = { id: 1, name: "Alice" };

5. 面向对象编程特性
类和继承: TypeScript 提供了更强大的面向对象编程特性，如类、接口和访问修饰符，使得构建复杂应用程序变得更加直观。

class Animal {
    constructor(public name: string) {}
}

class Dog extends Animal {
    bark() {
        console.log(`${this.name} says woof!`);
    }
}

6. 泛型支持
灵活的函数和类: TypeScript 支持泛型，使得函数和类能够处理多种类型，同时保持类型安全。

function identity<T>(arg: T): T {
    return arg;
}

7. 更强的模块化
模块系统: TypeScript 强化了 JavaScript 的模块系统，支持 ES6 模块语法，使得代码组织更为清晰。

export class MyClass { }
import { MyClass } from './myClass';

8. 其他:

• 兼容性
  与 JavaScript 的兼容性: TypeScript 是 JavaScript 的超集，任何有效的 JavaScript 代码都是有效的 TypeScript 代码。这意味着可以逐步引入 TypeScript，而不需要重写现有的 JavaScript 代码。
• 社区和生态系统
  丰富的库支持: TypeScript 具有强大的社区支持，许多流行的 JavaScript 库（如 React、Angular 和 Vue）都提供了 TypeScript 类型定义，使得在这些框架中使用 TypeScript 变得更加容易。

---

ts 中有哪些类型？

• number:表示数字类型，包括整数和浮点数。
• string:表示字符串类型，用于表示文本。
• boolean:表示布尔值，只有两个可能的值：true 或 false。
• 字面量:表示具体的值，例如特定字符串或数字。

let direction: "up" | "down" | "left" = "up"; // 只能是这三个值中的一个

• any :表示任何类型，允许赋值为任何类型，通常用于不确定类型的情况。使用 any 会失去类型检查。

let data: any = 42;
data = "Hello"; // 合法

• unknown:表示未知类型，类似于 any，但在使用之前必须进行类型检查，提供更严格的类型安全。

let value: unknown = 30;
// let str: string = value; // 错误，必须先检查类型
if (typeof value === "string") {
    let str: string = value; // 现在合法
}

• void :表示没有任何类型，通常用于函数没有返回值的情况。

function logMessage(message: string): void {
    console.log(message);
}

• never :表示永远不会有任何类型，通常用于函数抛出错误或无限循环的情况。

function throwError(message: string): never {
    throw new Error(message);
}

• object:表示非原始类型的引用类型，主要用于表示对象。

let person: object = { name: "Alice", age: 30 };

• array :表示数组类型，可以使用类型后跟 [] 表示数组。

let numbers: number[] = [1, 2, 3];
let names: string[] = ["Alice", "Bob"];

• tuple :表示固定数量、不同类型的数组，允许在同一数组中包含不同类型的元素。

let tuple: [string, number] = ["Alice", 30];
  enum :用于定义一组命名的常量，通常用于表示一组相关的值。
enum Direction {
    Up,
    Down,
    Left,
    Right
}

let dir: Direction = Direction.Up; // dir 的值为 0

---

any 和 unknown的区别是？

any 和 unknown 是 TypeScript 中的两种特殊类型，它们都可以用于表示不确定的类型，但它们之间有一些重要的区别。以下是详细的对比：
1. 类型安全
any:
允许赋值为任何类型，使用 any 时，TypeScript 会放弃对该变量的类型检查。
这可能导致运行时错误，因为编译器无法提供任何类型安全保障。

let value: any = "Hello";
value = 42; // 合法
let result = value.toUpperCase(); // 可能导致运行时错误

unknown:
也可以赋值为任何类型，但在使用 unknown 类型时，必须先进行类型检查。
这提供了更好的类型安全，因为 TypeScript 强制开发者在使用之前确认变量的实际类型。

let value: unknown = "Hello";
value = 42; // 合法

// 需要类型检查
if (typeof value === "string") {
    let result = value.toUpperCase(); // 现在合法
}

2. 使用场景
any:
通常用于快速原型开发或在不确定类型时，或者在需要临时忽略类型检查的情况下使用。不过，过度使用 any 可能会影响代码的可维护性和安全性。
unknown:
更适合用于需要保留类型安全的场景，当你确实需要处理未知类型但希望强制进行类型检查时使用。
3. 总结
any:
(1). 放弃类型检查，允许任何类型。
(2). 可能导致潜在的运行时错误。
unknown:
(1). 保留类型安全，强制进行类型检查。
(2). 更安全的选择，适用于处理不确定类型的情况。

代码示例:

// 使用 any
let anyValue: any = 5;
anyValue = "Now I'm a string"; // 合法
let length = anyValue.length; // 可能在运行时出错

// 使用 unknown
let unknownValue: unknown = 5;
unknownValue = "Now I'm a string"; // 合法

// 必须进行类型检查
if (typeof unknownValue === "string") {
    let length = unknownValue.length; // 现在合法
}

总的来说，尽量避免使用 any，而在处理不确定类型时，优先选择 unknown 以提高代码的安全性和可维护性。

---

void 和 never 的区别是？

void 和 never 是 TypeScript 中的两种特殊类型，它们在表示函数的返回值时有不同的含义和用途。以下是这两者之间的主要区别：
1. 定义
void:
表示函数没有返回值。使用 void 的函数可以正常结束，但不返回任何值。
常用于那些只执行某些操作而不需要返回结果的函数。

function logMessage(message: string): void {
    console.log(message);
}

never:
表示函数永远不会有返回值。使用 never 的函数可能会抛出错误、进入无限循环，或在某种情况下永远不返回。
常用于那些会导致程序终止的函数，例如抛出异常的函数。

function throwError(message: string): never {
    throw new Error(message);
}

function infiniteLoop(): never {
    while (true) {}
}

2. 使用场景
void:
适用于那些完成操作但没有返回结果的函数。比如打印日志、更新 UI 等场景。
never:
适用于那些不正常结束的函数，例如抛出错误或实现无限循环的函数。
3. 编译器行为
void:
如果你尝试返回一个值（如 return 42;）的函数会导致编译错误。
never:
在任何情况下都不应该返回，因此不会有正常的返回语句。试图返回任何值都会导致编译错误。
4. 示例

// void 示例
function doNothing(): void {
    // 不返回任何值
}

// never 示例
function throwError(message: string): never {
    throw new Error(message); // 永远不会返回
}

// 下面的函数将导致编译错误
function invalid(): never {
    return 42; // 错误：类型“number”的值不能赋给类型“never”
}

5. 总结
void:
(1).表示函数没有返回任何值。
(2). 函数可以正常结束。

never:
(1). 表示函数永远不会正常返回。
(2). 通常用于抛出错误或进入无限循环的函数。

---

TypeScript中的访问修饰符有哪些？

访问修饰符	类内可见	子类中可见	通过类实例对外部可见
公共（Public）	是	是	是
受保护的（Protected）	是	是	否
公共（Public）	是	否	否

1. Public:默认情况下，类的所有成员（属性和方法）都是公共的。
2. Private:私有访问修饰符不能在其包含类之外访问。它确保类成员仅对其中包含的类可见。
3. protected:受保护的访问修饰符只能在当前类及其子类中访问。我们不能从包含它的类的外部访问它。
4. readonly :只读修饰符 我们可以通过使用只读修饰符使类、类型或接口的属性只读。 这个修饰符需要在声明时或构造函数中初始化。我们也可以从类的外部访问只读成员，但其值不能被改变。

class Company {
 readonly country: string = "India";
 readonly name: string;

 constructor(contName: string) {
 this.name = contName;
 }
 showDetails() {
 console.log(this.name + " : " + this.country);
 }
}

let comp = new Company("JavaTpoint");
comp.showDetails(); // JavaTpoint : India

comp.name = "TCS"; //Error, name can be initialized only within constructor

---

什么是接口，它在面向对象编程中的作用是什么？

面向对象编程（OOP）中，接口（Interface）是一种定义类应该遵循的协议或约定的结构。接口指定了类所需实现的方法，但不提供其具体的实现。接口的作用在于提供一种方式，让不同的类可以以统一的方式进行交互。

接口的特点:

1. 只定义方法: 接口定义了方法的签名（名称、参数和返回类型），但不包含方法的实现。
2. 多重继承: 一个类可以实现多个接口，允许更灵活的设计，避免了单继承的限制。
3. 契约: 接口可以被视为一个契约，表示实现该接口的类承诺实现接口中定义的所有方法。

接口的作用:

1. 提高代码的可维护性: 使用接口可以使代码更易于维护和扩展。因为接口定义了一个标准，任何实现该接口的类都可以被视为同一类型。
2. 支持多态性: 接口是实现多态性的关键。通过接口，可以创建方法，这些方法可以接受接口类型的参数，从而允许不同的对象在运行时被替换。
3. 解耦合: 接口提供了一种解耦合的方式。客户端代码可以依赖于接口，而不是具体的实现类。这使得更改实现类不会影响使用该接口的代码。
4. 代码复用: 接口允许不同类之间共享相同的方法签名，从而促进代码复用。

---

在 TypeScript 的接口定义中,除了使用数字索引签名之外,其他几种常见的索引签名类型:

interface namelist {
[index:number]:string
}

对应的：

let nameList: NameList = {
  0: "John",
  1: "Jane",
  2: "Bob",
  // 键必须是数字,值必须是字符串
};

---

最后一个联合类型是返回值为string的函数表达式

interface RunOptions { 
    program:string; 
    commandline:string[]|string|(()=>string); 
} 

---

字符串索引签名:

interface StringIndexedObject {
  [key: string]: any;
}

let obj: StringIndexedObject = {
  foo: 123,
  bar: "hello"
};

这种类型可以用来描述一个键为字符串、值可以是任意类型的对象。

---

联合类型索引签名:

interface MyObject {
  [key: string | number]: string;
}

let obj: MyObject = {
  foo: "bar",
  123: "hello"
};

这种类型可以接受字符串或数字作为键,但值必须是字符串类型。

---

只读索引签名:

interface ReadonlyObject {
  readonly [key: number]: string;
}

let obj: ReadonlyObject = {
  0: "foo",
  1: "bar"
};
obj[0] = "baz"; // Error: Cannot assign to index signature

这种类型的索引签名创建了一个只读对象,不允许修改其属性。

---

可选索引签名:

interface OptionalObject {
  [key: string]?: string;
}

let obj: OptionalObject = {
  foo: "bar"
};
obj.baz; // undefined

这种类型的索引签名允许对象包含可选属性。

---

除了上述这些,还可以在接口中同时使用多种索引签名类型。例如:

interface MixedObject {
  [key: string]: any;
  [index: number]: string;
}

这个接口描述了一个既可以使用字符串键访问任意类型的值,也可以使用数字索引访问字符串类型的值的对象。

---

Type 和 interface 有什么区别？

1. 基本定义
type:
用于定义类型别名，可以是基本类型、联合类型、元组、对象类型等。

type Point = {
    x: number;
    y: number;
};

interface:
用于定义对象的结构和类型，主要用于描述对象的形状和类的接口。

interface Point {
    x: number;
    y: number;
}

2. 扩展和实现
type:
使用交叉类型（&）来实现类型的组合。

type A = { a: number };
type B = { b: number };
type C = A & B; // C 具有 a 和 b 属性

interface:
通过扩展（extends）来实现接口的组合或继承。

interface A {
    a: number;
}
interface B {
    b: number;
}
interface C extends A, B { } // C 继承了 A 和 B

3. 合并声明
type:
不支持同名的合并声明。如果定义了同名的类型，会导致错误。

type A = { a: number };
// type A = { b: number }; // 错误：Duplicate identifier 'A'.

interface:
支持同名的合并声明，将多个同名的接口合并成一个。

interface A {
    a: number;
}
interface A {
    b: number;
}
// 合并后的 A 接口具有 a 和 b 属性

4. 用途
(1). type:
更灵活，适用于定义简单的类型别名、元组、联合类型等。
适合复杂类型的组合和操作。
(2). interface:
更适合用于定义对象的形状和类的接口。
适合描述 API、库和模块的结构。

---

如何使用抽象类:

在 TypeScript 中，抽象类（abstract class）是一种不能被实例化的类，可以作为其他类的基类。抽象类通常用于定义一个类的基本结构和行为，子类需要实现抽象类中定义的方法。
使用抽象类的步骤:

1. 定义抽象类: 使用 abstract 关键字来定义类和方法。
2. 实现抽象方法: 子类必须实现抽象类中定义的抽象方法。

示例:
以下是一个使用抽象类的示例：

// 定义抽象类
abstract class Animal {
    constructor(public name: string) {}

    // 抽象方法，没有实现
    abstract makeSound(): void;

    // 具体方法
    move(): void {
        console.log(`${this.name} is moving.`);
    }
}

// 子类实现抽象类
class Dog extends Animal {
    makeSound(): void {
        console.log(`${this.name} says: Woof!`);
    }
}

class Cat extends Animal {
    makeSound(): void {
        console.log(`${this.name} says: Meow!`);
    }
}

// 使用抽象类和子类
const dog = new Dog('Buddy');
dog.makeSound(); // 输出: Buddy says: Woof!
dog.move();      // 输出: Buddy is moving.

const cat = new Cat('Whiskers');
cat.makeSound(); // 输出: Whiskers says: Meow!
cat.move();      // 输出: Whiskers is moving.

关键点

• 定义抽象类: 使用 abstract 关键字定义类和方法。
• abstract class Animal 表示 Animal 是一个抽象类。
• abstract makeSound(): void 表示此方法没有实现，子类必须提供实现。
• 子类实现: 子类必须实现所有抽象方法，否则会导致编译错误。
• 不能实例化: 抽象类不能被直接实例化，必须通过子类进行实例化。

适用场景
模板方法: 当您希望定义一个基类的基本行为，并强制子类实现特定的方法时，可以使用抽象类。
代码复用: 抽象类可以包含共享的实现代码，减少重复。
总结
抽象类在 TypeScript 中用于定义类的基本结构和行为。它提供了一个强制子类实现特定功能的机制，从而实现代码的组织和复用。

---

什么是泛型？如何在类和接口中使用泛型？

泛型（Generics）是一种强大的特性，允许在定义函数、类或接口时使用类型参数，从而使代码更加灵活和可重用。通过泛型，您可以在编写代码时不确定具体类型，而是在使用时确定具体类型。

为什么使用泛型？

• 类型安全: 泛型可以确保在编译时检查类型，减少运行时错误。
• 代码复用: 您可以编写能够处理各种数据类型的通用代码。
• 灵活性: 泛型提供了一种灵活的方式来定义函数和类，使其能够处理多种数据类型。

在类中使用泛型
可以在类的定义中引入类型参数。以下是一个简单的示例：

class Box<T> {
    private value: T;

    constructor(value: T) {
        this.value = value;
    }

    getValue(): T {
        return this.value;
    }
}

// 使用泛型类
const numberBox = new Box<number>(123);
console.log(numberBox.getValue()); // 输出: 123

const stringBox = new Box<string>('Hello');
console.log(stringBox.getValue()); // 输出: Hello

在接口中使用泛型
也可以在接口中定义泛型。以下是一个示例：

interface Pair<K, V> {
    key: K;
    value: V;
}

// 使用泛型接口
const pair1: Pair<number, string> = { key: 1, value: 'One' };
const pair2: Pair<string, boolean> = { key: 'isActive', value: true };

泛型约束
可以使用泛型约束限制类型参数的类型。例如，如果您希望类型参数必须是对象，您可以使用 extends 关键字：

interface Lengthwise {
    length: number;
}

function logLength<T extends Lengthwise>(item: T): void {
    console.log(item.length);
}

logLength({ length: 10 }); // 输出: 10

举例:获取长度的通用函数:

function getLength<T extends { length: number }>(target: T): number {
    return target.length;
}

// 测试
console.log(getLength('123')); // 输出: 3
console.log(getLength([1, 2, 3])); // 输出: 3
console.log(getLength({ length: 5 })); // 输出: 5

泛型约束:
T extends { length: number }: 这表示类型 T 必须具有一个 length 属性，且该属性的类型为number。这样就确保了传入参数可以是字符串、数组或任何具有 length 属性的对象。

函数实现:
return target.length;: 直接返回传入对象的 length 属性。

测试用例:
函数可以接受字符串、数组，甚至是具有 length 属性的其他对象。

总结

• 泛型允许在定义类和接口时使用类型参数，提高代码的灵活性和可重用性。
• 在类中使用泛型使得类可以处理多种数据类型。
• 在接口中使用泛型可以定义具有多种类型的对象结构。
• 泛型约束可以限制类型参数的类型，确保类型安全。

---

Ts命名空间

两个相同名字的学生，在不同的班级，为了明确区分它们，我们在使用名字之外，不得不使用一些额外的信息，比如他们的班级、姓（王小明，李小明），或者他们父母的名字等等。
命名空间定义了标识符的可见范围，一个标识符可在多个命名空间中定义，它在不同命名空间中的含义是互不相干的。这样，在一个新的命名空间中可定义任何标识符，它们不会与任何已有的标识符发生冲突，因为已有的定义都处于其他命名空间中。

TypeScript 中命名空间使用 namespace 来定义，语法格式如下：

namespace SomeNameSpaceName { 
   export interface ISomeInterfaceName {      }  
   export class SomeClassName {      }  
}

以上定义了一个命名空间 SomeNameSpaceName，如果我们需要在外部可以调用 SomeNameSpaceName 中的类和接口，则需要在类和接口添加 export 关键字。
要在另外一个命名空间调用语法格式为：

SomeNameSpaceName.SomeClassName;

如果一个命名空间在一个单独的 TypeScript 文件中，则应使用三斜杠 /// 引用它，语法格式如下：

/// <reference path = "SomeFileName.ts" />