TypeScript大厂面试真题详解与实战指南

本文详细介绍了TypeScript的基础概念与语法，包括变量声明、函数定义、类与接口以及泛型等核心特性，并深入解析了高级特性如装饰器和联合类型。此外，文章还提供了多个面试题解析与解答，涵盖基础语法、类与继承以及泛型与高级类型等知识点，旨在帮助读者掌握TypeScript大厂面试真题。

在TypeScript中，变量声明不仅是一个简单的名称绑定，还可以通过类型注解来指明变量的具体类型。这不仅提高了代码的可读性和可维护性，还可以帮助开发者在开发过程中尽早发现类型错误。TypeScript支持多种内置类型，包括但不限于：number、string、boolean、null、undefined、void、never、any和unknown等。

示例代码

// 声明一个数字类型的变量
let age: number = 30;

// 声明一个字符串类型的变量
let name: string = "张三";

// 声明一个布尔类型的变量
let isStudent: boolean = true;

// 声明一个null类型的变量
let nullValue: null = null;

// 声明一个undefined类型的变量
let undefinedValue: undefined = undefined;

// 声明一个void类型的变量
let voidValue: void = undefined;

// 声明一个never类型的变量
// 注意：never类型通常用于声明永远不会执行的函数返回值
function throwError(message: string): never {
    throw new Error(message);
}

// 声明一个任意类型的变量
let anyValue: any = 123;

// 声明一个未知类型的变量
let unknownValue: unknown = "未知类型";

TypeScript不仅支持函数的显式类型定义，还支持类型推断。这意味着，当函数返回值或函数参数类型没有显式声明时，TypeScript会根据上下文推断出合适的类型。类型推断是TypeScript的一个强大特性，它减少了代码冗余，提高了代码的简洁性。

示例代码

// 显式声明函数类型
function addNumbers(a: number, b: number): number {
    return a + b;
}

// 类型推断
function addNumbersInferred(a, b) {
    return a + b;
}

// 以下代码调用函数并将结果类型推断为number
let result = addNumbersInferred(1, 2);

在TypeScript中，类和接口是构建面向对象程序的核心。class关键字用于定义类，而interface关键字用于定义接口。类和接口可以共同使用来实现对象的创建与行为定义。类可以实现接口，类的属性和方法也可以被接口所约束。

类示例代码

class Person {
    name: string;
    age: number;

    constructor(name: string, age: number) {
        this.name = name;
        this.age = age;
    }

    printDetails() {
        console.log(`Name: ${this.name}, Age: ${this.age}`);
    }
}

let person = new Person("张三", 30);
person.printDetails();

接口示例代码

interface IPerson {
    name: string;
    age: number;
    printDetails: () => void;
}

class Person implements IPerson {
    name: string;
    age: number;

    constructor(name: string, age: number) {
        this.name = name;
        this.age = age;
    }

    printDetails() {
        console.log(`Name: ${this.name}, Age: ${this.age}`);
    }
}

let person = new Person("张三", 30);
person.printDetails();

泛型允许在定义函数、类或接口时使用类型变量。这些类型变量可以在之后被具体的类型替代，从而提高代码的复用性和灵活性。泛型通常用<T>表示类型变量。

泛型示例代码

// 泛型函数
function identity<T>(arg: T): T {
    return arg;
}

let output = identity<string>("Hello, TypeScript!");
console.log(output);

// 泛型类
class GenericNumber<T> {
    zeroValue: T;
    add: (x: T, y: T) => T;

    constructor(zeroValue: T, add: (x: T, y: T) => T) {
        this.zeroValue = zeroValue;
        this.add = add;
    }
}

let myGenericNumber = new GenericNumber<number>(0, function (x, y) { return x + y });
console.log(myGenericNumber.add(1, 2));

装饰器是一种特殊的声明，它可以附加到类声明、方法、访问器、属性或参数上。装饰器使用@符号表示，并接收一个元数据参数作为参数。装饰器可以用来修改类的行为或属性。

装饰器示例代码

function readonly(target: any, propertyName: string) {
    let value: any;
    Object.defineProperty(target, propertyName, {
        get: () => value,
        set: (newValue: any) => {
            if (value === undefined) {
                value = newValue;
            } else {
                throw new Error('Cannot modify the readonly property');
            }
        }
    });
}

class User {
    @readonly
    name: string = '张三';
}

let user = new User();
console.log(user.name); // 输出：张三
user.name = '李四'; // 抛出错误：Cannot modify the readonly property

在TypeScript中，联合类型和交叉类型提供了更细粒度的类型定义。联合类型表示变量可以是几种类型中的一种，而交叉类型则用于合并多个类型。

联合类型示例代码

let value: number | string;
value = 123;
value = "字符串";

交叉类型示例代码

interface A {
    a: number;
}

interface B {
    b: number;
}

let ab: A & B = { a: 1, b: 2 };

模板字符串是一种特殊的字符串字面量，可以在其中嵌入表达式。这使得字符串可以包含变量的值，从而动态生成字符串。模板字面量则是模板字符串的一种特例，用于生成复杂的字符串。

示例代码

let name = "张三";
let age = 30;
let greeting = `你好，${name}，你今年${age}岁了。`;
console.log(greeting); // 输出：你好，张三，你今年30岁了。

// 模板字面量
let templateLiteral = `张三：${name}`;
let result = templateLiteral.replace(/张三/g, '李四');
console.log(result); // 输出：李四：张三

// 更明确的模板字面量示例
let complexLiteral = `张三：${name}，${age}岁`;
let complexResult = complexLiteral.replace(/张三/g, '李四');
console.log(complexResult); // 输出：李四：张三，30岁

面试题1

问题：什么是类型推断？它如何工作？

