重构 TypeScript

重构意味着更新源代码而不改变应用程序的行为。重构帮助您保持代码可靠、干净且易于维护。

移动重构

除了移动文件和文件夹之外，IntelliJ IDEA 还允许您移动 TypeScript 顶级符号。移动符号重构适用于 ES6 模块中的类、函数和变量。

移动类、函数或变量

选择要移动的符号。
按 F6 或从主菜单或选择的上下文菜单中选择重构 | 移动。或者，选择重构 | 重构此项或按 Ctrl+Alt+Shift+T ，然后从列表中选择移动。
移动模块成员对话框打开。
请指定目标文件，并选择要移动的成员。
默认情况下，IntelliJ IDEA 会自动将成员的可见性提升到所需级别。如果您希望保持可见性级别不变，请点击保留原样在可见性中。

上移类成员重构

上移类成员重构将类方法在类层次结构中上移——从当前类移动到它实现的超类或接口。

假设您有一个类 AccountingDepartment ，它扩展了一个抽象类 Department 并实现了一个接口 ReportingDepartment。

abstract class Department {
    constructor(public name: string) {
    }
    printName(): void {
        console.log("Department name: " + this.name);
    }
}

interface ReportingDepartment {
    generateReports(): void
}

class AccountingDepartment extends Department implements ReportingDepartment {
    constructor() {
        super("Accounting and Auditing");
    }
    printMeeting(): void {
        console.log("The Accounting Department meets each Monday at 10 a.m");
    }
    generateReports(): void {
        console.log("Generating accounting reports...");
    }
}
                         
  

示例 1：将类的方法移动到超类

在这个例子中，该 PrintMeeting() 方法被从 AccountingDepartment 移动到 Department。

abstract class Department {
    constructor(public name: string) {
    }
    printName(): void {
        console.log("Department name: " + this.name);
    }
    printMeeting(): void {
        console.log("The Accounting Department meets each Monday at 10 a.m");
    }
}

interface ReportingDepartment {
    generateReports(): void
}

class AccountingDepartment extends Department implements ReportingDepartment {
    constructor() {
        super("Accounting and Auditing");
    }
    generateReports(): void {
        console.log("Generating accounting reports...");
    }
}
                        
  

示例 2：将一个类方法移动到接口

在此示例中， PrintMeeting() 方法从 AccountingDepartment 类复制到 ReportingDepartment 接口。

abstract class Department {
    constructor(public name: string) {
    }
    printName(): void {
        console.log("Department name: " + this.name);
    }
}

interface ReportingDepartment {
    generateReports(): void
    printMeeting(): void
}
class AccountingDepartment extends Department implements ReportingDepartment {
    constructor() {
        super("Accounting and Auditing");
    }
    printMeeting(): void {
        console.log("The Accounting Department meets each Monday at 10 a.m");
    }
    generateReports(): void {
        console.log("Generating accounting reports...");
    }
}
            
  

将类的方法移动到超类或接口

请将文本光标放置在您想要上推成员的类中任意位置。
在主菜单或上下文菜单中选择重构 | 上移成员。 Pull Members Up 对话框打开。
请从列表中选择您要移动方法的超类或接口。
要向上抽取方法，请在要被向上拉取的成员列表中选中它旁边的复选框。如果适用，请选择方法旁边的设为 abstract 复选框。

重命名重构

除此之外，在任何语言环境中均可使用的重命名文件和文件夹功能，您还可以重命名类、方法、变量、参数和字段。 IntelliJ IDEA 更改符号在声明中的名称，并默认更改其在当前项目中的所有用法。

重命名重构是在原地执行的，但您可以按 Shift+F6 来在重命名对话框中配置重构范围。

要默认打开对话框，请打开设置对话框（Ctrl+Alt+S ），转到编辑器 | 代码编辑，并在指定重构选项区域中选择在模态对话框中选项。

