# JavaScript のリファクタリング

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

> **TL;DR**
> 必須プラグイン  ：
>
>
>
> `JavaScript and TypeScript` ：このプラグインは CLion にバンドルされており、デフォルトで有効化されています。

[リファクタリング(英語)](https://en.wikipedia.org/wiki/Code_refactoring)とは、アプリケーションの動作を変更せずにソースコードを更新することを意味します。 リファクタリングは、コードを安定した [dry(英語)](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 はメンバーの可視性を必要なレベルまで自動的に上げます。 可視性レベルを変更しない場合は、   可視性   の   そのまま   をクリックします。

## クラスメンバーのプルアップリファクタリング

クラスメンバーをプルアップする リファクタリングは、現在のクラスからスーパークラスにクラス階層を上に移動します。

サンプル: クラスメソッドをスーパークラスに移動する

抽象クラス  `Department`  を拡張するクラス  `AccountingDepartment`  があるとします。 この例では、  クラスメンバーをプルアップする リファクタリングは  `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 は他のファイルのインポートステートメント内のこのファイル名を更新します。

![Rename class and file](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) ページの   ファイル名規則（Filename convention）を適用   リストから選択されたスタイルによって決まります。

![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)

関数、変数、パラメーターの  名前変更 リファクタリングはインプレースで実行される場合がありますが、 `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. キャンバスのあるフィールドで、新しい関数名、変数名、またはパラメーター名を入力します。

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 は動的であるため、動的参照が有効な使用箇所であり、名前を変更する必要がある場合があります。 ただし、多くの場合、動的な使用箇所の名前を変更することは、予期された動作ではありません。 以下の例では、  `rename.test()`  で  `test()`  を  `test1()`  に変更することは正しいですが、  `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 は複雑なリファクタリングを適用する前に必ず   プレビュー  ウィンドウを表示します。

* シンボルの動的な使用例を表示するには、 ![the Show Dynamic Usages toggle button](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 は、パラメーター、変数、定数、フィールド、メソッド、関数を導入するための  抽出 リファクタリングを複数提供しています。 これらのリファクタリングを実行するには、リファクタリング対象の式を選択し、  `リファクタリング｜<target>`  を選択します。 式全体を選択するか、その中にキャレットを置くと、CLion が選択を支援します。

### パラメーターの導入

パラメーターの導入 リファクタリングを使用して、関数呼び出しの式をパラメーターで置き換えます。 CLion は、それに応じて関数の宣言と呼び出しを更新します。 新しいパラメーターのデフォルト値は、関数本体の中で初期化することも、関数呼び出しを渡すこともできます。

関数  `calculate_sum(i)`  にハードコードされた  `1`  を含むコードがあるとします。 パラメーターの導入リファクタリングを使用すると、このハードコードされた  `1`  を  `i2`  パラメーターに置き換えることができます。 新しい  `i2`  パラメーターは、  オプション または  必須 として抽出できます。

例 1: オプションのパラメーターの紹介

新しいパラメーター  `i2`  がオプションのパラメーターとして抽出されます。 新しいパラメーターは  `calculate_sum(i)`  の本体で初期化され、  `show_sum()`  の  `calculate_sum(i)`  の呼び出しは変更されません。

下記の [パラメーター型の選択 (オプション)](#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`  が必須パラメーターとして抽出され、  `show_sum()`  内の  `calculate_sum(i)`  の呼び出しがそれに応じて変更されます。

下の [パラメーター型の選択 (必須)](#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. 新しいパラメーターの型（  オプション または  必須 ）を選択し、該当する場合はデフォルト値を指定します。

* 省略可能なパラメーター チェックボックスが選択されている場合、パラメーターはファンクション本体のデフォルト値で初期化されます。 上の [パラメーターの紹介の例 1](#javascript_extract_parameter_examples_example_1_optional_parameter) を参照してください。

* 省略可能なパラメーター チェックボックスをオフにすると、既定のパラメーター値が既存の関数呼び出しを介して渡されます。 新しい関数シグネチャーに従ってすべての関数呼び出しが変更され、パラメーターの初期化が関数本体に追加されます。 上の [パラメーターの紹介の例 2](#javascript_extract_parameter_examples_example_2_required_parameter) を参照してください。

最初は、CLion はリファクタリングが呼び出された式をデフォルト値として受け入れます。 ほとんどの場合、変更する必要はありません。 それでも必要な場合は、JSDoc コメントに  `@param <parameter name> - <default value>`  の形式で別のデフォルト値を指定してください。

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 コードでは、  `i2 = i2 || 1;`  の代わりに新しいデフォルト関数のパラメーター構文  `function calculate_sum(i, i2 = 1)`  が適用されます。 [https://developer.mozilla.orgWeb サイト](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Default_parameters)のデフォルト関数型パラメーターの詳細を参照してください。

#### リファクタリングモードの選択

エディター（インプレースモード）で直接パラメーターを抽出 [上記で説明されているように](#javascript_extract_parameter_inplace_refactoring)、または   パラメーターの導入ダイアログ  を利用できます。 この2つのアプローチは非常に似ていますが、違いは次のとおりです：

* [リファクタリングの結果のプレビュー](null)。 ダイアログで、 プレビュー をクリックして、 検索 ツールウィンドウの専用タブで予想される変更を確認できます。 インプレースモードでは、この機能は使用できません。

* [デフォルトのパラメーター値の指定](#javascript_extract_parameter_inplace_optional_required_default_value)。 CLion のダイアログの 値 フィールドにデフォルトのパラメーター値が表示されます。提案を受け入れるか、別の値を入力します。 インプレースモードでは、CLion はリファクタリングが呼び出された式をデフォルトのパラメーター値として扱います。 別の値を指定するには、JSDoc コメントブロックを使用する必要があります。

デフォルトで、CLion はインプレースモードで Introduce Parameter リファクタリングを実行します。   パラメーターの導入   ダイアログを使用するには、   設定   ダイアログ（ `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)) ）を開き、   エディター | コード編集   に移動して、   リファクタリング   領域で   モーダルダイアログ内   オプションを選択します。

### 変数の導入

変数の導入 リファクタリングを使用して、式を [関数スコープ変数 (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) に置き換えます。 このリファクタリングにより、ソースコードの可読性と保守性が向上します。

`return`  ステートメントに部分的にハードコードされた式を持つ関数があるとします。

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

```

変数の導入リファクタリングを使用すると、  `'(' + this.getValue() + ')'`  式を変数（たとえば  `string`  ）で置き換えることができます。 抽出された変数のスコープは、その宣言  `var`  または  `let`  で使用されるステートメントと、新しい変数が宣言されるコンテキスト（関数の内部または外部）に依存します。

例 1: let ステートメント宣言を使用したブロックスコープ変数の紹介

変数  `string`  は、  `return`  ステートメントの  `'(' + this.getValue() + ')'`  式から抽出されます。 新しい変数は、  `Parenizor.method('toString', function ())`  内の  `let`  ステートメントで宣言されています。

リファクタリング前:

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

```

リファクタリング後:

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

```

例 2: 変数を導入し、関数外で変数を宣言する

変数  `appName`  は  `navigator.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. リストから、新しい変数の宣言で使用するステートメントを選択します：

* [関数スコープ変数](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/var)を導入するには、 var を選択します。

* [ブロックスコープ変数](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/let)を導入するには、 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 はインプレースモードで Introduce Variable リファクタリングを実行します。   変数の導入  ダイアログを使用するには、   設定  ダイアログ（ `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://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/const)に置き換えます。 このリファクタリングにより、ソースコードの可読性と保守性が向上します。 また、値や目的の説明がないままハードコードされた定数の使用を避けるのにも役立ちます。

クラス内では、読み取り専用フィールドを導入したり、複数のスコープが適している場合はスコープを選択したりできます。 他のコンテキストでは、CLion はローカル定数のみを導入します。

例 1: 導入された定数のスコープの選択

`"Department name :"`  がハードコードされているメソッド  `printName()`  を持つクラス  `AccountingDepartment`  があるとします。

```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)

### メソッドの抽出

メソッドの抽出 リファクタリングでは、抽出されたコードで名前付きのメソッドまたは関数を作成できます。  メソッドの抽出 リファクタリングが呼び出されると、CLion は選択したコード箇所の入力となる変数と、出力となる変数を検出します。 検出された出力変数は、抽出されたメソッドまたは関数の戻り値として使用されます。

以下の例では、  `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()`  関数内にあります。   関数 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. 選択した式が関数内にある場合は、リストから宛先スコープを選択してください：

* グローバル​タイトル​ を選択すると、抽出された関数は関数の外部で宣言されます。 上記の [例 1](#javascript_extract_method_examples_example_1_global_inside_another_function) を参照してください。

* 現在の囲み関数内で抽出された関数を定義するには、 関数 <current enclosing function name> を選択します。 上記の [例 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: デフォルトで関数抽出ダイアログを開く

* 設定   ダイアログ（ `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)) ）を開き、   エディター | コード編集   に移動して、   リファクタリング   領域で   モーダルダイアログ内   オプションを選択します。

### スーパークラスの抽出

スーパークラスの抽出 リファクタリングは、現在のクラスのメンバーに基づいて新しい抽象クラスを作成します。 作成されたクラスは自動的に拡張されます。

> **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 は、   検索  ツールウィンドウの   リファクタリングプレビュー  ペインで提案された変更を表示します。

### オブジェクトまたは配列の非構造化を導入

構造を分割すると、配列やオブジェクトの値を変数に簡単に解凍できます。 この機能には非常に簡潔な構文があり、アプリケーションでデータを渡す必要がある場合によく使用されます。 詳細については、 [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: インラインで実行リファクタリング

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)) を押すか、コンテキストメニューまたはメインメニューから  `リファクタリング｜インライン化`  を選択します。

## シグネチャーの変更リファクタリング

ファンクション名の変更、パラメーターの追加、削除、並べ替え、名前の変更、呼び出しの階層を介した新しいパラメーターの伝播には、  シグネチャーの変更 リファクタリングを使用します。

[Introduce Parameter](#javascript_extract_parameter)リファクタリングを使用してパラメーターを追加することもできます。

以下の例は、シグネチャーの変更リファクタリングを実行するためのさまざまな方法を示しています。 すべての場合において、関数  `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()`  で ES6 言語レベルの場合は  `function generate_result(input = 100) {}`  、ES5 の場合は  `input = input || 100`  の形式で初期化されます。

リファクタリング前:

```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()`  で ES6 言語レベルの場合は  `function generate_result(input = 100) {}`  、ES5 の場合は  `input = input || 100`  の形式で初期化されます。  `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)) および ![次の出現箇所ボタン](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) をクリックします。   新規パラメーターを伝播するメソッドの選択   ダイアログが開きます。 左側のペインには、関数呼び出しの階層が表示されます。 関数を選択すると、右側のペインのコードと、   呼び出し元メソッド   フィールドと   呼び出し先メソッド   フィールドにそれぞれ呼び出される関数のコードが表示されます。

上の [例 3](#javascript_change_signature_examples_example_3_rename_function_and_add_required_parameter_propagate_param_to_call) を参照してください。

2. 左側のペインで、パラメーターを伝播する機能の横にあるチェックボックスを選択し、   OK   をクリックします。

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)) を押します。

![エクスポートステートメントからエクスポートデフォルト変換を呼び出す](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)) を押します。

![エクスポートステートメントから名前付きエクスポートをデフォルトエクスポートに変換する](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`  ステートメントがどのように更新されるかが表示されます。

![エクスポートステートメントから名前付きエクスポートをデフォルトエクスポートに変換する](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)