解答：类型推断是TypeScript的一项特性，它允许编译器在没有明确类型注解的情况下推断出变量或函数参数的类型。类型推断基于变量的初始化值或函数的调用上下文进行。

面试题2

问题：在TypeScript中，any类型有什么用处？

解答：any类型允许类型检查被关闭。它经常用于那些你不能或不愿意指定类型的情况，例如，当你需要与非TypeScript代码进行交互时，或者当你正在操作一些难以用明确类型表示的数据时。

面试题3

问题：在TypeScript中，如何实现抽象类？

解答：可以通过在类声明前添加abstract关键字来创建抽象类。抽象类不能直接实例化，只能被其他类继承。抽象类可以包含抽象方法，这些方法在派生类中必须实现。

示例代码

abstract class Animal {
    abstract makeSound(): void;
    move(): void {
        console.log("移动");
    }
}

class Dog extends Animal {
    makeSound(): void {
        console.log("汪汪");
    }
}

let dog = new Dog();
dog.makeSound();
dog.move();

面试题4

问题：请解释一下类型保护。

解答：类型保护是TypeScript中的一种机制，用于确保一个表达式具有特定的类型。这通常通过类型保护函数或类型谓词来实现。类型保护函数通常返回一个布尔值，表示给定的表达式是否具有特定类型。

示例代码

function isString(arg: any): arg is string {
    return typeof arg === 'string';
}

let value = "hello";
if (isString(value)) {
    console.log(value.toUpperCase());
} else {
    console.log("不是字符串");
}

示例代码

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

let output = identity<string>("Hello, TypeScript!");
console.log(output);

TypeScript在前端开发中的应用主要体现在大型项目中，它提供了更好的类型安全和结构化编程。例如，可以使用TypeScript来创建React或Vue项目，或在Angular项目中使用TypeScript来增强代码的可读性和可维护性。

示例代码

// 使用TypeScript的React组件示例
import React from 'react';

interface Props {
    name: string;
}

const Greeting: React.FC<Props> = (props) => {
    return <h1>Hello, {props.name}!</h1>;
};

export default Greeting;

TypeScript同样适用于后端开发，特别是在Node.js环境中。TypeScript可以帮助开发者编写更安全、更易于维护的代码。例如，可以使用TypeScript来实现RESTful API，或者在Express项目中使用TypeScript。

示例代码

// 使用TypeScript的Express路由示例
import express, { Request, Response } from 'express';
import bodyParser from 'body-parser';

const app = express();
app.use(bodyParser.json());

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

let users: User[] = [];

app.get('/users', (req: Request, res: Response) => {
    res.json(users);
});

app.post('/users', (req: Request, res: Response) => {
    const user: User = req.body;
    users.push(user);
    res.send(`用户 ${user.name} 已添加`);
});

app.listen(3000, () => {
    console.log('服务器运行在端口3000');
});

// 处理数据库操作的示例
import express, { Request, Response } from 'express';
import bodyParser from 'body-parser';
import { Pool } from 'pg';

const app = express();
app.use(bodyParser.json());
const pool = new Pool({
    user: 'postgres',
    host: 'localhost',
    database: 'testdb',
    password: 'password',
    port: 5432,
});

app.get('/users', async (req: Request, res: Response) => {
    const result = await pool.query('SELECT * FROM users');
    res.json(result.rows);
});

app.post('/users', async (req: Request, res: Response) => {
    const user: User = req.body;
    await pool.query(
        'INSERT INTO users (name, email) VALUES ($1, $2)',
        [user.name, user.email]
    );
    res.send(`用户 ${user.name} 已添加`);
});

app.listen(3000, () => {
    console.log('服务器运行在端口3000');
});

面试题1

问题：TypeScript中的let和const有什么区别？

解答：let关键字用于声明变量，这些变量的值可以在声明后更改。而const用于声明常量，一旦赋值后，常量的值不能更改。

面试题2

问题：为什么使用TypeScript？

解答：使用TypeScript可以提高代码的可读性和可维护性，有助于团队协作和代码复用。此外，TypeScript提供了强大的类型检查功能，有助于在开发早期捕捉类型错误。

建议1：熟悉TypeScript的基础语法和高级特性。

建议2：了解TypeScript在项目中的应用，包括前端和后端。

建议3：准备一些编程挑战，例如LeetCode或CodeWars上的TypeScript题目。

错误1：对类型推断的理解不清晰。

错误2：混淆let和const的使用场景。

错误3：不了解装饰器、泛型等高级特性。

// 示例代码
function identity<T>(arg: T): T {
    return arg;
}

let output = identity<string>("Hello, TypeScript!");
console.log(output);

function readonly(target: any, propertyName: string) {
    let value: any;
    Object.defineProperty(target, propertyName, {
        get: () => value,
        set: (newValue: any) => {
            if (value === undefined) {
                value = newValue;
            } else {
                throw new Error('Cannot modify the readonly property');
            }
        }
    });
}

class User {
    @readonly
    name: string = '张三';
}

let user = new User();
console.log(user.name); // 输出：张三
user.name = '李四'; // 抛出错误：Cannot modify the readonly property

TypeScript在未来将继续保持其作为JavaScript的重要补充角色。随着TypeScript生态系统的发展和成熟，它将支持更多的语言特性和框架。此外，TypeScript的跨平台支持也将变得更加广泛，使其成为构建大型、复杂应用的理想选择。

建议1：通过慕课网（https://www.imooc.com/）上的免费课程学习TypeScript。

建议2：参与开源项目，了解实际项目中的TypeScript应用。

建议3：阅读TypeScript官方文档，深入理解其特性和最佳实践。

资源推荐：

• TypeScript官方文档
• TypeScript官方GitHub仓库
• TypeScript官方博客