在编辑器中，选择要重命名的类、方法、变量或字段，然后按 Shift+F6 或从上下文菜单中选择重命名。
在画布中指定符号的新名称。输入名称或从列表中选择一个合适的名字。
可选：
点击旁边的高亮符号以打开同时在其他位置重命名弹出窗口，并选中搜索注释和文本和搜索文本匹配项复选框以重命名该符号在注释、字符串文本和文本中的用法。
当您重命名参数时，同时在其他位置重命名弹出窗口和不可用。如需指定其他选项，请再次打开重命名对话框 Shift+F6。
可选：
要打开重命名对话框查看更多选项，请再次按 Shift+F6。
- 选中搜索注释和文本复选框，以重命名注释、文档注释和字符串字面量中的符号用法。
- 选中搜索文本匹配项复选框，可以重命名项目中 HTML 和其他文件中的匹配符号。
- 选中在 JavaScript 文件中搜索复选框以重命名生成的 JavaScript 代码中的符号用法。
- 选中搜索动态引用复选框以重命名符号的动态用法。
  如果选中搜索动态引用复选框，对话框将默认打开，直到您清除它。
  请注意，包括动态用法的重构可能会导致如下面示例中所示的错误重命名。这里 目标 在 console.log(e.target) 里可以更改为 myTarget ，因为 e 的类型是 any ，这意味着它也可以是 myInt。
  interface myInt { target: string } function onClick(e: any) { console.log(e.target); }
  interface myInt { myTarget: string } function onClick(e: any) { console.log(e.myTarget); }
为避免错误重命名，请在应用更改之前预览这些更改。
默认情况下，在重构预览工具窗口中，所有符号的动态用法都会被标记为排除，并分组到代码中对<symbol>的动态引用节点下。要将重构应用于某个用法，请从其上下文菜单中选择包含。

保持类名和所含文件一致性

当您重命名类时，IntelliJ IDEA 也建议重命名文件（如果它具有相同的名称）。如果您接受这个建议，IntelliJ IDEA 会在其他文件中的 import 语句中更新此文件的名称。

如果您拒绝此建议，您可以稍后随时使用重命名文件… 操作意图重命名该文件。如果您刚创建了一个新文件，但在开始输入类或接口时想出了一个更好的名称，这将非常有用。

另一个意图操作建议将该类移动到具有相应名称的新文件中。建议文件名的格式由文件名约定列表中选择的样式决定，可在代码样式：JavaScript页面上找到。

将文件名称与对应类的名称保持一致

将文本光标放置在类名处并按 Alt+Enter。
从意图列表中选择将文件重命名为 <class_name.ts> 以匹配类名或将类<class_name>移动到文件<class_name.ts>。

提取/引入重构

IntelliJ IDEA 提供各种提取重构，以引入参数、变量、常量、字段、方法和函数。要运行这些重构中的任何一个，选择要重构的表达式并选择重构 | <target>。您可以选择整个表达式或将插入点放在其中任何位置，IntelliJ IDEA 将帮助您进行选择。

Introduce Parameter

使用 Introduce Parameter 重构将函数调用中的表达式替换为参数。 IntelliJ IDEA 将相应地更新函数的声明和调用。新参数的默认值可以在函数体内初始化或通过函数调用传递。

假设您有一段代码，其中在函数 "Hello, " 中硬编码了 greeter()。

function greeter(firstName : String, lastName : String) {
    return "Hello, " + firstName + " " + lastName;
}

document.body.innerHTML = greeter("Jane","User");

通过引入参数重构，您可以将此硬编码的 "Hello, " 替换为一个 greeting 参数。新 greeting 参数可以提取为可选或必需。

示例 1：提取一个可选参数

一个新参数 greeting 被提取为可选参数。已使用函数默认参数语法将新参数添加到 greeter() 的定义中。 greeter() 的调用未更改。

function greeter(firstName : String, lastName : String, greeting = "Hello, ") {
    return greeting + firstName + " " + lastName;
}

