# 重构 JavaScript

> For the complete documentation index, see [llms.txt](https://www.jetbrains.com/zh-cn/help/clion/llms.txt).

> **TL;DR**
> 必需插件  :
>
>
>
> `JavaScript 和 TypeScript` ：该插件随 CLion 一同捆绑，并默认启用。

[重构](https://en.wikipedia.org/wiki/Code_refactoring)意味着在不改变应用程序行为的情况下更新源代码。 重构帮助您保持代码的坚固、 [简洁](https://en.wikipedia.org/wiki/Don%27t_repeat_yourself)和易于维护。

## 移动符号重构

除了 [移动文件和文件夹](null)，CLion 还允许您移动 JavaScript 顶级符号。  移动符号重构  适用于 ES6 模块中的类、函数和变量。

Procedure: 移动类、函数或变量

1. 选择要移动的符号。

2. 按 `F6` (Windows), `F6` (macOS), `F6` (IntelliJ IDEA Classic (macOS)), `⌘ ⌥ I` (macOS System Shortcuts), `F6` (XWin), `F6` (GNOME), `F6` (KDE), `F6` (Emacs), `F6` (Sublime Text), `F6` (Sublime Text (macOS)), `⌥ F6` (Xcode), `Ctrl+R, O` (Visual Studio), `⌘ R, O` (Visual Studio (macOS)), `F6` (ReSharper), `F6` (ReSharper (macOS)), `F6` (QtCreator), `F6` (QtCreator (macOS)), `Ctrl+M` (NetBeans), `Alt+Shift+V` (Eclipse), `⌘ ⌥ V` (Eclipse (macOS)) 或从上下文菜单或主菜单中选择  `重构 | 移动` 。 或者，选择  `重构 | 执行重构` 或按 `Ctrl+Alt+Shift+T` (Windows), `⌃ T` (macOS), `⌘ ⌥ ⇧ T` (IntelliJ IDEA Classic (macOS)), `⌃ S` (macOS System Shortcuts), `Ctrl+Alt+Shift+T` (XWin), `Ctrl+Alt+Shift+T` (GNOME), `Ctrl+Alt+Shift+T` (KDE), `Ctrl+Alt+Shift+T` (Emacs), `Ctrl+Alt+Shift+T` (Sublime Text), `⌃ T` (Sublime Text (macOS)), `⌘ ⌃ ⌥ T` (Xcode), `Ctrl+Shift+R` (Visual Studio), `⌘ ⇧ R` (Visual Studio (macOS)), `Ctrl+Shift+R` (ReSharper), `⌘ ⇧ R` (ReSharper (macOS)), `Ctrl+Alt+Shift+T` (QtCreator), `⌃ T` (QtCreator (macOS)), `Ctrl+Alt+Shift+T` (NetBeans), `Ctrl+Alt+Shift+T` (Eclipse), `⌃ T` (Eclipse (macOS))，然后从列表中选择  `移动` 。

移动模块成员   对话框将打开。

3. 指定目标文件并选择要移动的成员。

4. 默认情况下，CLion 会自动将成员权限提升到所需级别。 如果您想保持可见性级别不变，请点击   原样  ，然后在   可见性  中选择。

## 向上拉取成员重构

Pull Class Members Up  重构将类方法在类层次结构中向上移动——从当前类移动到超类。

例如：将类方法移动到超类

假设您有一个类  `AccountingDepartment` 扩展一个抽象类  `Department` 。 在此示例中，  Pull Class Members Up  重构将  `printMeeting()`  方法从  `AccountingDepartment`  移动到其超类  `Department` 。

重构前:

```JAVASCRIPT
class Department {
    name;

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

class AccountingDepartment extends Department {
    printMeeting() {
        console.log("The Accounting Department meets each Monday at 10am.");
    }

    generateReports() {
        console.log("Generating accounting reports...");
    }
}

```

重构后:

```JAVASCRIPT
class Department {
    name;

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

    printMeeting() {
        console.log("The Accounting Department meets each Monday at 10am.");
    }
}

class AccountingDepartment extends Department {
    generateReports() {
        console.log("Generating accounting reports...");
    }
}

```

Procedure: 将类的方法移到超类

1. 将文本光标放置在您要上移成员的类内的任意位置。

2. 请选择  `重构 | 上移成员`  从主菜单或上下文菜单中。   上移成员   对话框将打开。

3. 从列表中选择您要移动方法的超类。

4. 要向上提取方法，请在   要上移的成员  列表中选中其旁边的复选框。

## 重命名重构

除了 [重命名文件和文件夹](null)之外，您还可以重命名类、方法、函数、变量和参数。 CLion 更改符号在其声明中的名称，并且默认情况下更改当前项目中所有用法。

### 重命名类及其方法

Procedure:

1. 在编辑器中，将插入点放在要重命名的类或方法上，或选择它，然后按 `Shift+F6` (Windows), `⇧ F6` (macOS), `⇧ F6` (IntelliJ IDEA Classic (macOS)), `⌘ ⌥ R` (macOS System Shortcuts), `Shift+F6` (XWin), `Shift+F6` (GNOME), `Shift+F6` (KDE), `Shift+F6` (Emacs), `Shift+F6` (Sublime Text), `⇧ F6` (Sublime Text (macOS)), `⌘ ⌃ E` (Xcode), `Ctrl+R, R` (Visual Studio), `⌘ R, R` (Visual Studio (macOS)), `F2` (ReSharper), `F2` (ReSharper (macOS)), `Ctrl+Shift+R` (QtCreator), `⌘ ⌃ R` (QtCreator (macOS)), `Ctrl+R` (NetBeans), `Alt+Shift+R` (Eclipse), `⇧ F6` (Eclipse (macOS)) 或从上下文菜单中选择  `重命名` 。

2. 在打开的   重命名  对话框中，输入类或方法的新名称。

3. 可选：

* 请选择 在注释和字符串中搜索 和 搜索文本出现位置 复选框以便重命名类或方法在注释、字符串字面量和文本中的用法。

* 默认情况下，类或方法会在整个项目中被重命名。 您可以从列表中选择另一个 [作用域](configuring-scopes-and-file-colors.html)。

#### 保持类名和包含文件的一致性

当您重命名一个类时，CLion 还会建议重命名同名文件。 如果您接受建议，CLion 会更新其他文件中的 import 语句中的文件名。

![重命名类和文件](https://resources.jetbrains.com/help/img/idea/2026.3/ws_js_refactoring_rename_class_and_file.animated.gif)

如果您拒绝此建议，您可以稍后随时使用   重命名文件  意图操作重命名文件。 另一种意图操作建议将类移动到具有相应名称的新文件中。 建议名称的格式由   文件名约定  列表中选定的样式决定，位于 [代码样式：JavaScript](settings-code-style-javascript.html#ws_settings_code_style_js_code_generation)页面。

![ws_js_refactoring_rename_file_intention_custom_naming_convention.png](https://resources.jetbrains.com/help/img/idea/2026.3/ws_js_refactoring_rename_file_intention_custom_naming_convention.png)

如果您刚创建了一个新文件，但在其中开始输入类或接口时想出了一个更好的名称，这会很有用。 要调用意图操作，请将文本光标置于相关类的名称处并按下 `Alt+Enter` (Windows), `⌥ ⏎` (macOS), `⌥ ⏎` (IntelliJ IDEA Classic (macOS)), `⌥ ⏎` (macOS System Shortcuts), `Alt+Enter` (XWin), `Alt+Enter` (GNOME), `Alt+Enter` (KDE), `Alt+Enter` (Emacs), `Alt+Enter` (Sublime Text), `⌥ ⏎` (Sublime Text (macOS)), `⌥ ⏎` (Xcode), `Alt+Enter` (Visual Studio), `⌥ ⏎` (Visual Studio (macOS)), `Alt+Enter` (ReSharper), `⌥ ⏎` (ReSharper (macOS)), `Alt+Enter` (QtCreator), `⌥ ⏎` (QtCreator (macOS)), `Alt+Enter` (NetBeans), `Ctrl+1` (Eclipse), `⌘ 1` (Eclipse (macOS))。

### 重命名函数、变量和参数

![重命名函数](https://resources.jetbrains.com/help/img/idea/2026.3/ws_javascript_rename_function.animated.gif)

函数、变量和参数的  Rename 重构可能会在原地执行，但您可以按 `Shift+F6` (Windows), `⇧ F6` (macOS), `⇧ F6` (IntelliJ IDEA Classic (macOS)), `⌘ ⌥ R` (macOS System Shortcuts), `Shift+F6` (XWin), `Shift+F6` (GNOME), `Shift+F6` (KDE), `Shift+F6` (Emacs), `Shift+F6` (Sublime Text), `⇧ F6` (Sublime Text (macOS)), `⌘ ⌃ E` (Xcode), `Ctrl+R, R` (Visual Studio), `⌘ R, R` (Visual Studio (macOS)), `F2` (ReSharper), `F2` (ReSharper (macOS)), `Ctrl+Shift+R` (QtCreator), `⌘ ⌃ R` (QtCreator (macOS)), `Ctrl+R` (NetBeans), `Alt+Shift+R` (Eclipse), `⇧ F6` (Eclipse (macOS))在   重命名  对话框中配置重构作用域。

要默认打开   重命名   对话框，请打开   设置   对话框（ `Ctrl+Alt+S` (Windows), `⌘ Comma` (macOS), `⌘ Comma` (IntelliJ IDEA Classic (macOS)), `⌘ Comma` (macOS System Shortcuts), `Ctrl+Alt+S` (XWin), `Ctrl+Alt+S` (GNOME), `Ctrl+Alt+S` (KDE), `Ctrl+Alt+S` (Emacs), `Ctrl+Alt+S` (Sublime Text), `⌘ Comma` (Sublime Text (macOS)), `⌘ Comma` (Xcode), `Ctrl+Alt+S` (Visual Studio), `⌘ Comma` (Visual Studio (macOS)), `Ctrl+Alt+S` (ReSharper), `⌘ Comma` (ReSharper (macOS)), `Ctrl+Alt+S` (QtCreator), `⌘ Comma` (QtCreator (macOS)), `Ctrl+Alt+S` (NetBeans), `Ctrl+Alt+S` (Eclipse), `⌘ Comma` (Eclipse (macOS))），转到  `编辑器 | 代码编辑` ，并在   指定重构选项   区域中选择   在模式对话框中   选项。

![重构设置：在模态对话框中打开设置](https://resources.jetbrains.com/help/img/idea/2026.3/ws_js_refactoring_settings.png)

Procedure:

1. 在编辑器中，将插入点放在要重命名的函数、变量或参数上，或选择它，然后按 `Shift+F6` (Windows), `⇧ F6` (macOS), `⇧ F6` (IntelliJ IDEA Classic (macOS)), `⌘ ⌥ R` (macOS System Shortcuts), `Shift+F6` (XWin), `Shift+F6` (GNOME), `Shift+F6` (KDE), `Shift+F6` (Emacs), `Shift+F6` (Sublime Text), `⇧ F6` (Sublime Text (macOS)), `⌘ ⌃ E` (Xcode), `Ctrl+R, R` (Visual Studio), `⌘ R, R` (Visual Studio (macOS)), `F2` (ReSharper), `F2` (ReSharper (macOS)), `Ctrl+Shift+R` (QtCreator), `⌘ ⌃ R` (QtCreator (macOS)), `Ctrl+R` (NetBeans), `Alt+Shift+R` (Eclipse), `⇧ F6` (Eclipse (macOS))或从上下文菜单中选择  `重命名` 。

2. 如果 CLion 在注释或字符串中检测到符号的用法，请指定是否也要重命名这些用法。

3. 在带有 canvas 的字段中，输入函数、变量或参数的新名称。

4. 或者：

请再次按下 `Shift+F6` (Windows), `⇧ F6` (macOS), `⇧ F6` (IntelliJ IDEA Classic (macOS)), `⌘ ⌥ R` (macOS System Shortcuts), `Shift+F6` (XWin), `Shift+F6` (GNOME), `Shift+F6` (KDE), `Shift+F6` (Emacs), `Shift+F6` (Sublime Text), `⇧ F6` (Sublime Text (macOS)), `⌘ ⌃ E` (Xcode), `Ctrl+R, R` (Visual Studio), `⌘ R, R` (Visual Studio (macOS)), `F2` (ReSharper), `F2` (ReSharper (macOS)), `Ctrl+Shift+R` (QtCreator), `⌘ ⌃ R` (QtCreator (macOS)), `Ctrl+R` (NetBeans), `Alt+Shift+R` (Eclipse), `⇧ F6` (Eclipse (macOS)) 以打开   重命名   对话框。

* 选中 在注释和字符串中搜索 和 搜索文本出现位置 复选框，以重命名符号在注释、字符串字面量和文本中的用法。

* 默认情况下，该符号在整个项目中重命名。 您可以从列表中选择另一个 [作用域](configuring-scopes-and-file-colors.html)。

### 重命名常量

Procedure:

1. 在编辑器中，将插入点放在要重命名的常量上，或选择它，然后按 `Shift+F6` (Windows), `⇧ F6` (macOS), `⇧ F6` (IntelliJ IDEA Classic (macOS)), `⌘ ⌥ R` (macOS System Shortcuts), `Shift+F6` (XWin), `Shift+F6` (GNOME), `Shift+F6` (KDE), `Shift+F6` (Emacs), `Shift+F6` (Sublime Text), `⇧ F6` (Sublime Text (macOS)), `⌘ ⌃ E` (Xcode), `Ctrl+R, R` (Visual Studio), `⌘ R, R` (Visual Studio (macOS)), `F2` (ReSharper), `F2` (ReSharper (macOS)), `Ctrl+Shift+R` (QtCreator), `⌘ ⌃ R` (QtCreator (macOS)), `Ctrl+R` (NetBeans), `Alt+Shift+R` (Eclipse), `⇧ F6` (Eclipse (macOS))或从上下文菜单中选择  `重命名` 。

2. 在打开的   重命名  对话框中，输入常量的新名称。

3. 可选：

* 选中 在注释和字符串中搜索 和 搜索文本出现位置 复选框，以便重命名注释、字符串文字和文本中的常量用法。

* 默认情况下，常量在整个项目中重命名。 您可以从列表中选择另一个 [作用域](configuring-scopes-and-file-colors.html)。

### 重命名符号的动态用法

由于 JavaScript 的动态特性，在某些情况下，动态引用是有效的使用方式，应该被重命名。 然而，通常重命名动态用法不是预期的行为。 在下面的示例中，将  `test()`  更改为  `test1()`  在  `rename.test()`  中是正确的，而在  `hello.test()`  中则会是一个错误。

重命名前:

```JAVASCRIPT
class Rename{
    test() {
        return 12345;
    }
}

let rename = new Rename();
let hello = window["Test"];

let a = rename.test();
let b = hello.test();
            
```

动态用法未被重命名:

```JAVASCRIPT
class Rename{
    test1() {
        return 12345;
    }
}

let rename = new Rename();
let hello = window["Test"];

let a = rename.test1();
let b = hello.test();
            
```

动态用法已重命名:

```JAVASCRIPT
class Rename{
    test1() {
        return 12345;
    }
}

let rename = new Rename();
let hello = window["Test"];

let a = rename.test1();
let b = hello.test1();
            
```

CLion 总是在应用复杂重构前显示   预览   窗口。

* 要显示符号的动态用法，请按 ![显示动态用法切换按钮](https://resources.jetbrains.com/help/img/idea/2026.3/ws_find_usages_show_dynamic_usages.png)

* 默认情况下，在 重构预览 工具窗口中，所有符号的动态用法都会被标记为排除，并分组到 代码中对<symbol>的动态引用 节点下。 要将重构应用于某个用法，请从其上下文菜单中选择 包含 。

![动态用法的重构预览](https://resources.jetbrains.com/help/img/idea/2026.3/ws_js_rename_symbol_dynamic_usages_error_preview.png)

## 提取重构

CLion 提供多种  Extract 重构操作，以引入参数、变量、常量、字段、方法和函数。 要执行这些重构操作，请选择要重构的表达式并选择  `重构 | <target>` 。 您可以选择整个表达式或将文本光标置于其中的任意位置，CLion 都将帮助您进行选择。

### 引入参数

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

假设您有一段代码，其中在函数  `1` 中硬编码了  `calculate_sum(i)` 。 通过引入参数重构，您可以用一个  `1` 参数来替换这个硬编码的  `i2` 。 新的  `i2`  参数可以提取为  可选  或  必需 。

示例 1：引入一个可选参数

一个新的参数  `i2` 被提取为可选参数。 新参数在  `calculate_sum(i)` 的主体中初始化，并且  `calculate_sum(i)` 中的调用在  `show_sum()` 中没有变化。

请参阅下文的 [选择参数类型（可选）](#javascript_extract_parameter_inplace_optional_required_default_value)。

重构前:

```JAVASCRIPT
function calculate_sum(i) {
    alert('Adding ' + 1 + ' to ' + i);
    return 1 + i;
}

function show_sum() {
    alert('Result: ' + calculate_sum(5));
}

```

重构后:

```JAVASCRIPT
function calculate_sum(i, i2) {
    i2 = i2 || 1;
    alert('Adding ' + i2 + ' to ' + i);
    return i2 + i;
}

function show_sum() {
    alert('Result: ' + calculate_sum(5));
}

```

示例 2：介绍必需参数

新的参数  `i2` 被提取为必需参数，  `calculate_sum(i)` 在  `show_sum()` 中的调用已相应更改。

请参见 [选择参数类型（必需）](#javascript_extract_parameter_inplace_optional_required_default_value)下文。

重构前:

```JAVASCRIPT
function calculate_sum(i) {
    alert('Adding ' + 1 + ' to ' + i);
    return 1 + i;
}

function show_sum() {
    alert('Result: ' + calculate_sum(5));
}

```

重构后:

```JAVASCRIPT
function calculate_sum(i, i2) {
    alert('Adding ' + i2 + ' to ' + i);
    return i2 + i;
}

function show_sum() {
    alert('Result: ' + calculate_sum(5, 1));
}

```

Procedure: 引入一个参数

1. 在编辑器中，将文本光标放置在您想要转换为参数的表达式内，然后按 `Ctrl+Alt+P` (Windows), `⌘ ⌥ P` (macOS), `⌘ ⌥ P` (IntelliJ IDEA Classic (macOS)), `⌘ ⌥ P` (macOS System Shortcuts), `Ctrl+Alt+P` (XWin), `Ctrl+Alt+P` (GNOME), `Ctrl+Alt+P` (KDE), `Ctrl+Alt+P` (Emacs), `Ctrl+Alt+P` (Sublime Text), `⌘ ⌥ P` (Sublime Text (macOS)), `⌘ ⌃ ⌥ P` (Xcode), `Ctrl+R, P` (Visual Studio), `⌘ R, P` (Visual Studio (macOS)), `Ctrl+Alt+P` (ReSharper), `⌘ ⌥ P` (ReSharper (macOS)), `Ctrl+Alt+P` (QtCreator), `⌘ ⌥ P` (QtCreator (macOS)), `Ctrl+Alt+P` (NetBeans), `Ctrl+Alt+P` (Eclipse), `⌘ ⌥ P` (Eclipse (macOS)) 或从上下文菜单中选择   重构 | 引入参数  。

或者，执行以下操作之一：

* 按 `Ctrl+Alt+Shift+T` (Windows), `⌃ T` (macOS), `⌘ ⌥ ⇧ T` (IntelliJ IDEA Classic (macOS)), `⌃ S` (macOS System Shortcuts), `Ctrl+Alt+Shift+T` (XWin), `Ctrl+Alt+Shift+T` (GNOME), `Ctrl+Alt+Shift+T` (KDE), `Ctrl+Alt+Shift+T` (Emacs), `Ctrl+Alt+Shift+T` (Sublime Text), `⌃ T` (Sublime Text (macOS)), `⌘ ⌃ ⌥ T` (Xcode), `Ctrl+Shift+R` (Visual Studio), `⌘ ⇧ R` (Visual Studio (macOS)), `Ctrl+Shift+R` (ReSharper), `⌘ ⇧ R` (ReSharper (macOS)), `Ctrl+Alt+Shift+T` (QtCreator), `⌃ T` (QtCreator (macOS)), `Ctrl+Alt+Shift+T` (NetBeans), `Ctrl+Alt+Shift+T` (Eclipse), `⌃ T` (Eclipse (macOS))并选择 `引入参数` 。

* 转到 `重构 | 提取 | 参数` 。

2. 如果在当前文本光标位置检测到多个表达式，请从   表达式  列表中选择所需的表达式。

![ws_js_extract_parameter_select_expression.png](https://resources.jetbrains.com/help/img/idea/2026.3/ws_js_extract_parameter_select_expression.png)

3. 如果找到多于一个的所选表达式实例，请从   找到多处出现  列表中选择   仅替换此处   或   替换所有出现的地方  。

![ws_js_extract_parameter_multiple_occurrences.png](https://resources.jetbrains.com/help/img/idea/2026.3/ws_js_extract_parameter_multiple_occurrences.png)

最后，用于配置重构的弹出窗口会出现。

![ws_js_extract_parameter_specify_parameter_name_and_type.png](https://resources.jetbrains.com/help/img/idea/2026.3/ws_js_extract_parameter_specify_parameter_name_and_type.png)

4. 选择   生成 JSDoc   生成一个 [JSDoc](https://github.com/jsdoc/jsdoc) 注释块。 如果您需要指定自定义的默认参数值，这可能会有所帮助。

5. 选择新参数的类型（  optional  或  required ）并指定其默认值（如果适用）：

* 如果选中 可选参数 复选框，参数将在函数体中使用默认值进行初始化。 请参见 [Introduce Parameter example 1](#javascript_extract_parameter_examples_example_1_optional_parameter) 上方。

* 如果清除了 可选参数 复选框，默认参数值将通过现有的函数调用传递。 所有的函数调用都将根据新的函数签名进行更改，并且函数体内将添加一个参数初始化。 请参见上面的 [Introduce Parameter example 2](#javascript_extract_parameter_examples_example_2_required_parameter)。

最初，CLion 将调用重构的表达式作为默认值接收。 在大多数情况下，您无需更改它。 如果仍有必要，请在格式  `@param <parameter name> - <default value>` 的 JSDoc 注释中指定另一个默认值。

6. 在列表中双击以接受建议的参数名称之一，或在带有画布的字段中指定自定义名称。 按 `Enter` (Windows), `⏎` (macOS), `⏎` (IntelliJ IDEA Classic (macOS)), `⏎` (macOS System Shortcuts), `Enter` (XWin), `Enter` (GNOME), `Enter` (KDE), `Enter` (Emacs), `Enter` (Sublime Text), `⏎` (Sublime Text (macOS)), `⏎` (Xcode), `Enter` (Visual Studio), `⏎` (Visual Studio (macOS)), `Enter` (ReSharper), `⏎` (ReSharper (macOS)), `Enter` (QtCreator), `⏎` (QtCreator (macOS)), `Enter` (NetBeans), `Enter` (Eclipse), `⏎` (Eclipse (macOS)) 准备。

![ws_js_extract_parameter_result.png](https://resources.jetbrains.com/help/img/idea/2026.3/ws_js_extract_parameter_result.png)

请注意，在 ES6 代码中，将应用新的默认函数参数语法  `function calculate_sum(i, i2 = 1)` ，而不是  `i2 = i2 || 1;` 。 了解有关默认函数参数的更多信息，详见 [https://developer.mozilla.org 网站](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Default_parameters)。

#### 选择重构模式

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

* [预览重构的结果](null)。 在对话框中，您可以点击 预览 ，并在 查找 工具窗口的专用选项卡中查看预期的更改。 在就地模式下，此功能不可用。

* [指定默认参数值](#javascript_extract_parameter_inplace_optional_required_default_value)。 在对话框中，CLion 在 Value 字段中建议默认参数值，您可以接受建议或指定另一个值。 在就地模式中，CLion 会将调用重构的表达式视为默认参数值。 要指定另一个值，您必须使用 JSDoc 注释块。

默认情况下，CLion 以就地模式运行引入参数重构。 要使用   提取参数   对话框，请打开   设置   对话框（ `Ctrl+Alt+S` (Windows), `⌘ Comma` (macOS), `⌘ Comma` (IntelliJ IDEA Classic (macOS)), `⌘ Comma` (macOS System Shortcuts), `Ctrl+Alt+S` (XWin), `Ctrl+Alt+S` (GNOME), `Ctrl+Alt+S` (KDE), `Ctrl+Alt+S` (Emacs), `Ctrl+Alt+S` (Sublime Text), `⌘ Comma` (Sublime Text (macOS)), `⌘ Comma` (Xcode), `Ctrl+Alt+S` (Visual Studio), `⌘ Comma` (Visual Studio (macOS)), `Ctrl+Alt+S` (ReSharper), `⌘ Comma` (ReSharper (macOS)), `Ctrl+Alt+S` (QtCreator), `⌘ Comma` (QtCreator (macOS)), `Ctrl+Alt+S` (NetBeans), `Ctrl+Alt+S` (Eclipse), `⌘ Comma` (Eclipse (macOS))），转到   编辑器 │ 代码编辑  ，并在   重构   区域中选择   在模式对话框中   选项。

### 引入变量

使用  Introduce Variable  重构将表达式替换为 [function-scoped variable (var)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/var) 或 [block-scoped variable (let)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/let)。 此重构使您的源代码更易读和维护。

假设您在  `return`  语句中有一个部分硬编码的表达式的函数：

```JAVASCRIPT
Parenizor.method('toString', function ())
{
    return '(' + this.getValue() + ')';
}

```

借助引入变量重构，您可以用变量替换  `'(' + this.getValue() + ')'` 表达式，例如，  `字符串` 。 提取变量的作用域取决于其声明中使用的语句  `var` 或  `let` 以及新变量声明的上下文（在函数内部或外部）。

示例 1：用 let 声明引入块作用域变量

从  `'(' + this.getValue() + ')'`  表达式中在  `return`  语句提取出一个变量  `字符串` 。 新变量通过  `let` 语句在  `Parenizor.method('toString', function ())` 内声明。

重构前:

```JAVASCRIPT
Parenizor.method('toString', function ())
{
    return '(' + this.getValue() + ')';
}

```

重构后:

```JAVASCRIPT
Parenizor.method('toString', function ())
{
    let string = '(' + this.getValue() + ')';
    return string;
}

```

示例 2：引入一个变量并在任何函数之外声明它

从  `navigator.appName`  表达式中提取了一个变量  `appName` ，并在任何函数之外用  `var`  语句声明。

重构前:

```JAVASCRIPT
let browserName = "N/A";
if (navigator.appName.indexOf("Netscape") !== -1) {
    browserName = "NS";
} else if (navigator.appName.indexOf("Microsoft") !== -1) {
    browserName = "MSIE";
} else if (navigator.appName.indexOf("Opera") !== -1) {
    browserName = "O";
}                    
```

重构后:

```JAVASCRIPT
let browserName = "N/A";
let appName = navigator.appName;
if (appName.indexOf("Netscape") !== -1) {
    browserName = "NS";
} else if (appName.indexOf("Microsoft") !== -1) {
    browserName = "MSIE";
} else if (appName.indexOf("Opera") !== -1) {
    browserName = "O";
}
                    
```

Procedure: 引入变量

1. 在编辑器中，选择要转换为变量的表达式，然后按 `Ctrl+Alt+V` (Windows), `⌘ ⌥ V` (macOS), `⌘ ⌥ V` (IntelliJ IDEA Classic (macOS)), `⌘ ⌥ V` (macOS System Shortcuts), `Ctrl+Alt+V` (XWin), `Ctrl+Alt+V` (GNOME), `Alt+Shift+V` (KDE), `Ctrl+Alt+V` (Emacs), `Ctrl+Alt+V` (Sublime Text), `Ctrl+Alt+V` (Sublime Text (macOS)), `⌘ ⌃ ⌥ V` (Xcode), `Ctrl+R, V` (Visual Studio), `⌘ R, V` (Visual Studio (macOS)), `Ctrl+Alt+V` (ReSharper), `⌘ ⌥ V` (ReSharper (macOS)), `Ctrl+Alt+V` (QtCreator), `⌘ ⌥ V` (QtCreator (macOS)), `Alt+Shift+V` (NetBeans), `Alt+Shift+L` (Eclipse), `⌘ ⌥ L` (Eclipse (macOS)) 或从上下文菜单中选择  `重构 | 引入变量` 。

或者，执行以下操作之一：

* 按 `Ctrl+Alt+Shift+T` (Windows), `⌃ T` (macOS), `⌘ ⌥ ⇧ T` (IntelliJ IDEA Classic (macOS)), `⌃ S` (macOS System Shortcuts), `Ctrl+Alt+Shift+T` (XWin), `Ctrl+Alt+Shift+T` (GNOME), `Ctrl+Alt+Shift+T` (KDE), `Ctrl+Alt+Shift+T` (Emacs), `Ctrl+Alt+Shift+T` (Sublime Text), `⌃ T` (Sublime Text (macOS)), `⌘ ⌃ ⌥ T` (Xcode), `Ctrl+Shift+R` (Visual Studio), `⌘ ⇧ R` (Visual Studio (macOS)), `Ctrl+Shift+R` (ReSharper), `⌘ ⇧ R` (ReSharper (macOS)), `Ctrl+Alt+Shift+T` (QtCreator), `⌃ T` (QtCreator (macOS)), `Ctrl+Alt+Shift+T` (NetBeans), `Ctrl+Alt+Shift+T` (Eclipse), `⌃ T` (Eclipse (macOS))并选择 `引入变量` 。

* 转到 `重构 | 提取 | 变量` 。

2. 如果在当前文本光标位置检测到多个表达式，请从   表达式  列表中选择所需的表达式。

![提取变量 - 选择一个表达式](https://resources.jetbrains.com/help/img/idea/2026.3/ws_js_refactoring_extract_variable_inplace_select_expression.png)

3. 如果找到多于一个的所选表达式实例，请从   找到多处出现  列表中选择   仅替换此处   或   替换所有出现的地方  。

![提取变量 - 多次出现](https://resources.jetbrains.com/help/img/idea/2026.3/ws_js_refactoring_extract_variable_inplace_multiple_occurrences.png)

最后，用于配置重构的弹出窗口会出现。

4. 从列表中选择用于声明新变量的语句：

* 选择 var 引入一个 [函数作用域变量](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/var)。

* 选择 let 来引入 [块级作用域变量](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/let)，请参阅上面的 [示例 2](#javascript_extract_variable_examples_example_1_declaration_inside_a_function_let_statement)。

* 选择 const 以引入一个 [常量](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/const)。

![提取变量 - 选择声明类型](https://resources.jetbrains.com/help/img/idea/2026.3/ws_js_refactoring_extract_variable_inplace_choose_scope_type.png)

5. 在列表中双击以接受建议的参数名称之一，或在带有画布的字段中指定自定义名称。 按 `Enter` (Windows), `⏎` (macOS), `⏎` (IntelliJ IDEA Classic (macOS)), `⏎` (macOS System Shortcuts), `Enter` (XWin), `Enter` (GNOME), `Enter` (KDE), `Enter` (Emacs), `Enter` (Sublime Text), `⏎` (Sublime Text (macOS)), `⏎` (Xcode), `Enter` (Visual Studio), `⏎` (Visual Studio (macOS)), `Enter` (ReSharper), `⏎` (ReSharper (macOS)), `Enter` (QtCreator), `⏎` (QtCreator (macOS)), `Enter` (NetBeans), `Enter` (Eclipse), `⏎` (Eclipse (macOS)) 准备。

#### 选择重构模式

您可以直接在编辑器中（就地模式）提取变量 [，如上所述](#javascript_extract_variable_inplace_refactoring)或使用   提取变量对话框  。 默认情况下，CLion 在就地模式下运行引入变量重构。 要使用   提取变量  对话框，请打开   设置  对话框（ `Ctrl+Alt+S` (Windows), `⌘ Comma` (macOS), `⌘ Comma` (IntelliJ IDEA Classic (macOS)), `⌘ Comma` (macOS System Shortcuts), `Ctrl+Alt+S` (XWin), `Ctrl+Alt+S` (GNOME), `Ctrl+Alt+S` (KDE), `Ctrl+Alt+S` (Emacs), `Ctrl+Alt+S` (Sublime Text), `⌘ Comma` (Sublime Text (macOS)), `⌘ Comma` (Xcode), `Ctrl+Alt+S` (Visual Studio), `⌘ Comma` (Visual Studio (macOS)), `Ctrl+Alt+S` (ReSharper), `⌘ Comma` (ReSharper (macOS)), `Ctrl+Alt+S` (QtCreator), `⌘ Comma` (QtCreator (macOS)), `Ctrl+Alt+S` (NetBeans), `Ctrl+Alt+S` (Eclipse), `⌘ Comma` (Eclipse (macOS))），转到   编辑器 │ 代码编辑  ，并在   重构  区域中选择   在模式对话框中  选项。

### 引入常量

使用  Introduce Constant  重构将表达式替换为 [常量](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/const)。 此重构使您的源代码更易读和维护。 它还可以帮助您避免使用未解释其值或目的的硬编码常量。

在类中，您可以引入 readonly 字段或选择一个作用域（如果有多个作用域适合）。 在其他上下文中，CLion 仅引入局部常量。

示例 1：为引入的常量选择一个作用域

假设您有一个类  `AccountingDepartment` ，其方法  `printName()` 中  `"Department name :"` 是硬编码的。

```JAVASCRIPT
class AccountingDepartment {
    name;

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

    printMeeting() {...
    }

    generateReports() {...
    }
}

```

CLion可以作为局部变量在  `printName()` 函数内声明新的常量，或者在类外部以全局变量或模块变量的形式声明。

引入局部常量:

```JAVASCRIPT
class AccountingDepartment {
    name;

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

    printMeeting() {...
    }

    generateReports() {...
    }
}

```

引入全局常量:

```JAVASCRIPT
const departmentName = "Department name: ";

class AccountingDepartment {
    name;

    printName() {
        console.log(departmentName + this.name);
    }

    printMeeting() {...
    }

    generateReports() {...
    }
}


```

示例 2：仅引入常量而不选择作用域

如果从任何类外部调用 Introduce Constant 重构，CLion 将自动引入一个局部变量，并在当前函数或块中声明它。

重构前:

```JAVASCRIPT
let output = MyFunction(5, 8);
document.writeln("The value is .".output);

```

重构后:

```JAVASCRIPT
let output = MyFunction(5, 8);
const Value = "The value is ";
document.writeln(Value.output);


```

Procedure: 引入一个常量

1. 在编辑器中，选择要转换为常量的表达式，然后按 `Ctrl+Alt+C` (Windows), `⌘ ⌥ C` (macOS), `⌘ ⌥ C` (IntelliJ IDEA Classic (macOS)), `⌘ ⌥ C` (macOS System Shortcuts), `Ctrl+Alt+C` (XWin), `Ctrl+Alt+C` (GNOME), `Ctrl+Alt+C` (KDE), `Ctrl+Alt+C` (Emacs), `Ctrl+Alt+C` (Sublime Text), `⌘ ⌥ C` (Sublime Text (macOS)), `⌘ ⌃ ⌥ C` (Xcode), `Ctrl+Alt+C` (Visual Studio), `⌘ ⌥ C` (Visual Studio (macOS)), `Ctrl+Alt+C` (ReSharper), `⌘ ⌥ C` (ReSharper (macOS)), `Ctrl+Alt+C` (QtCreator), `⌘ ⌥ C` (QtCreator (macOS)), `Alt+Shift+C` (NetBeans), `Ctrl+Alt+C` (Eclipse), `Ctrl+Alt+C` (Eclipse (macOS)) 或从上下文菜单中选择  `重构 | 引入常量` 。

或者，执行以下操作之一：

* 按 `Ctrl+Alt+Shift+T` (Windows), `⌃ T` (macOS), `⌘ ⌥ ⇧ T` (IntelliJ IDEA Classic (macOS)), `⌃ S` (macOS System Shortcuts), `Ctrl+Alt+Shift+T` (XWin), `Ctrl+Alt+Shift+T` (GNOME), `Ctrl+Alt+Shift+T` (KDE), `Ctrl+Alt+Shift+T` (Emacs), `Ctrl+Alt+Shift+T` (Sublime Text), `⌃ T` (Sublime Text (macOS)), `⌘ ⌃ ⌥ T` (Xcode), `Ctrl+Shift+R` (Visual Studio), `⌘ ⇧ R` (Visual Studio (macOS)), `Ctrl+Shift+R` (ReSharper), `⌘ ⇧ R` (ReSharper (macOS)), `Ctrl+Alt+Shift+T` (QtCreator), `⌃ T` (QtCreator (macOS)), `Ctrl+Alt+Shift+T` (NetBeans), `Ctrl+Alt+Shift+T` (Eclipse), `⌃ T` (Eclipse (macOS))并选择 `引入常量` 。

* 转到 `重构 | 提取 | 常量` 。

2. 如果在当前文本光标位置检测到多个表达式，请从   表达式  列表中选择所需的表达式。

![引入常量：选择表达式](https://resources.jetbrains.com/help/img/idea/2026.3/ws_js_refactoring_extract_constant__2_several_expressions.png)

3. 如果从类内部调用重构，请引入 readonly 字段或选择新常量的作用域，参见 [示例 1](#javascript_extract_constant_example_1)。

![引入常量：选择作用域](https://resources.jetbrains.com/help/img/idea/2026.3/ws_js_refactoring_extract_constant__3_select_scope.png)

对于全局常量，可以找到所选表达式的多个出现。 从   找到多处出现   列表中选择   仅替换此处   或   替换所有出现的地方  。

![引入常量：全局常量的多次出现](https://resources.jetbrains.com/help/img/idea/2026.3/ws_js_refactoring_extract_constant__4_multiple_occurrences.png)

4. 在列表中双击以接受建议的参数名称之一，或在带有画布的字段中指定自定义名称。 按 `Enter` (Windows), `⏎` (macOS), `⏎` (IntelliJ IDEA Classic (macOS)), `⏎` (macOS System Shortcuts), `Enter` (XWin), `Enter` (GNOME), `Enter` (KDE), `Enter` (Emacs), `Enter` (Sublime Text), `⏎` (Sublime Text (macOS)), `⏎` (Xcode), `Enter` (Visual Studio), `⏎` (Visual Studio (macOS)), `Enter` (ReSharper), `⏎` (ReSharper (macOS)), `Enter` (QtCreator), `⏎` (QtCreator (macOS)), `Enter` (NetBeans), `Enter` (Eclipse), `⏎` (Eclipse (macOS)) 准备。

![引入常量：选择名称](https://resources.jetbrains.com/help/img/idea/2026.3/ws_js_refactoring_extract_constant__5_specify_name.png)

### 提取方法

提取方法 重构允许您使用提取的代码创建一个命名方法或函数。 当调用  Extract Method 重构时，CLion会检测出选定代码片段的输入变量和输出变量。 检测到的 output 变量用作提取方法或函数的返回值。

在下面的示例中，函数是从  `c = a + b;`  表达式中提取的。

示例 1：从另一个函数内部的表达式提取全局作用域的函数

`c = a + b;`  表达式，它所在的位置调用了重构，该表达式位于  `MyFunction()`  函数内部。 已经选择   全局   目标作用域。

示例 1.1：生成一个函数声明

重构前:

```JAVASCRIPT
function MyFunction(a, b) {
    c = a + b;
    return (c * c);
}

result = MyFunction(4, 6);
document.write(result);

```

重构后:

```JAVASCRIPT
function extracted(a, b) {
    c = a + b;
}

function MyFunction(a, b) {
    extracted(a, b);
    return (c * c);
}

result = MyFunction(4, 6);
document.write(result);

```

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

重构前:

```JAVASCRIPT
function MyFunction(a, b) {
    c = a + b;
    return (c * c);
}

result = MyFunction(4, 6);
document.write(result);

```

重构后:

```JAVASCRIPT
let extracted = function (a, b) {
    c = a + b;
};

function MyFunction(a, b) {
    extracted(a, b);
    return (c * c);
}

result = MyFunction(4, 6);
document.write(result);

```

示例 2：从任何函数外部的表达式中提取一个全局作用域的函数

`c = a + b;`  表达式（重构在此调用）不在任何函数内。 因此，没有可用的目标作用域选择。

示例 2.1：生成了一个函数声明

重构前:

```JAVASCRIPT
c = a + b;

```

重构后:

```JAVASCRIPT
function extracted() {
    c = a + b;
}

extracted();

```

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

重构前:

```JAVASCRIPT
c = a + b;

```

重构后:

```JAVASCRIPT
let extracted = function () {
    c = a + b;
};
extracted();

```

例 3：在封闭函数内提取具有定义的函数

`c = a + b;`  表达式，它所在的位置调用了重构，该表达式位于  `MyFunction()`  函数内部。 已经选择   function MyFunction   目标作用域。

重构前:

```JAVASCRIPT
function MyFunction(a, b) {
    c = a + b;
    return (c * c);
}

result = MyFunction(4, 6);
document.write(result);

```

重构后:

```JAVASCRIPT
function MyFunction(a, b) {
    function extracted() {
        c = a + b;
    }

    extracted();
    return (c * c);
}

result = MyFunction(4, 6);
document.write(result);


```

Procedure: 提取函数

1. 在编辑器中，选择要转换为函数的代码片段，然后按 `Ctrl+Alt+M` (Windows), `⌘ ⌥ M` (macOS), `⌘ ⌥ M` (IntelliJ IDEA Classic (macOS)), `⌘ ⌥ M` (macOS System Shortcuts), `Ctrl+Alt+M` (XWin), `Ctrl+Alt+M` (GNOME), `Ctrl+Alt+M` (KDE), `Ctrl+Alt+M` (Emacs), `Ctrl+Alt+M` (Sublime Text), `⌘ ⌥ M` (Sublime Text (macOS)), `⌘ ⌃ ⌥ M` (Xcode), `Ctrl+R, M` (Visual Studio), `⌘ R, M` (Visual Studio (macOS)), `Ctrl+Alt+M` (ReSharper), `⌘ ⌥ M` (ReSharper (macOS)), `Ctrl+Alt+M` (QtCreator), `⌘ ⌥ M` (QtCreator (macOS)), `Alt+Shift+M` (NetBeans), `Alt+Shift+M` (Eclipse), `⌘ ⌥ M` (Eclipse (macOS)) 或者从上下文菜单中选择  `重构 | 提取方法` 。

或者，执行以下操作之一：

* 按 `Ctrl+Alt+Shift+T` (Windows), `⌃ T` (macOS), `⌘ ⌥ ⇧ T` (IntelliJ IDEA Classic (macOS)), `⌃ S` (macOS System Shortcuts), `Ctrl+Alt+Shift+T` (XWin), `Ctrl+Alt+Shift+T` (GNOME), `Ctrl+Alt+Shift+T` (KDE), `Ctrl+Alt+Shift+T` (Emacs), `Ctrl+Alt+Shift+T` (Sublime Text), `⌃ T` (Sublime Text (macOS)), `⌘ ⌃ ⌥ T` (Xcode), `Ctrl+Shift+R` (Visual Studio), `⌘ ⇧ R` (Visual Studio (macOS)), `Ctrl+Shift+R` (ReSharper), `⌘ ⇧ R` (ReSharper (macOS)), `Ctrl+Alt+Shift+T` (QtCreator), `⌃ T` (QtCreator (macOS)), `Ctrl+Alt+Shift+T` (NetBeans), `Ctrl+Alt+Shift+T` (Eclipse), `⌃ T` (Eclipse (macOS))并选择 `提取方法` 。

* 转到 `重构 | 提取 | 方法` 。

> **Tip:**
> 所选代码片段可以是一组语句，也可以是代码中使用的一个表达式。

2. 如果选中的表达式在函数内，请从列表中选择目标作用域：

* 如果您选择 全局 ，提取的函数将在任何函数外部声明。 请参阅 上面的 [Example 1](#javascript_extract_method_examples_example_1_global_inside_another_function)。

* 要在当前封闭函数内定义提取的函数，请选择 function <current enclosing function name> 。 请参见 [Example 3](#javascript_extract_method_examples_example_3_function_scope_inside_another_function)上文。

![提取方法 - 选择目标作用域](https://resources.jetbrains.com/help/img/idea/2026.3/ws_refactoring_js_extract_method_extract.png)

3. 请指定将要提取的函数名称。

![提取方法 - 选择将要提取的函数名称](https://resources.jetbrains.com/help/img/idea/2026.3/ws_refactoring_js_extract_method_specify_name.png)

Procedure: 默认打开 Extract Function 对话框

* 打开   设置   对话框 ( `Ctrl+Alt+S` (Windows), `⌘ Comma` (macOS), `⌘ Comma` (IntelliJ IDEA Classic (macOS)), `⌘ Comma` (macOS System Shortcuts), `Ctrl+Alt+S` (XWin), `Ctrl+Alt+S` (GNOME), `Ctrl+Alt+S` (KDE), `Ctrl+Alt+S` (Emacs), `Ctrl+Alt+S` (Sublime Text), `⌘ Comma` (Sublime Text (macOS)), `⌘ Comma` (Xcode), `Ctrl+Alt+S` (Visual Studio), `⌘ Comma` (Visual Studio (macOS)), `Ctrl+Alt+S` (ReSharper), `⌘ Comma` (ReSharper (macOS)), `Ctrl+Alt+S` (QtCreator), `⌘ Comma` (QtCreator (macOS)), `Ctrl+Alt+S` (NetBeans), `Ctrl+Alt+S` (Eclipse), `⌘ Comma` (Eclipse (macOS)))，进入   编辑器 │ 代码编辑  ，并在   重构   区域选择   在模式对话框中   选项。

### 提取超类

Extract Superclass  重构基于当前类的成员创建一个新的抽象类。 创建的类会自动扩展。

> **Note:**
> 抽取超类  重构仅在 ES6 代码中可用。 欲了解更多信息，请参阅 [选择 JavaScript 语言版本](javascript-specific-guidelines.html#ws_js_choose_language_version)。

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

```JAVASCRIPT
class AccountingDepartment {
    name;

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

    printMeeting() {
        console.log("The Accounting Department meets each Monday at 10am.");
    }

    generateReports() {
        console.log("Generating accounting reports...");
    }
}

```

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

```JAVASCRIPT
class Department {
    name;

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

class AccountingDepartment extends Department {
    printMeeting() {
        console.log("The Accounting Department meets each Monday at 10am.");
    }

    generateReports() {
        console.log("Generating accounting reports...");
    }
}

```

Procedure: 提取一个超类

1. 将文本光标置于您想要提取超类的类中的任意位置。

2. 从主菜单中选择  `重构 | 提取 | 超类`  或从上下文菜单中选择  `重构｜提取超类` 。   提取超类  对话框已打开。

3. 指定新超类的名称并选中类成员旁边的复选框以将其包括在内。 可选地，标记您要设为抽象的成员。

4. 在   目标文件   字段中，指定新类文件的位置。 默认情况下，该字段显示调用重构时当前文件的路径。

5. 选择   提取超类  。 CLion 创建一个新类，并使用  `extends`  标记源类。

要创建一个超类并将方法参数中的源类引用替换为超类引用，请选择   提取超类并在可能的地方使用  。 CLion 在   重构预览   窗格的   查找   工具窗口中显示建议的更改。

### 引入对象或数组解构

解构让您可以轻松地将数组和对象中的值解包到变量中。 此功能具有非常简洁的语法，通常在需要在您的应用程序中传递数据时使用。 欲了解更多信息，请参阅 [Exploring ES6](http://exploringjs.com/es6/ch_destructuring.html)。

在 CLion 中，您可以使用意图操作 `Alt+Enter` (Windows), `⌥ ⏎` (macOS), `⌥ ⏎` (IntelliJ IDEA Classic (macOS)), `⌥ ⏎` (macOS System Shortcuts), `Alt+Enter` (XWin), `Alt+Enter` (GNOME), `Alt+Enter` (KDE), `Alt+Enter` (Emacs), `Alt+Enter` (Sublime Text), `⌥ ⏎` (Sublime Text (macOS)), `⌥ ⏎` (Xcode), `Alt+Enter` (Visual Studio), `⌥ ⏎` (Visual Studio (macOS)), `Alt+Enter` (ReSharper), `⌥ ⏎` (ReSharper (macOS)), `Alt+Enter` (QtCreator), `⌥ ⏎` (QtCreator (macOS)), `Alt+Enter` (NetBeans), `Ctrl+1` (Eclipse), `⌘ 1` (Eclipse (macOS)) 调用解构。 使用  替换为对象/数组解构  操作，原始赋值将被删除。 为了保持此分配，请使用  引入对象/数组解构 。

[Video](https://resources.jetbrains.com/help/img/idea/2026.3/ws_js_refactoring_destructuring.mp4)

Procedure: 替换原始分配

1. 请将文本光标放在数组或对象中的某个值上，然后按 `Alt+Enter` (Windows), `⌥ ⏎` (macOS), `⌥ ⏎` (IntelliJ IDEA Classic (macOS)), `⌥ ⏎` (macOS System Shortcuts), `Alt+Enter` (XWin), `Alt+Enter` (GNOME), `Alt+Enter` (KDE), `Alt+Enter` (Emacs), `Alt+Enter` (Sublime Text), `⌥ ⏎` (Sublime Text (macOS)), `⌥ ⏎` (Xcode), `Alt+Enter` (Visual Studio), `⌥ ⏎` (Visual Studio (macOS)), `Alt+Enter` (ReSharper), `⌥ ⏎` (ReSharper (macOS)), `Alt+Enter` (QtCreator), `⌥ ⏎` (QtCreator (macOS)), `Alt+Enter` (NetBeans), `Ctrl+1` (Eclipse), `⌘ 1` (Eclipse (macOS))。

2. 从列表中选择   替换为对象解构   或   替换为数组解构  。

如果数组或对象中的某些值未被使用，则这些元素将被跳过：

Procedure: 保持原始分配

1. 请将文本光标放在数组或对象中的某个值上，然后按 `Alt+Enter` (Windows), `⌥ ⏎` (macOS), `⌥ ⏎` (IntelliJ IDEA Classic (macOS)), `⌥ ⏎` (macOS System Shortcuts), `Alt+Enter` (XWin), `Alt+Enter` (GNOME), `Alt+Enter` (KDE), `Alt+Enter` (Emacs), `Alt+Enter` (Sublime Text), `⌥ ⏎` (Sublime Text (macOS)), `⌥ ⏎` (Xcode), `Alt+Enter` (Visual Studio), `⌥ ⏎` (Visual Studio (macOS)), `Alt+Enter` (ReSharper), `⌥ ⏎` (ReSharper (macOS)), `Alt+Enter` (QtCreator), `⌥ ⏎` (QtCreator (macOS)), `Alt+Enter` (NetBeans), `Ctrl+1` (Eclipse), `⌘ 1` (Eclipse (macOS))。

2. 从列表中选择   介绍对象解构   或   介绍数组解构  。

此意图操作在使用 React 类组件时非常方便：

Procedure: 为函数生成解构参数

1. 将文本光标放置在函数的参数处并按下 `Alt+Enter` (Windows), `⌥ ⏎` (macOS), `⌥ ⏎` (IntelliJ IDEA Classic (macOS)), `⌥ ⏎` (macOS System Shortcuts), `Alt+Enter` (XWin), `Alt+Enter` (GNOME), `Alt+Enter` (KDE), `Alt+Enter` (Emacs), `Alt+Enter` (Sublime Text), `⌥ ⏎` (Sublime Text (macOS)), `⌥ ⏎` (Xcode), `Alt+Enter` (Visual Studio), `⌥ ⏎` (Visual Studio (macOS)), `Alt+Enter` (ReSharper), `⌥ ⏎` (ReSharper (macOS)), `Alt+Enter` (QtCreator), `⌥ ⏎` (QtCreator (macOS)), `Alt+Enter` (NetBeans), `Ctrl+1` (Eclipse), `⌘ 1` (Eclipse (macOS))。

2. 从列表中选择   将参数转换为对象  。

![有意通过解构操作：将参数转换为对象](https://resources.jetbrains.com/help/img/idea/2026.3/ws_js_destructuring_convert_params.png)

## 内联重构

内联重构与 [提取重构](#javascript_extract_refactorings)相反。

示例 1：内联变量

内联变量  重构用该变量或常量的初始化器替换冗余的使用。 这种重构仅适用于块级作用域和函数作用域变量。

重构前:

```JAVASCRIPT
Parenizor.method('toString', function () {
    var string = '(' + this.getValue() + ')';
    return string;
}                            
```

重构后:

```JAVASCRIPT
Parenizor.method('toString', function () {
    return '(' + this.getValue() + ')';
}

```

示例 2：内联函数

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

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

重构前:

```JAVASCRIPT
function Sum(a, b) {
    return a + b;
}

function Multiplication(a, b) {
    c = Sum(a, b);
    d = c * c;
    return d;
}

function Division(a, b) {
    c = Sum(a, b);
    d = Multiplication(a, b);
    result = c / d;
    return result;
}

```

重构后:

```JAVASCRIPT
function Multiplication(a, b) {
    c = a + b;
    d = c * c;
    return d;
}

function Division(a, b) {
    c = a + b;
    d = Multiplication(a, b);
    result = c / d;
    return result;
}


```

Procedure: 运行 Inline 重构

1. 在编辑器中，把文本光标放在要内联的符号上，然后按 `Ctrl+Alt+N` (Windows), `⌘ ⌥ N` (macOS), `⌘ ⌥ N` (IntelliJ IDEA Classic (macOS)), `⌘ ⌥ N` (macOS System Shortcuts), `Ctrl+Alt+N` (XWin), `Ctrl+Alt+N` (GNOME), `Ctrl+Alt+N` (KDE), `Ctrl+Alt+N` (Emacs), `Ctrl+Alt+N` (Sublime Text), `⌘ ⌥ N` (Sublime Text (macOS)), `⌘ ⌥ N` (Xcode), `Ctrl+R, I` (Visual Studio), `⌘ R, I` (Visual Studio (macOS)), `Ctrl+Alt+N` (ReSharper), `⌘ ⌥ N` (ReSharper (macOS)), `Ctrl+Alt+N` (QtCreator), `⌘ ⌥ N` (QtCreator (macOS)), `Ctrl+Alt+N` (NetBeans), `Alt+Shift+I` (Eclipse), `⌘ ⌥ I` (Eclipse (macOS)) 或从上下文菜单或主菜单中选择  `重构 | 内联` 。

## 更改签名重构

使用  Change Signature 重构来更改函数名称，添加、删除、重新排序和重命名参数，并在调用层级中传播新参数。

您还可以使用 [Introduce Parameter](#javascript_extract_parameter)重构来添加参数。

以下示例展示了运行 Change Signature 重构的不同方式。 在所有情况下，函数  `result()`  被重命名为  `generate_result()` ，并且该函数添加了一个新的参数  `input` 。 示例显示了函数调用、调用函数  `show_result()` 和其他代码片段在不同重构设置下可能受到的影响。

示例 1：重命名函数、添加参数并通过函数调用传递其值

在此示例中，函数  `result()`  被重命名为  `generate_result()` ，添加了一个参数  `input` ，并将值  `100`  作为参数传递到函数调用中。

重构前:

```JAVASCRIPT
function result() {
}

function show_result() {
    alert('Result: ' + result());
}

```

重构后:

```JAVASCRIPT
function generate_result(input) {
}

function show_result() {
    alert('Result: ' + generate_result(100));
}

```

示例 2：重命名函数并添加默认参数

在此示例中，函数  `result()` 被重命名为  `generate_result()` 。 默认参数  `input` 已添加，值为  `100` 。 新参数在  `generate_result()`  中以  `function generate_result(input = 100) {}`  的格式为 ES6 语言级别或  `input = input || 100`  的格式为 ES5 进行初始化。

重构前:

```JAVASCRIPT
function result() {
}

function show_result() {
    alert('Result: ' + result());
}

```

重构后:

```JAVASCRIPT
function generate_result(input = 100) {
}

function show_result() {

alert('Result: ' + generate_result());
}



```

示例 3：重命名函数，添加默认参数，并将参数传递到函数调用

在此示例中，函数  `result()` 被重命名为  `generate_result()` 。 默认参数  `input` 已添加，值为  `100` 。 新参数在  `generate_result()`  中以  `function generate_result(input = 100) {}`  的格式为 ES6 语言级别或  `input = input || 100`  的格式为 ES5 进行初始化。  `input`  参数通过调用函数 show_result() 传播，因此函数调用相应地更改。

重构前:

```JAVASCRIPT
function result() {
}

function show_result() {
    alert('Result: ' + result());
}

```

重构前:

```JAVASCRIPT
function generate_result(input = 100) {
}

function show_result() {

alert('Result: ' + generate_result());
}



```

Procedure: 调用更改签名

* 在编辑器中，将文本光标放在待重构的函数名称内，按 `Ctrl+F6` (Windows), `⌘ F6` (macOS), `⌘ F6` (IntelliJ IDEA Classic (macOS)), `⌘ ⌥ S` (macOS System Shortcuts), `Ctrl+F6` (XWin), `Ctrl+F6` (GNOME), `Ctrl+6` (KDE), `Ctrl+F6` (Emacs), `Ctrl+F6` (Sublime Text), `Ctrl+F6` (Sublime Text (macOS)), `⌘ F6` (Xcode), `Ctrl+R, S` (Visual Studio), `⌘ R, S` (Visual Studio (macOS)), `Ctrl+F6` (ReSharper), `⌘ F6` (ReSharper (macOS)), `Ctrl+F6` (QtCreator), `⌘ F6` (QtCreator (macOS)), `Ctrl+F6` (NetBeans), `Alt+Shift+C` (Eclipse), `⌘ ⌥ C` (Eclipse (macOS)) 或从上下文菜单或主菜单中选择   重构 | 更改签名  。   更改签名  对话框已打开。

Procedure: 重命名函数

* 在   更改签名  对话框 `Ctrl+F6` (Windows), `⌘ F6` (macOS), `⌘ F6` (IntelliJ IDEA Classic (macOS)), `⌘ ⌥ S` (macOS System Shortcuts), `Ctrl+F6` (XWin), `Ctrl+F6` (GNOME), `Ctrl+6` (KDE), `Ctrl+F6` (Emacs), `Ctrl+F6` (Sublime Text), `Ctrl+F6` (Sublime Text (macOS)), `⌘ F6` (Xcode), `Ctrl+R, S` (Visual Studio), `⌘ R, S` (Visual Studio (macOS)), `Ctrl+F6` (ReSharper), `⌘ F6` (ReSharper (macOS)), `Ctrl+F6` (QtCreator), `⌘ F6` (QtCreator (macOS)), `Ctrl+F6` (NetBeans), `Alt+Shift+C` (Eclipse), `⌘ ⌥ C` (Eclipse (macOS))中，编辑   名称  字段。

Procedure: 管理函数参数

* 在   更改签名  对话框 `Ctrl+F6` (Windows), `⌘ F6` (macOS), `⌘ F6` (IntelliJ IDEA Classic (macOS)), `⌘ ⌥ S` (macOS System Shortcuts), `Ctrl+F6` (XWin), `Ctrl+F6` (GNOME), `Ctrl+6` (KDE), `Ctrl+F6` (Emacs), `Ctrl+F6` (Sublime Text), `Ctrl+F6` (Sublime Text (macOS)), `⌘ F6` (Xcode), `Ctrl+R, S` (Visual Studio), `⌘ R, S` (Visual Studio (macOS)), `Ctrl+F6` (ReSharper), `⌘ F6` (ReSharper (macOS)), `Ctrl+F6` (QtCreator), `⌘ F6` (QtCreator (macOS)), `Ctrl+F6` (NetBeans), `Alt+Shift+C` (Eclipse), `⌘ ⌥ C` (Eclipse (macOS))中，使用参数表及其右侧的按钮：

* 要添加新参数，请点击 ![添加按钮](https://resources.jetbrains.com/help/img/idea/2026.3/app.expui.general.add.svg)  `Alt+Insert` (Windows), `⌘ N` (macOS), `⌃ N` (IntelliJ IDEA Classic (macOS)), `⌘ N` (macOS System Shortcuts), `Alt+Insert` (XWin), `Alt+Insert` (GNOME), `Alt+Insert` (KDE), `Alt+Insert` (Emacs), `Ctrl+N` (Sublime Text), `⌘ N` (Sublime Text (macOS)), `⌘ N` (Xcode), `Ctrl+N` (Visual Studio), `⌘ N` (Visual Studio (macOS)), `Alt+Insert` (ReSharper), `⌥ Insert` (ReSharper (macOS)), `Alt+Insert` (QtCreator), `Alt+Insert` (QtCreator (macOS)), `Alt+Insert` (NetBeans), `Alt+Insert` (Eclipse), `⌘ N` (Eclipse (macOS))并指定新参数的名称及其默认值或通过函数调用传递的值。 请参见 [示例1](#javascript_change_signature_examples_example_1_rename_function_and_add_required_parameter)和 [示例2](#javascript_change_signature_examples_example_2_rename_function_and_add_optional_parameter)上方。

* 要删除参数，请点击相应行中的任意一个单元格，然后点击 ![删除按钮](https://resources.jetbrains.com/help/img/idea/2026.3/app.expui.general.remove.svg)  `Alt+Delete` (Windows), `⌘ ⌦` (macOS), `⌘ ⌦` (IntelliJ IDEA Classic (macOS)), `⌘ ⌦` (macOS System Shortcuts), `Alt+Delete` (XWin), `Alt+Delete` (GNOME), `Alt+Delete` (KDE), `Alt+Delete` (Emacs), `Alt+Delete` (Sublime Text), `⌘ ⌦` (Sublime Text (macOS)), `⌘ ⌦` (Xcode), `Ctrl+R, D` (Visual Studio), `⌘ R, D` (Visual Studio (macOS)), `Alt+Delete` (ReSharper), `⌥ ⌦` (ReSharper (macOS)), `Alt+Delete` (QtCreator), `⌘ ⌦` (QtCreator (macOS)), `Alt+Delete` (NetBeans), `Alt+Delete` (Eclipse), `Alt+Delete` (Eclipse (macOS))。

* 要重新排序参数，请使用 ![上一个出现按钮](https://resources.jetbrains.com/help/img/idea/2026.3/app.expui.general.up.svg)  `Alt+Up` (Windows), `⌃ ⇧ ↑` (macOS), `⌃ ↑` (IntelliJ IDEA Classic (macOS)), `⌃ ⌥ ↑` (macOS System Shortcuts), `Alt+Up` (XWin), `Alt+Up` (GNOME), `Alt+Up` (KDE), `Alt+Up` (Emacs), `Alt+Up` (Sublime Text), `Alt+Up` (Sublime Text (macOS)), `⌥ ↑` (Xcode), `Alt+Up` (Visual Studio), `⌃ ⇧ ↑` (Visual Studio (macOS)), `Alt+Up` (ReSharper), `⌃ ⇧ ↑` (ReSharper (macOS)), `Alt+Up` (QtCreator), `⌃ ⇧ ↑` (QtCreator (macOS)), `Ctrl+Alt+Up` (NetBeans), `Ctrl+Shift+Up` (Eclipse), `⌃ ⌥ ↑` (Eclipse (macOS)) 和 ![下一个 Occurrence 按钮](https://resources.jetbrains.com/help/img/idea/2026.3/app.expui.general.down.svg)  `Alt+Down` (Windows), `⌃ ⇧ ↓` (macOS), `⌃ ↓` (IntelliJ IDEA Classic (macOS)), `⌃ ⌥ ↓` (macOS System Shortcuts), `Alt+Down` (XWin), `Alt+Down` (GNOME), `Alt+Down` (KDE), `Alt+Down` (Emacs), `Alt+Down` (Sublime Text), `Alt+Down` (Sublime Text (macOS)), `⌥ ↓` (Xcode), `Alt+Down` (Visual Studio), `⌃ ⇧ ↓` (Visual Studio (macOS)), `Alt+Down` (ReSharper), `⌃ ⇧ ↓` (ReSharper (macOS)), `Alt+Down` (QtCreator), `⌃ ⇧ ↓` (QtCreator (macOS)), `Ctrl+Alt+Down` (NetBeans), `Ctrl+Shift+Down` (Eclipse), `⌃ ⌥ ↓` (Eclipse (macOS))。

* 要重命名参数，请编辑 名称 字段。

* 如果必要，请 [传递新参数](#propagate_params) 到调用当前函数的函数中。

Procedure: 沿调用层次传播参数

1. 在   更改签名  对话框 `Ctrl+F6` (Windows), `⌘ F6` (macOS), `⌘ F6` (IntelliJ IDEA Classic (macOS)), `⌘ ⌥ S` (macOS System Shortcuts), `Ctrl+F6` (XWin), `Ctrl+F6` (GNOME), `Ctrl+6` (KDE), `Ctrl+F6` (Emacs), `Ctrl+F6` (Sublime Text), `Ctrl+F6` (Sublime Text (macOS)), `⌘ F6` (Xcode), `Ctrl+R, S` (Visual Studio), `⌘ R, S` (Visual Studio (macOS)), `Ctrl+F6` (ReSharper), `⌘ F6` (ReSharper (macOS)), `Ctrl+F6` (QtCreator), `⌘ F6` (QtCreator (macOS)), `Ctrl+F6` (NetBeans), `Alt+Shift+C` (Eclipse), `⌘ ⌥ C` (Eclipse (macOS))中，选择参数并点击 ![Propagate Parameter 按钮](https://resources.jetbrains.com/help/img/idea/2026.3/propagateParameters.png)。   选择传播新参数的方法  对话框打开。 左侧窗格显示函数调用的层次结构。 当您选择一个函数时，右侧窗格会显示其代码和它调用的函数的代码，分别在   调用方法   和   被调用方法   字段中。

请参见 [Example 3](#javascript_change_signature_examples_example_3_rename_function_and_add_required_parameter_propagate_param_to_call)上方。

2. 在左侧窗格中，选中您想要传播参数的函数旁边的复选框，然后点击   确定  。

Procedure: 预览更改并完成重构

1. 在   更改签名  对话框中，点击   预览  。

2. 在   重构预览  选项卡中， [“查找”工具窗口](find-tool-window.html)， [查看预期的更改](null)，进行必要的调整，并在准备好时点击   执行重构  。

> **Note:**
> 若要立即执行重构，请点击   重构  。

## 将默认导出转换为命名导出

对于类、函数、常量变量、字符串、对象和类型，您可以将  `export default`  语句替换为命名的  `export`  语句，并相应更新对应的  `import`  语句。

[Video](https://resources.jetbrains.com/help/img/idea/2026.3/js_convert_default_export_to_named_intro.mp4)

如果符号被重新导出，相应的  `export`  语句也会更新。

[Video](https://resources.jetbrains.com/help/img/idea/2026.3/js_convert_default_export_to_named_reexport.mp4)

Procedure:

重构可以从  `export default`  和  `import`  语句中调用。

* 将光标放在  `export default`  语句或您要导出的名称上，按 `Alt+Enter` (Windows), `⌥ ⏎` (macOS), `⌥ ⏎` (IntelliJ IDEA Classic (macOS)), `⌥ ⏎` (macOS System Shortcuts), `Alt+Enter` (XWin), `Alt+Enter` (GNOME), `Alt+Enter` (KDE), `Alt+Enter` (Emacs), `Alt+Enter` (Sublime Text), `⌥ ⏎` (Sublime Text (macOS)), `⌥ ⏎` (Xcode), `Alt+Enter` (Visual Studio), `⌥ ⏎` (Visual Studio (macOS)), `Alt+Enter` (ReSharper), `⌥ ⏎` (ReSharper (macOS)), `Alt+Enter` (QtCreator), `⌥ ⏎` (QtCreator (macOS)), `Alt+Enter` (NetBeans), `Ctrl+1` (Eclipse), `⌘ 1` (Eclipse (macOS))，然后选择   将默认导出转换为命名导出  。 要切换预览，请按 `Ctrl+Q` (Windows), `F1` (macOS), `⌃ J` (IntelliJ IDEA Classic (macOS)), `⌘ I` (macOS System Shortcuts), `Ctrl+Q` (XWin), `Ctrl+Q` (GNOME), `Ctrl+Q` (KDE), `Ctrl+Q` (Emacs), `Ctrl+Q` (Sublime Text), `Ctrl+Q` (Sublime Text (macOS)), `⌘ ⌃ ⇧ /` (Xcode), `Ctrl+K, I` (Visual Studio), `⌘ K, I` (Visual Studio (macOS)), `Ctrl+Q` (ReSharper), `⌃ Q` (ReSharper (macOS)), `Ctrl+Q` (QtCreator), `Ctrl+Q` (QtCreator (macOS)), `Ctrl+Q` (NetBeans), `Alt+Middle-Click` (Eclipse), `⌥ Middle-Click` (Eclipse (macOS))。

![从 export 语句中调用 export default 转换](https://resources.jetbrains.com/help/img/idea/2026.3/js_convert_default_export_to_named_from_export.png)

* 在  `import`  语句中，将光标放在导入内容的名称上，按 `Alt+Enter` (Windows), `⌥ ⏎` (macOS), `⌥ ⏎` (IntelliJ IDEA Classic (macOS)), `⌥ ⏎` (macOS System Shortcuts), `Alt+Enter` (XWin), `Alt+Enter` (GNOME), `Alt+Enter` (KDE), `Alt+Enter` (Emacs), `Alt+Enter` (Sublime Text), `⌥ ⏎` (Sublime Text (macOS)), `⌥ ⏎` (Xcode), `Alt+Enter` (Visual Studio), `⌥ ⏎` (Visual Studio (macOS)), `Alt+Enter` (ReSharper), `⌥ ⏎` (ReSharper (macOS)), `Alt+Enter` (QtCreator), `⌥ ⏎` (QtCreator (macOS)), `Alt+Enter` (NetBeans), `Ctrl+1` (Eclipse), `⌘ 1` (Eclipse (macOS))，然后选择   将默认导出转换为命名导出  。 预览（ `Ctrl+Q` (Windows), `F1` (macOS), `⌃ J` (IntelliJ IDEA Classic (macOS)), `⌘ I` (macOS System Shortcuts), `Ctrl+Q` (XWin), `Ctrl+Q` (GNOME), `Ctrl+Q` (KDE), `Ctrl+Q` (Emacs), `Ctrl+Q` (Sublime Text), `Ctrl+Q` (Sublime Text (macOS)), `⌘ ⌃ ⇧ /` (Xcode), `Ctrl+K, I` (Visual Studio), `⌘ K, I` (Visual Studio (macOS)), `Ctrl+Q` (ReSharper), `⌃ Q` (ReSharper (macOS)), `Ctrl+Q` (QtCreator), `Ctrl+Q` (QtCreator (macOS)), `Ctrl+Q` (NetBeans), `Alt+Middle-Click` (Eclipse), `⌥ Middle-Click` (Eclipse (macOS))）显示  `import`  语句将如何更新。

![从导入语句调用默认导出转换](https://resources.jetbrains.com/help/img/idea/2026.3/js_convert_default_export_to_named_from_import.png)

> **Note:**
> * 您还可以在 TypeScript、Vue、React 和 Angular 上下文中使用此操作。
>
> * 此转换仅在导出的符号已命名时可用。

## 将具名导出转换为默认导出

对于类、函数、常量变量、字符串、对象和类型，您可以将具名  `export`  语句替换为  `export default`  语句，并使相应的  `import`  语句自动更新。

[Video](https://resources.jetbrains.com/help/img/idea/2026.3/javascript_refactoring_convert_named_export_to_default_export_intro.mp4)

Procedure:

重构可以从  `export default`  和  `import`  语句中调用。

* 将插入符号放置在  `export`  语句中要导出的名称上，按下 `Alt+Enter` (Windows), `⌥ ⏎` (macOS), `⌥ ⏎` (IntelliJ IDEA Classic (macOS)), `⌥ ⏎` (macOS System Shortcuts), `Alt+Enter` (XWin), `Alt+Enter` (GNOME), `Alt+Enter` (KDE), `Alt+Enter` (Emacs), `Alt+Enter` (Sublime Text), `⌥ ⏎` (Sublime Text (macOS)), `⌥ ⏎` (Xcode), `Alt+Enter` (Visual Studio), `⌥ ⏎` (Visual Studio (macOS)), `Alt+Enter` (ReSharper), `⌥ ⏎` (ReSharper (macOS)), `Alt+Enter` (QtCreator), `⌥ ⏎` (QtCreator (macOS)), `Alt+Enter` (NetBeans), `Ctrl+1` (Eclipse), `⌘ 1` (Eclipse (macOS))，然后选择   将具名导出转换为默认导出  。 要切换预览，请按 `Ctrl+Q` (Windows), `F1` (macOS), `⌃ J` (IntelliJ IDEA Classic (macOS)), `⌘ I` (macOS System Shortcuts), `Ctrl+Q` (XWin), `Ctrl+Q` (GNOME), `Ctrl+Q` (KDE), `Ctrl+Q` (Emacs), `Ctrl+Q` (Sublime Text), `Ctrl+Q` (Sublime Text (macOS)), `⌘ ⌃ ⇧ /` (Xcode), `Ctrl+K, I` (Visual Studio), `⌘ K, I` (Visual Studio (macOS)), `Ctrl+Q` (ReSharper), `⌃ Q` (ReSharper (macOS)), `Ctrl+Q` (QtCreator), `Ctrl+Q` (QtCreator (macOS)), `Ctrl+Q` (NetBeans), `Alt+Middle-Click` (Eclipse), `⌥ Middle-Click` (Eclipse (macOS))。

![从 export 语句中将具名导出转换为默认导出](https://resources.jetbrains.com/help/img/idea/2026.3/javascript_refactoring_convert_named_export_to_default_export_from_export.png)

* 在  `import`  语句中，将光标放在导入内容的名称上，按 `Alt+Enter` (Windows), `⌥ ⏎` (macOS), `⌥ ⏎` (IntelliJ IDEA Classic (macOS)), `⌥ ⏎` (macOS System Shortcuts), `Alt+Enter` (XWin), `Alt+Enter` (GNOME), `Alt+Enter` (KDE), `Alt+Enter` (Emacs), `Alt+Enter` (Sublime Text), `⌥ ⏎` (Sublime Text (macOS)), `⌥ ⏎` (Xcode), `Alt+Enter` (Visual Studio), `⌥ ⏎` (Visual Studio (macOS)), `Alt+Enter` (ReSharper), `⌥ ⏎` (ReSharper (macOS)), `Alt+Enter` (QtCreator), `⌥ ⏎` (QtCreator (macOS)), `Alt+Enter` (NetBeans), `Ctrl+1` (Eclipse), `⌘ 1` (Eclipse (macOS))，然后选择   将具名导出转换为默认导出  。 预览（ `Ctrl+Q` (Windows), `F1` (macOS), `⌃ J` (IntelliJ IDEA Classic (macOS)), `⌘ I` (macOS System Shortcuts), `Ctrl+Q` (XWin), `Ctrl+Q` (GNOME), `Ctrl+Q` (KDE), `Ctrl+Q` (Emacs), `Ctrl+Q` (Sublime Text), `Ctrl+Q` (Sublime Text (macOS)), `⌘ ⌃ ⇧ /` (Xcode), `Ctrl+K, I` (Visual Studio), `⌘ K, I` (Visual Studio (macOS)), `Ctrl+Q` (ReSharper), `⌃ Q` (ReSharper (macOS)), `Ctrl+Q` (QtCreator), `Ctrl+Q` (QtCreator (macOS)), `Ctrl+Q` (NetBeans), `Alt+Middle-Click` (Eclipse), `⌥ Middle-Click` (Eclipse (macOS))）显示  `import`  语句将如何更新。

![从 export 语句中将具名导出转换为默认导出](https://resources.jetbrains.com/help/img/idea/2026.3/javascript_refactoring_convert_named_export_to_default_export_from_import.png)

> **Note:**
> 仅当导出文件中尚未存在  `默认`  导出时，该重构操作才可用。

## See also

### 流程

[重构](refactoring-source-code.html)