document.body.innerHTML = greeter("Jane","User");

示例 2：提取必需的参数

在此示例中，一个新参数 greeting 被提取为必需参数。因此，相应的函数调用 (document.body.innerHTML = greeter(user); 随之更改。

function greeter(firstName : String, lastName : String, greeting: string) {
    return greeting + firstName + " " + lastName;
}

document.body.innerHTML = greeter("Jane", "User", "Hello, ");

引入参数

在编辑器中，将文本光标放置在您想要转换为参数的表达式内，然后按 Ctrl+Alt+P 或从上下文菜单中选择重构 | 引入参数。
或者，执行以下操作之一：
- 按 Ctrl+Alt+Shift+T 并选择 Introduce Parameter。
- 前往重构 | 提取 | 参数。
如果在当前文本光标位置检测到多个表达式，请从表达式列表中选择所需的表达式。
如果找到多个所选表达式的匹配项，请从发现多个事件列表中选择仅替换此项或替换所有匹配项。最后，将出现用于配置重构的弹出窗口。
选择生成 JSDoc 生成 JSDoc 注释块。如果您需要指定自定义默认参数值，这可能会有所帮助。
选择新参数将在何处初始化，并指定其默认值（如果适用）：
- 如果选中可选形参复选框，参数将在函数体中使用默认值进行初始化。
- 如果清除可选形参复选框，默认参数值将通过现有的函数调用传递。所有的函数调用将根据新的函数签名进行更改，并且一个参数初始化将被添加到函数体中。
最初，IntelliJ IDEA 接受调用重构的表达式作为默认值。在大多数情况下，您不需要更改它。如果仍然有必要，请在 JSDoc 注释中按照格式指定另一个默认值 @param <parameter name> - <default value>。
了解更多有关可选参数和默认参数的信息，请访问 TypeScript official website。
双击列表中的建议参数名称之一予以接受，或在红色画布的字段中指定一个自定义名称。按 Enter 准备。

选择重构模式

您可以在编辑器中（就地模式）提取参数如上所述或使用引入参数对话框。这两种方法非常相似，区别如下：

预览重构结果。
在对话框中，您可以点击预览，并在查找工具窗口的专用选项卡中查看预期的更改。在就地模式下，此功能不可用。
指定默认参数值。
在此对话框中，IntelliJ IDEA 在值字段中建议默认参数值，您可以接受建议或指定其他值。在就地模式下，IntelliJ IDEA 将重构调用的表达式视为默认参数值。要指定其他值，您必须使用 JSDoc 注释块。

引入变量

使用 Introduce Variable重构将表达式替换为函数作用域变量 (var)、块作用域变量 (let)或块作用域常量 (const)。此重构使您的源代码更易读、更易维护。它还可以帮助您避免使用硬编码常量而没有任何关于其值或目的的解释。

function Multiplication(a : number, b : number) {
    let d = (a + b) * (a + b);
    return d;
}

var e = Multiplication(4, 6);
                        
     

function Multiplication(a : number, b : number) {
    let c = a + b;
    let d = (c) * (c);
    return d;
}

var e = Multiplication(4, 6);

                        
     

引入变量

在编辑器中，选择要转换为变量的表达式，然后按 Ctrl+Alt+V 并从上下文菜单中选择重构 | 引入变量。
或者，执行以下操作之一：
- 按 Ctrl+Alt+Shift+T 并选择引入变量。
- 前往重构 | 提取 | 变量。
如果在当前文本光标位置检测到多个表达式，请从表达式列表中选择所需的表达式。
如果找到多个所选表达式的匹配项，请从发现多个事件列表中选择仅替换此项或替换所有匹配项。
最后，将出现用于配置重构的弹出窗口。
从列表中选择用于声明新变量的语句：
- 选择 var 来引入一个函数作用域变量。此变量可以在外层函数或在任何函数外声明。
- 选择 let 来引入一个块作用域变量。
- 选择 const 来引入一个块级作用域常量。
双击列表中的建议参数名称之一予以接受，或在红色画布的字段中指定一个自定义名称。按 Enter 准备。

选择重构模式

您可以直接在编辑器中（以原地模式）提取变量如上所述或使用变量引入对话框。默认情况下，IntelliJ IDEA 以就地模式运行“引入变量”重构。要使用提取变量对话框，请打开设置对话框（Ctrl+Alt+S ），转到编辑器 | 代码编辑，并在重构区域中选择在模态对话框中选项。

引入常量

使用 Introduce Constant 重构来将表达式替换为 constant。此重构使您的源代码更易读、更易维护。它还可以帮助您避免使用硬编码常量而没有任何关于其值或目的的解释。

假设您有一段包含硬编码 Department name: 的代码。

printName(): void {
    console.log("Department name: " + this.name);    }

通过“Introduce Constant”重构，您可以用常量替换硬编码的 Department name。提取常量的范围取决于新常量声明的上下文（在封闭方法内部、作为类的字段或不在任何类中）。

示例 1：引入的常量 departmentName 在封闭方法 printName() 中声明

printName(): void {
    console.log("Department name: " + this.name);
}
                    
     

printName(): void {
    const departmentName = "Department name: ";
    console.log(departmentName + this.name);
}
                    
     

示例 2：引入的常量被声明为外围类 AccountingDepartment 的 _departmentName 字段

class AccountingDepartment extends Department implements ReportingDepartment {
    name: string;

    printName(): void {
        console.log("Department name: " + this.name);
    }
}
                    
     

 class AccountingDepartment extends Department implements ReportingDepartment {
    name: string;

    private readonly _departmentName = "Department name: ";

    printName(): void {
        console.log(this._departmentName + this.name);
    }
}
                    
     

示例 3：引入的常量 departmentName 在任何类外声明

class AccountingDepartment extends Department implements ReportingDepartment {
    name: string;

    printName(): void {
        console.log("Department name: " + this.name);
    }
}
                    
     

abstract class Department {...}

const deparmentName = "Department name: ";

class AccountingDepartment extends Department implements ReportingDepartment {...}

引入常量

在编辑器中，选择要转换为常量的表达式并按下 Ctrl+Alt+C 或从上下文菜单中选择重构 | 引入常量。
或者，执行以下操作之一：
- 按 Ctrl+Alt+Shift+T 并选择引入常量。
- 前往重构 | 提取 | 常量。
如果在当前文本光标位置检测到多个表达式，请从表达式列表中选择所需的表达式。
选择新常量的作用范围：
- 局部常量将在封闭方法内声明，请参阅示例 1。
- 类字段将在当前类中声明，请参阅示例 2。
- 全局或模块常量将在任何类之外声明，请参阅示例 3。
如果 IntelliJ IDEA 检测到多个表达式，请选择更改所有出现的表达式还是仅更改调用重构的表达式。
双击列表中的建议参数名称之一予以接受，或在红色画布的字段中指定一个自定义名称。按 Enter 准备。

Introduce Field

Introduce Field 重构声明一个新的字段，并用选定的表达式将其初始化。原始表达式被字段的用法替换。

假设您有以下代码：

class Rectangle {
    constructor(public height: number, public width: number) {
        this.height = height;
        this.width = width;
    }

    get area() {
        return this.calcArea();
    }

    calcArea() {
        return this.height * this.width;
    }
}

                
   

在以下所有三个例子中，引入了相同的字段， _calcArea。这些示例说明了初始化所引入字段的三种不同方法。

示例 1：引入的字段 _calcArea 在封闭方法 getArea() 中初始化

class Rectangle {
    constructor(public height: number, public width: number) {
        this.height = height;
        this.width = width;
    }

    private _calcArea: number;

    get area() {
        this._calcArea = this.calcArea();
        return this._calcArea;
    }

    calcArea() {
        return this.height * this.width;
    }
}
                
   

示例 2：引入的字段 _calcArea 在声明中被初始化

class Rectangle {
    constructor(public height: number, public width: number) {
        this.height = height;
        this.width = width;
    }

    private _calcArea = this.calcArea();

    get area() {
        return this._calcArea;
    }

    calcArea() {
        return this.height * this.width;
    }
}
                
   

示例 3：引入的字段 _calcArea 在类的构造函数中初始化

class Rectangle {
    constructor(public height: number, public width: number) {
        this._calcArea = this.calcArea();
        this.height = height;
        this.width = width;
    }

    private _calcArea: number;

    get area() {
        return this._calcArea;
    }

    calcArea() {
        return this.height * this.width;
    }
}
                
   

介绍一个字段

在编辑器中，选择要转换为常量的表达式并按下 Ctrl+Alt+F 或从上下文菜单中选择重构 | 引入字段。
或者，执行以下操作之一：
- 按 Ctrl+Alt+Shift+T 并选择 Introduce Field。
- 前往重构 | 提取 | 字段。
如果 IntelliJ IDEA 检测到多个表达式，请选择更改所有出现的表达式还是仅更改调用重构的表达式。
在弹出窗口中，选择新字段的初始化位置：
- 当前方法，请参阅示例 1。
- 字段声明，请参见示例 2。
- 构造函数，请参见示例 3。请注意，如果您从字段初始化器调用重构，则此选项将被禁用。
在字段声明或构造函数中初始化时，可以使用 readonly修饰符引入新字段。要做到这一点，选中设为只读复选框。
请选择字段可见性，可用选项有公开、 private 和 protected。了解字段可见性修饰符详细信息，请参阅 TypeScript 官方网站
双击列表中的建议参数名称之一予以接受，或在红色画布的字段中指定一个自定义名称。按 Enter 准备。

选择重构模式

默认情况下，IntelliJ IDEA 在编辑器中直接运行引入字段重构（就地模式），如上所述。

要使用 Extract Field Dialog ，请打开设置对话框（Ctrl+Alt+S ），转到编辑器 | 代码编辑，并在重构区域中选择在模态对话框中选项。

提取方法

提取方法重构允许您使用提取的代码创建一个命名的方法或函数。当 Extract Method重构被调用时，IntelliJ IDEA会检测作为所选代码片段输入的变量以及作为其输出的变量。检测到的输出变量用作提取方法或函数的返回值。

示例 1：从另一个方法内的表达式中提取全局方法

在此示例中，从 let c = a + b; 表达式中提取了一个全局范围的方法 NewMethod()。提取方法的参数从 let c = a + b; 表达式中获取。

示例 1.1：生成函数声明

function MyFunction(a : number, b : number) {
    let c = a + b;
    let d = c * c;
    return d;
}
                    
     

function NewMethod(a: number, b: number) {
    let c = a + b;
    return c;
}

function MyFunction(a : number, b : number) {
    let c = NewMethod(a, b);
    let d = c * c;
    return d;
}
                    
     

示例 1.2：提取的函数在表达式内声明

function MyFunction(a : number, b : number) {
    let c = a + b;
    let d = c * c;
    return d;
}
                    
     

let NewMethod = function (a: number, b: number) {
    let c = a + b;
    return c;
};

function MyFunction(a : number, b : number) {
    let c = NewMethod(a, b);
    let d = c * c;
    return d;
}
                    
     

示例 2：在封闭方法内部声明提取方法

在此示例中，方法 NewMethod() 从 let c = a + b; 表达式中提取。目标范围 function MyFunction 已选择。

function MyFunction(a : number, b : number) {
    let c = a + b;
    let d = c * c;
    return d;
}
                        
     

function MyFunction(a : number, b : number) {
    let NewMethod = function () {
        let c = a + b;
        return c;
    };
    let c = NewMethod();
    let d = c * c;
    return d;
}
                        
     

示例 3：从任何方法之外的表达式中提取方法

从 var e = MyFunction(4, 6); 表达式中提取出一个 NewMethod() 方法，该表达式不在任何方法内。提取的方法是全局范围的。

var e = MyFunction(4, 6);

let NewMethod = function () {
    var e = MyFunction(4, 6);
};
NewMethod();
                    
     

提取函数

在编辑器中，选择一个代码片段转换成函数，然后按 Ctrl+Alt+M 或从上下文菜单中选择重构 | 提取方法。
或者，执行以下操作之一：
- 按 Ctrl+Alt+Shift+T 并选择提取方法。
- 前往重构 | 提取 | 方法。
所选的代码片段不一定必须是语句集。它也可能是代码中使用的一个表达式。
如果所选表达式在另一个函数内部，请从列表中选择目标作用域：
- 如果您选择全局，提取的函数将声明在任何函数之外，请参阅上面的示例 1。
- 要在当前包含函数内声明提取的函数，请选择 function <current enclosing function name> ，请参阅上面的示例2。
要打开具有更多选项的 Extract Function提取函数对话框，请再次按 Ctrl+Alt+M。在此对话框中，您可以选择提取的函数是通过生成的 function declaration声明，还是在表达式内部声明，并配置要作为参数传递的变量集。请参见上面的示例。

默认打开 Extract Function 对话框

打开设置对话框（Ctrl+Alt+S ），转到编辑器 | 代码编辑，并在重构区域中选择在模态对话框中选项。

提取类型别名

使用此重构将类型声明表达式转换为 type alias ，并将所有出现的表达式替换为此别名。

假设您有以下带有 { z: number } 类型声明的代码片段：

function returnsObj(): { x : number, y : {z : number} } {
    return null
}

function anotherObjectReturned(): {x : number, y : {z : number} } {
    return null
}                        
   

在下面的示例中，一个类型别名 MyNewAlias 被从 { z: number } 类型声明中提取出来：

 type MyNewAlias = { z : number };

function returnsObj(): { x : number, y : MyNewAlias } {
    return null
}

function anotherObjectReturned(): { x : number, y : MyNewAlias } {
    return null
}
                        
   

提取类型别名

在编辑器中，将文本光标置于您希望用类型别名替换的表达式内，然后从上下文菜单中选择重构 | 提取 Type Alias 或从主菜单中选择重构 | 提取 | 类型别名。
如果在当前文本光标位置检测到多个表达式，请从表达式列表中选择所需的表达式。
如果找到多个所选表达式的匹配项，请从发现多个事件列表中选择仅替换此项或替换所有匹配项。
在该字段中，输入类型别名的名称，然后按下 Enter 完成操作。

Extract Superclass

抽取超类重构会基于当前类的成员创建一个新的抽象类。所创建的抽象类会被自动扩展。

假设您有一个类 AccountingDepartment ，并且您希望其中的 printName() 方法将被重用。

class AccountingDepartment  {
    name: string;
    printName(): void {
        console.log("Department name: " + this.name);
    }
    printMeeting(): void {
        console.log("The Accounting Department meets each Monday at 10 a.m");
    }
    generateReports(): void {
        console.log("Generating accounting reports...");
    }
}
                
   

您可以提取一个超类 Department 并在其中包含 printName 和 名称 字段。

class Department {
    name: string;

    printName(): void {
        console.log("Department name: " + this.name);
    }
}

class AccountingDepartment extends Department {
    printMeeting(): void {
        console.log("The Accounting Department meets each Monday at 10 a.m");
    }
    generateReports(): void {
        console.log("Generating accounting reports...");
    }
}
                
   

提取超类

将文本光标置于您想提取超类的类中的任意位置。
从主菜单中选择重构 | 提取 | 超类或从上下文菜单中选择重构 | 提取超类。 Extract Superclass 对话框打开。
请指定新超类的名称，并选中您希望包括在其中的类成员旁边的复选框。
在目标文件字段中，指定新类所在的文件位置。默认情况下，该字段显示调用重构的当前文件路径。
选择 Extract Superclass. IntelliJ IDEA 创建一个新类，并使用 extends 标记源类。
要创建一个超类并将源类的引用替换为方法参数中的超类引用，请选择提取超类并在可能的地方使用。 IntelliJ IDEA 在重构预览面板的查找工具窗口中显示建议的更改。

Extract Interface

该 Extract Interface 重构基于当前类的成员创建新接口。创建的接口将自动实现。

假设您有一个类 AccountingDepartment 并且您期望其中的 generateReports() 方法将有其他实现。

abstract class Department {
    constructor(public name: string) {
    }
    printName(): void {
        console.log("Department name: " + this.name);
    }
}

class AccountingDepartment extends Department {
    constructor() {
        super("Accounting and Auditing");
    }
    printMeeting(): void {
        console.log("The Accounting Department meets each Monday at 10 a.m");
    }
    generateReports(): void {
        console.log("Generating accounting reports...");
    }
}
                         
   

您可以提取一个 DepartmentInterface 接口并将 generateReports() 包含在其中。

abstract class Department {
    constructor(public name: string) {
    }
    printName(): void {
        console.log("Department name: " + this.name);
    }
}

interface DepartmentInterface {
    generateReports(): void;
}

class AccountingDepartment extends Department implements DepartmentInterface {
    constructor() {
        super("Accounting and Auditing");
    }
    printMeeting(): void {
        console.log("The Accounting Department meets each Monday at 10 a.m");
    }
    generateReports(): void {
        console.log("Generating accounting reports...");
    }
}
                
   

提取接口

将文本光标置于您想要提取接口的类中的任何位置。
请选择重构 | 提取 | 接口从主菜单或重构 | 提取接口从上下文菜单。 Extract Interface 对话框打开。
指定新接口的名称，并选择您希望包含在其中的类成员旁边的复选框。
在目标文件字段中，指定新接口所在文件的位置。默认情况下，该字段显示调用重构的当前文件路径。
选择 Extract Interface. IntelliJ IDEA 创建一个新的接口，并将源类标记为其实现。
要创建一个接口并将方法参数中对源类的引用替换为对接口的引用，请选择尽可能提取接口并使用。 IntelliJ IDEA 在重构预览面板的查找工具窗口中显示建议的更改。
如果实例引用的某个方法或字段未在接口中定义，IntelliJ IDEA将不会建议替换它。

引入对象或数组析构

解构使您可以轻松地将数组和对象中的值解包到变量中。此功能具有非常简洁的语法，通常在您需要在应用程序中传递数据时使用。如需了解更多信息，请参阅 TypeScript official website。

在 IntelliJ IDEA 中，您可以使用意图操作调用解构 Alt+Enter。使用对象/数组解构替换操作，原始赋值将被移除。为了保留作业，请使用 Introduce object/array destructuring。

替换原始分配

将文本光标置于数组或对象中的值处，然后按 Alt+Enter。
从名单中选择替换为对象解构或替换为数组解构。
如果数组或对象中的某些值未被使用，这些元素将被跳过：

保留原始分配

将文本光标置于数组或对象中的值处，然后按 Alt+Enter。
从名单中选择介绍对象解构或介绍数组解构。

生成函数的解构参数

将文本光标放在函数的参数处，然后按 Alt+Enter。
从列表中选择将参数转换为对象。

内联重构

内联重构与提取重构相反。

示例 1：插入变量

Inline Variable 重构会用变量或常量的初始值替换其冗余使用。这种重构类型仅适用于块作用域和函数作用域的变量。

function Multiplication(a : number, b : number) {
    let c = a + b;
    let d = (c) * (c);
    return d;
}
                        
    

function Multiplication(a : number, b : number) {
    let d = ((a + b)) * ((a + b));
    return d;
}
                        
    

示例 2：内联方法

将内联方法/内联函数重构的结果是将方法或函数的主体放入其调用者的主体中；方法/函数本身被删除。

在下面的示例中， Sum() 的主体被放置在 Multiplication() 的主体内。

function Sum(a: number, b: number) {
    return a + b;
}

function Multiplication(a: number, b: number) {
    let d = Sum(a, b) * Sum(a, b);
    return d;
}

var e = Multiplication(4, 6);
                   
    

function Multiplication(a : number, b : number) {
    let d = (a + b) * (a + b);
    return d;
}

var e = Multiplication(4, 6);

进行 Inline 重构

在编辑器中，将文本光标放在要内联的符号处，然后按 Ctrl+Alt+N ，或从上下文菜单或主菜单中选择重构 | 内联。

“更改签名”重构

使用 Change Signature重构来更改函数的名称、可见性和返回类型，添加、删除、重新排序和重命名参数，并通过调用层次结构传播新参数。

您还可以使用 Introduce Parameter重构添加一个参数。

在下面的示例中，函数 eat() 被重命名为 feed() ，并引入了一个新的 布尔 参数 isMammal。

class Animal {
    constructor(age: number, name: string){
    }

    eat(food: string[]): void {
    }
}

let Max = new Animal(23, 'Max');
Max.eat(['Apple', 'Parsley']);
let Daisy = new Animal(12, 'Daisy');
Daisy.eat(['Pork', 'Fish']);
                        
    

class Animal {
    constructor(age: number, name: string){
    }

    feed(food: string[], isMammal: boolean = true): void {
    }
}

let Max = new Animal(23, 'Max');
Max.feed(['Apple', 'Parsley'], false);
let Daisy = new Animal(12, 'Daisy');
Daisy.feed(['Pork', 'Fish'], false);
                        
    

调用更改签名

在编辑器中，将文本光标放置在要重构的函数名称内，然后按 Ctrl+F6 或从上下文菜单或主菜单中选择重构 | 更改签名。更改签名对话框打开。

重命名函数

在更改签名对话框 Ctrl+F6 中，编辑名称字段。

更改函数的返回类型

在返回值类型字段中，指定函数返回值的类型。如果该字段为空，则返回类型将被视为 void。了解更多有关返回类型的信息，请访问 TypeScript 官方网站。

更改函数的可见性

从可见性列表中选择一个函数修饰符，可用的选项有 public（默认）、 private和 protected。

管理函数参数

在更改签名对话框 Ctrl+F6 中，使用参数表和其右侧的按钮：
- 要添加参数，请点击   Alt+Insert 并指定新参数的名称及其类型。指定参数的默认值或通过函数调用传递的值。
  如果有必要，把新参数传递给调用当前函数的函数。
- 要删除参数，请点击相应行中的任意一个单元格，然后点击   Alt+Delete。
- 要重新排序参数，使必需参数列在可选参数之前，请使用   Alt+Up 和   Alt+Down。更多信息，请访问 TypeScript official website。
- 若要重命名参数，请编辑名称字段。

沿调用层次传播参数

在更改签名对话框 Ctrl+F6 中，选择参数并点击。选择传播新参数的方法对话框打开。左侧窗格显示了函数调用的层次结构。当您选择一个函数时，右侧窗格会显示其代码以及它调用的函数的代码，分别显示在调用方法和被调用方法字段中。
在左侧窗格中，选中您希望传播该参数的函数旁边的复选框，然后点击 OK。

预览更改并完成重构

在更改签名对话框 Ctrl+F6 中，点击预览。
在重构预览选项卡中，查找工具窗口，查看预期更改，做出必要的调整，然后在准备好时点击执行重构。

最后修改日期： 2025年 4月 24日