はじめに：引用符や括弧内のテキスト選択、面倒じゃないですか？

VSCodeで文字列編集をしていて、こんな経験はありませんか？

const message = "このテキストだけコピーしたい";
const path = '/home/user/documents/report.pdf';
const config = { name: "設定値", value: 123 };

ダブルクォーテーション内の文字列だけコピーしたいときに、以下のような操作が必要です：

1. マウスで開始位置をクリック
2. ドラッグして終了位置まで選択
3. Ctrl+Cでコピー

あるいは：

1. Ctrl+Shift+→を何度も押して単語単位で選択
2. 微調整のためにShift+→/←
3. Ctrl+Cでコピー

特に長い文字列や入れ子構造の場合、この作業は非常に煩雑です。

標準のVSCodeには「Ctrl+Shift+→」「Alt+Shift+→」などの単語単位選択機能がありますが、デリミタ（区切り文字）を意識した選択には対応していません。引用符や括弧の中身だけを1キー操作で選択・コピーできたら便利だと思いませんか？

そこで、カーソル位置から自動でデリミタを検索し、その間のテキストを1キーで選択・コピーするTypeScriptマクロを開発しました。

この記事で分かること

• デリミタ間テキスト選択コピーの機能と使い方
• 対応するデリミタの種類（18種類）
• コピーせず選択のみを行う Ctrl+Alt+S の活用法
• 選択方向による動作の違い（右方向/左方向）
• TypeScript実装の詳細コード
• 実務での活用例とパフォーマンス

実装した機能の概要

できること

2つのショートカットキーで使い分けられます：

• Ctrl+Alt+D : デリミタ間を選択してクリップボードにコピー
• Ctrl+Alt+S : デリミタ間を選択のみ（クリップボードは変更しない）

Ctrl+Alt+S は「コピー元でCtrl+Alt+D → 置換先でCtrl+Alt+S → Ctrl+V」というコピー&貼り付け置換の用途を想定しています。

Ctrl+Alt+D を押すだけで、カーソル位置の最も近いデリミタ間のテキストを自動選択・コピー

例：＜"「あいうえお」、【かきくけこ】、｛さしすせそ｝"＞
          ↑ここにカーソル
          
Ctrl+Alt+D を押す
          
→「あいうえお」だけが選択・コピーされる（引用符は除外）

対応デリミタ（18種類）

クォーテーション・スラッシュ系

• "～" (ダブルクォート)
• '～' (シングルクォート)
• `～` (バッククォート)
• /～/ (スラッシュ・半角)
• ／～／ (スラッシュ・全角)
• \～\ (バックスラッシュ・半角)
• ￥～￥ (円記号・全角)
• |～| (パイプ・半角)
• ｜～｜ (パイプ・全角)

括弧系（半角・全角）

• (～) / （～） (丸括弧)
• [～] (角括弧)
• {～} / ｛～｝ (波括弧)
• <～> / ＜～＞ (山括弧)
• 【～】 (墨付き括弧)
• 「～」 (鉤括弧)

3つの動作モード

1. 通常モード（カーソル位置から左に検索）

＜"「あいうえお」、【かきくけこ】"＞
       ↑カーソル
       
→ カーソルの左にある最も近い開始デリミタ「"」を検出
→ 対応する終了デリミタ「"」を右に検索
→ 「あいうえお」、【かきくけこ】 が選択される

2. 右方向モード（1文字選択 + カーソルが右側）

＜"「あいうえお」、【かきくけこ】"＞
   ↑選択    ↑カーソル（左→右に選択）
   
→ 選択文字「"」が開始デリミタか判定
→ 右に終了デリミタ「"」を検索
→ 「あいうえお」、【かきくけこ】 が選択される

3. 左方向モード（1文字選択 + カーソルが左側）

＜"「あいうえお」、【かきくけこ】"＞
   ↑カーソル ↑選択（右→左に選択）
   
→ 選択文字「"」が終了デリミタか判定
→ 左に開始デリミタ「"」を検索
→ 「あいうえお」、【かきくけこ】 が選択される

フォールバック機能

デリミタが見つからない場合は、行全体をコピー（Ctrl+Alt+D）または行全体を選択（Ctrl+Alt+S）します。

具体的な使用場面とメリット

場面1：コード内の文字列リテラルを抽出

const errorMessage = "接続に失敗しました。しばらく経ってから再度お試しください。";

文字列の中にカーソルを置いてCtrl+Alt+D → 文字列だけが即座にコピーされる。

従来の方法：

1. "の直後をクリック
2. Shift+Endで行末まで選択
3. Shift+←で"の手前まで調整
4. Ctrl+C

このマクロ：

1. 文字列内にカーソルを置く
2. Ctrl+Alt+D

たった1操作で完了！

場面2：ファイルパスを素早く抽出

const configPath = '/etc/nginx/sites-available/default';
const dataPath = '/var/www/html/data/uploads/2026/02/';

パス内にカーソルを置いてCtrl+Alt+D → パス全体がコピーされる。

場面3：JSONのキーや値を抽出

{
  "database": {
    "host": "localhost",
    "port": 5432,
    "name": "production_db"
  }
}

各値にカーソルを置いてCtrl+Alt+D → 値だけが抽出される。

場面4：正規表現パターンを抽出

const pattern = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;

パターン内にカーソルを置いてCtrl+Alt+D → 正規表現本体だけがコピーされる（/～/を除外）。

場面5：複雑な入れ子構造から特定部分を抽出

異なる種類のデリミタの入れ子

＜"「あいうえお」、【かきくけこ】、｛さしすせそ｝"＞

この複雑な構造でも：

• 「の後にカーソル → あいうえおが選択される
• 【の後にカーソル → かきくけこが選択される
• ＜の後にカーソル → 最外側の"～"が選択される

最も近いデリミタを自動判別するため、入れ子構造でも正確に動作します。

同じ種類のデリミタのネスト構造

function outer(a, inner(b, c), d)

この場合、カーソルがouterにあるとき：

• 左で最も近い(（outerの後）を検出
• ネストレベルを考慮して対応する)を検索
• 内側のinner(b, c)のネストをカウント
• a, inner(b, c), d全体が正確に選択される ✅

従来バージョンでは誤ってouter(a, inner(b, cが選択されていましたが、ネスト対応により正確に動作するようになりました。

場面6：Markdown内のコード抜き出し

インラインコードは`console.log('Hello')`のように書きます。

バッククォート内にカーソルを置いてCtrl+Alt+D → console.log('Hello')だけがコピーされる。

場面7：コピー&貼り付け置換（Ctrl+Alt+Sの活用）

Ctrl+Alt+S（選択のみ）との組み合わせで、貼り付けによる置換が手軽にできます。

const oldValue = "置換前の文字列";
const newValue = "置換後の文字列";

手順：

1. "置換前の文字列" 内にカーソル → Ctrl+Alt+D でコピー
2. "置換後の文字列" 内にカーソルを移動
3. Ctrl+Alt+S で置換対象を選択
4. Ctrl+V で貼り付け → 置換完了！

クリップボードを変更せずに置換先だけを選択できるので、途中でクリップボードが上書きされる心配がありません。

メリットまとめ

• マウス操作不要: カーソル位置だけで判定
• 高速: キーボード1回で完結
• 正確: デリミタを自動検出
• 柔軟: 選択方向で動作を変更可能、コピー/選択を使い分け可能
• 安全: デリミタが見つからなくても行全体をコピー/選択

改修履歴：ネスト構造への対応

改修前の問題点

初期バージョンでは、ネスト（入れ子）構造の括弧を正しく処理できない問題がありました。

問題の例：

function(b,c){...}

この場合、カーソルがfunctionにあるとき：

1. 左から最も近い開始デリミタ(を検出
2. その位置から右に最初に見つかった終了デリミタ)をマッチング
3. しかし、最初の)はb,c)の閉じ括弧なので、function(b,cが誤って選択される ❌

ネストレベルを考慮していないため、入れ子構造で誤動作していました。

改修内容：括弧のバランスを考慮したマッチング

VSCodeのCtrl+Shift+\（対応する括弧へジャンプ）と同じように、ネストレベルをカウントしながら対応する括弧を探すアルゴリズムを実装しました。

アルゴリズム：

1. カーソル位置から左に開始デリミタを検索
2. その位置から右に向かって：
   • 同じ開始デリミタが出現 → カウンタ +1（ネストが深くなる）
   • 対応する終了デリミタが出現 → カウンタ -1（ネストから抜ける）
   • カウンタが 0 になった位置が対応する終了デリミタ ✅

追加した関数：

• findMatchingEndDelimiter() - 順方向のネスト対応マッチング
• findMatchingStartDelimiter() - 逆方向のネスト対応マッチング

これにより、複雑な入れ子構造でも正確にデリミタのペアを検出できるようになりました。

TypeScript実装の詳細

実際のコードを紹介します。copyTextBetweenDelimiters.tsファイルに実装しました。

import * as vscode from 'vscode';

/**
 * デリミタペアの定義（開始文字と終了文字）
 */
const DELIMITER_PAIRS: Array<{ start: string; end: string }> = [
    { start: '"', end: '"' },
    { start: "'", end: "'" },
    { start: '`', end: '`' }, // バッククォート（テンプレートリテラル・Markdownインラインコード）
    { start: '/', end: '/' },
    { start: '／', end: '／' },
    { start: '\\', end: '\\' },
    { start: '￥', end: '￥' },
    { start: '|', end: '|' },
    { start: '｜', end: '｜' },
    { start: '「', end: '」' },
    { start: '[', end: ']' },
    { start: '【', end: '】' },
    { start: '{', end: '}' },
    { start: '｛', end: '｝' },
    { start: '(', end: ')' },
    { start: '（', end: '）' },
    { start: '<', end: '>' },
    { start: '＜', end: '＞' }
];

/**
 * デリミタで囲まれたテキストを選択してコピー（デリミタは除外）
 * - カーソル位置から左に開始デリミタを検索
 * - 対応する終了デリミタを右に検索
 * - 見つからない場合は行全体をコピー
 * - 1文字選択時はカーソル位置（選択方向）で動作を変更
 */
export async function copyTextBetweenDelimiters() {
    await processTextBetweenDelimiters(true); // 選択＋コピー
}

/**
 * デリミタで囲まれたテキストを選択するだけ（コピーしない）
 * - copyTextBetweenDelimiters と同じ検索ロジック
 * - 貼り付け先を選択してから Ctrl+V で置換する用途を想定
 */
export async function selectTextBetweenDelimiters() {
    await processTextBetweenDelimiters(false); // 選択のみ
}

/**
 * デリミタ間テキストの共通処理
 * @param copyToClipboard true=選択＋コピー、false=選択のみ
 */
async function processTextBetweenDelimiters(copyToClipboard: boolean) {
    const editor = vscode.window.activeTextEditor;
    if (!editor) {
        vscode.window.showWarningMessage('アクティブなエディタがありません');
        return;
    }

    const document = editor.document;
    const selection = editor.selection;
    const cursorPos = selection.active;
    const line = document.lineAt(cursorPos.line);
    const lineText = line.text;

    // 1文字選択時の特殊処理（選択方向で動作を変更）
    if (!selection.isEmpty && selection.end.character - selection.start.character === 1) {
        const selectedChar = lineText[selection.start.character];
        const charPos = selection.start.character;

        // カーソルが選択文字の右側（左→右選択）
        if (selection.active.character > selection.anchor.character) {
            const result = handleRightDirection(lineText, charPos, selectedChar);
            if (result) {
                await applyResult(editor, cursorPos.line, result.start, result.end, copyToClipboard);
                return;
            }
        }
        // カーソルが選択文字の左側（右→左選択）
        else if (selection.active.character < selection.anchor.character) {
            const result = handleLeftDirection(lineText, charPos, selectedChar);
            if (result) {
                await applyResult(editor, cursorPos.line, result.start, result.end, copyToClipboard);
                return;
            }
        }
    }

    // 通常処理：カーソル位置から左に開始デリミタを検索
    const result = findDelimitedText(lineText, cursorPos.character);

    if (result) {
        await applyResult(editor, cursorPos.line, result.start, result.end, copyToClipboard);
    } else {
        // 見つからない場合は行全体を対象
        if (copyToClipboard) {
            copyEntireLine(editor, cursorPos.line);
        } else {
            selectEntireLine(editor, cursorPos.line);
        }
    }
}

/**
 * 右方向処理：選択文字が開始デリミタかチェックし、右に終了デリミタを検索（ネスト考慮）
 */
function handleRightDirection(
    lineText: string,
    charPos: number,
    selectedChar: string
): { start: number; end: number } | null {
    for (const pair of DELIMITER_PAIRS) {
        if (selectedChar === pair.start) {
            // ネストレベルを考慮して対応する終了デリミタを検索
            const endPos = findMatchingEndDelimiter(lineText, charPos, pair.start, pair.end);
            if (endPos !== -1) {
                // デリミタを除外: 開始の次の文字から終了の前まで
                return { start: charPos + 1, end: endPos };
            }
        }
    }
    return null;
}

/**
 * 左方向処理：選択文字が終了デリミタかチェックし、左に開始デリミタを検索（ネスト考慮）
 */
function handleLeftDirection(
    lineText: string,
    charPos: number,
    selectedChar: string
): { start: number; end: number } | null {
    for (const pair of DELIMITER_PAIRS) {
        if (selectedChar === pair.end) {
            // ネストレベルを考慮して対応する開始デリミタを検索
            const startPos = findMatchingStartDelimiter(lineText, charPos, pair.start, pair.end);
            if (startPos !== -1) {
                // デリミタを除外: 開始の次の文字から終了の前まで
                return { start: startPos + 1, end: charPos };
            }
        }
    }
    return null;
}

/**
 * カーソル位置からデリミタで囲まれたテキストを検索（デリミタは除外）
 * - 左に開始デリミタを検索
 * - ネストレベルを考慮して対応する終了デリミタを右に検索
 */
function findDelimitedText(
    lineText: string,
    cursorPos: number
): { start: number; end: number } | null {
    let bestMatch: { start: number; end: number; startPos: number } | null = null;

    // 各デリミタペアについて検索
    for (const pair of DELIMITER_PAIRS) {
        // カーソル位置の左側で最後に出現する開始デリミタを検索
        let startPos = -1;
        for (let i = cursorPos - 1; i >= 0; i--) {
            if (lineText[i] === pair.start) {
                startPos = i;
                break;
            }
        }

        if (startPos === -1) {
            continue; // 開始デリミタが見つからない
        }

        // 対応する終了デリミタを検索（ネストレベルを考慮）
        const endPos = findMatchingEndDelimiter(lineText, startPos, pair.start, pair.end);

        if (endPos !== -1) {
            // カーソル位置が範囲内にあるかチェック
            if (startPos < cursorPos && cursorPos <= endPos) {
                // より近い開始デリミタを優先
                if (!bestMatch || startPos > bestMatch.startPos) {
                    // デリミタを除外: 開始の次の文字から終了の前まで
                    bestMatch = {
                        start: startPos + 1,
                        end: endPos,
                        startPos: startPos
                    };
                }
            }
        }
    }

    if (bestMatch) {
        return { start: bestMatch.start, end: bestMatch.end };
    }

    return null;
}

/**
 * ネストレベルを考慮して対応する終了デリミタを検索
 */
function findMatchingEndDelimiter(
    lineText: string,
    startPos: number,
    startDelimiter: string,
    endDelimiter: string
): number {
    // 開始と終了が同じ文字の場合（" や ' など）は従来の方式
    if (startDelimiter === endDelimiter) {
        return lineText.indexOf(endDelimiter, startPos + 1);
    }

    // 異なる文字の場合はネストレベルを考慮
    let nestLevel = 1; // 開始デリミタを見つけた状態から開始

    for (let i = startPos + 1; i < lineText.length; i++) {
        const char = lineText[i];

        if (char === startDelimiter) {
            nestLevel++; // 同じ開始デリミタが出現したらネストレベル+1
        } else if (char === endDelimiter) {
            nestLevel--; // 終了デリミタが出現したらネストレベル-1

            if (nestLevel === 0) {
                return i; // ネストレベルが0になったら対応する終了デリミタを発見
            }
        }
    }

    return -1; // 対応する終了デリミタが見つからない
}

/**
 * ネストレベルを考慮して対応する開始デリミタを検索（逆方向）
 */
function findMatchingStartDelimiter(
    lineText: string,
    endPos: number,
    startDelimiter: string,
    endDelimiter: string
): number {
    // 開始と終了が同じ文字の場合（" や ' など）は従来の方式
    if (startDelimiter === endDelimiter) {
        return lineText.lastIndexOf(startDelimiter, endPos - 1);
    }

    // 異なる文字の場合はネストレベルを考慮（逆方向）
    let nestLevel = 1; // 終了デリミタを見つけた状態から開始

    for (let i = endPos - 1; i >= 0; i--) {
        const char = lineText[i];

        if (char === endDelimiter) {
            nestLevel++; // 同じ終了デリミタが出現したらネストレベル+1
        } else if (char === startDelimiter) {
            nestLevel--; // 開始デリミタが出現したらネストレベル-1

            if (nestLevel === 0) {
                return i; // ネストレベルが0になったら対応する開始デリミタを発見
            }
        }
    }

    return -1; // 対応する開始デリミタが見つからない
}

/**
 * 指定範囲を選択し、copyToClipboard=true の場合はコピーも行う
 */
async function applyResult(
    editor: vscode.TextEditor,
    line: number,
    startChar: number,
    endChar: number,
    copyToClipboard: boolean
) {
    const startPos = new vscode.Position(line, startChar);
    const endPos = new vscode.Position(line, endChar);
    editor.selection = new vscode.Selection(startPos, endPos);
    if (copyToClipboard) {
        await vscode.commands.executeCommand('editor.action.clipboardCopyAction');
    }
}

/**
 * 行全体をクリップボードにコピー
 */
async function copyEntireLine(editor: vscode.TextEditor, lineNumber: number) {
    const line = editor.document.lineAt(lineNumber);
    editor.selection = new vscode.Selection(line.range.start, line.range.end);
    await vscode.commands.executeCommand('editor.action.clipboardCopyAction');
    vscode.window.showInformationMessage('デリミタが見つからないため、行全体をコピーしました');
}

/**
 * 行全体を選択するだけ（コピーしない）
 */
function selectEntireLine(editor: vscode.TextEditor, lineNumber: number) {
    const line = editor.document.lineAt(lineNumber);
    editor.selection = new vscode.Selection(line.range.start, line.range.end);
    vscode.window.showInformationMessage('デリミタが見つからないため、行全体を選択しました');
}

コードのポイント解説

1. デリミタペアの定義

const DELIMITER_PAIRS: Array<{ start: string; end: string }> = [
    { start: '"', end: '"' },
    { start: "'", end: "'" },
    { start: '`', end: '`' }, // バッククォート（テンプレートリテラル・Markdownインラインコード）
    { start: '「', end: '」' },
    // ... 18種類
];

開始文字と終了文字のペアを配列で管理。拡張が容易な設計です。

2. コピーと選択の共通化

// コピーする場合（Ctrl+Alt+D）
export async function copyTextBetweenDelimiters() {
    await processTextBetweenDelimiters(true);
}

// 選択のみの場合（Ctrl+Alt+S）
export async function selectTextBetweenDelimiters() {
    await processTextBetweenDelimiters(false);
}

// 共通処理（copyToClipboard で動作を分岐）
async function processTextBetweenDelimiters(copyToClipboard: boolean) {
    // ...
    await applyResult(editor, line, start, end, copyToClipboard);
}

copyToClipboardフラグ1つで2つのコマンドを共通化。検索ロジックの重複をなくし、保守性を高めています。

3. 選択方向の判定

// カーソルが選択文字の右側（左→右選択）
if (selection.active.character > selection.anchor.character) {
    // 右方向処理
}
// カーソルが選択文字の左側（右→左選択）
else if (selection.active.character < selection.anchor.character) {
    // 左方向処理
}

VSCodeのselection.active（カーソル位置）とselection.anchor（選択開始位置）を比較して選択方向を判定。

4. 最も近いデリミタの優先

// より近い開始デリミタを優先
if (!bestMatch || startPos > bestMatch.startPos) {
    bestMatch = {
        start: startPos + 1,
        end: endPos,
        startPos: startPos
    };
}

複数のデリミタペアが見つかった場合、カーソルに最も近い開始デリミタを優先します。

5. デリミタの除外

// デリミタを除外: 開始の次の文字から終了の前まで
return { start: charPos + 1, end: endPos };

開始デリミタの次の文字から終了デリミタの前までを選択範囲とすることで、デリミタ自体を除外します。

6. パフォーマンス最適化

// 行内のみの線形検索
for (let i = cursorPos - 1; i >= 0; i--) {
    if (lineText[i] === pair.start) {
        startPos = i;
        break;
    }
}

行内のみを検索対象とすることで、長大なファイルでもパフォーマンスに影響しません。

7. ネストレベル考慮のアルゴリズム

function findMatchingEndDelimiter(lineText: string, startPos: number, startDelimiter: string, endDelimiter: string): number {
    // 開始と終了が同じ文字（" や ' など）は従来の方式
    if (startDelimiter === endDelimiter) {
        return lineText.indexOf(endDelimiter, startPos + 1);
    }

    // 異なる文字の場合はネストレベルを考慮
    let nestLevel = 1; // 開始デリミタを見つけた状態から開始

    for (let i = startPos + 1; i < lineText.length; i++) {
        const char = lineText[i];

        if (char === startDelimiter) {
            nestLevel++; // 同じ開始デリミタが出現 → ネスト +1
        } else if (char === endDelimiter) {
            nestLevel--; // 終了デリミタが出現 → ネスト -1

            if (nestLevel === 0) {
                return i; // ネストレベルが0 → 対応する括弧を発見
            }
        }
    }

    return -1; // 対応する終了デリミタが見つからない
}

ポイント：

• nestLevel = 1 から開始（開始デリミタを見つけた状態）
• 同じ開始デリミタが出現するたびに nestLevel++（ネストが深くなる）
• 終了デリミタが出現するたびに nestLevel--（ネストから抜ける）
• nestLevel === 0 になった位置が対応する終了デリミタ

具体例：

function(a, (b, c), d)
        ↑開始

1. function( → nestLevel = 1
2. (b → nestLevel = 2（ネストが深くなる）
3. c) → nestLevel = 1（ネストから抜ける）
4. d) → nestLevel = 0 ✅ ここが対応する閉じ括弧

これにより、複雑な入れ子構造でも正確にペアを検出できます。

package.jsonの設定

拡張機能のコマンドとキーバインディングを登録します。

{
  "contributes": {
    "commands": [
      {
        "command": "myMacros.copyTextBetweenDelimiters",
        "title": "Copy Text Between Delimiters",
        "category": "My Macros"
      },
      {
        "command": "myMacros.selectTextBetweenDelimiters",
        "title": "Select Text Between Delimiters",
        "category": "My Macros"
      }
    ],
    "keybindings": [
      {
        "command": "myMacros.copyTextBetweenDelimiters",
        "key": "ctrl+alt+d",
        "when": "editorTextFocus"
      },
      {
        "command": "myMacros.selectTextBetweenDelimiters",
        "key": "ctrl+alt+s",
        "when": "editorTextFocus"
      }
    ]
  }
}

extension.tsでの登録

import { copyTextBetweenDelimiters, selectTextBetweenDelimiters } from './macros/copyTextBetweenDelimiters';

export function activate(context: vscode.ExtensionContext) {
    const commands = [
        vscode.commands.registerCommand(
            'myMacros.copyTextBetweenDelimiters',
            copyTextBetweenDelimiters
        ),
        vscode.commands.registerCommand(
            'myMacros.selectTextBetweenDelimiters',
            selectTextBetweenDelimiters
        ),
        // ... 他のコマンド
    ];

    commands.forEach(command => context.subscriptions.push(command));
}

使い方

基本的な使い方

ステップ1：カーソルを配置

デリミタで囲まれたテキスト内にカーソルを配置します。

const message = "ここにカーソル";
                 ↑

ステップ2：マクロ実行

• Ctrl+Alt+D → 選択してクリップボードにコピー
• Ctrl+Alt+S → 選択のみ（クリップボードは変更しない）

ステップ3：完了

デリミタ内のテキストが選択（または選択＋コピー）されます。

コピー&貼り付け置換の使い方

Ctrl+Alt+DとCtrl+Alt+Sを組み合わせると、クリップボードを保持したまま置換できます。

const src = "コピー元のテキスト";
const dst = "ここに上書きしたい";

1. "コピー元のテキスト" 内にカーソル → Ctrl+Alt+D でコピー
2. "ここに上書きしたい" 内にカーソルを移動
3. Ctrl+Alt+S で選択（クリップボードは変わらない）
4. Ctrl+V で貼り付け → 置換完了！

方向別の使い方

右方向検索

開始デリミタを1文字選択（左→右）してからCtrl+Alt+D

＜"あいうえお"＞
   ↑選択 ↑カーソル

→ 右に"を検索してあいうえおを選択

左方向検索

終了デリミタを1文字選択（右→左）してからCtrl+Alt+D

＜"あいうえお"＞
   ↑カーソル ↑選択

→ 左に"を検索してあいうえおを選択

トラブルシューティング

Q: デリミタが認識されない

A: 対応デリミタを確認してください

現在対応しているのは18種類のデリミタです。バッククォート（`）も対応済みです。対応していないデリミタはDELIMITER_PAIRS配列に追加すれば簡単に拡張できます。

Q: 入れ子構造で意図しない範囲が選択される

A: ネストレベルを考慮して正確にマッチングします

改修後のバージョンでは、括弧のネストレベルを考慮して対応する括弧を検出します。

function(a, (b, c), d)
        ↑ここにカーソル

この場合：

• カーソルの左で最も近い(（functionの後）を検出
• ネストレベルをカウントしながら対応する)を検索
• 内側の(b, c)のネストを考慮して、最外側の)を正確に検出

ただし、異なる種類のデリミタの場合は最も近いものが優先されます：

＜"「あいうえお」、【かきくけこ】"＞
     ↑ここにカーソル

この場合、「～」が選択されます（最も近いため）。外側の"～"を選択したい場合は、"と「の間にカーソルを配置してください。

Q: 行全体がコピーされてしまう

A: デリミタが見つからない場合のフォールバック動作です

• カーソル位置の左に開始デリミタがない
• 対応する終了デリミタが右に見つからない
• カーソル位置がデリミタの外側

これらの場合、安全のため行全体をコピーします。

Q: 動作が遅い

A: 行内のみの検索なのでパフォーマンス問題はありません

1行あたりの検索は線形時間（O(n)）で、通常の行（数百文字）なら瞬時に完了します。

パフォーマンスについて

計算量

• 時間計算量: O(n × m)

  • n: 行の文字数
  • m: デリミタペアの数（18個）
  • 通常の行（100文字）なら約1800回の比較

• 空間計算量: O(1)

  • 固定サイズのデータ構造のみ使用

ベンチマーク（参考値）

• 100文字の行: < 1ms
• 1000文字の行: < 5ms
• 10000文字の行: < 50ms

実用上、全く問題ないレベルです。

拡張アイデア

カスタムデリミタの設定

VSCodeの設定ファイル（settings.json）から読み込むようにすれば、ユーザー独自のデリミタにも対応可能です。

{
  "myMacros.customDelimiters": [
    { "start": "/*", "end": "*/" },
    { "start": "<!--", "end": "-->" }
  ]
}

複数行対応

現在は行内のみですが、開始・終了デリミタが別の行にある場合も対応できます（ただし、パフォーマンスへの配慮が必要）。

まとめ：キーボード1回でデリミタ内を抜き出す快適さ

VSCodeの標準機能では手が届かなかった「デリミタ間のテキスト選択」を、TypeScriptマクロで実現しました。

このマクロの強み：

• 1キー操作で完結（Ctrl+Alt+D コピー / Ctrl+Alt+S 選択のみ）
• 18種類のデリミタに対応（バッククォートも含む）
• 選択方向で動作を切り替え可能
• 入れ子構造でも正確に動作（ネストレベル考慮）
• パフォーマンス問題なし
• デリミタが見つからない場合も安全（行全体をフォールバック）

こんな人におすすめ：

• コードレビューでログやJSONを頻繁に扱う
• 文字列リテラルのコピペが多い
• マウス操作を減らしたい
• キーボードだけで完結させたい

標準のVSCodeでは「Ctrl+Shift+→」を何度も押す必要があった操作が、たった1回のキー操作で完了します。

「需要はないかもしれない」と思っていましたが、一度使うと手放せない便利機能です。特に大量のテキストを扱う作業では、作業効率が劇的に向上します。

ぜひVSCodeでの快適なテキスト編集にお役立てください！

関連記事

• VSCodeで「任意行までの一括選択・コピー」を実現するTypeScriptマクロ

VSCodeで「任意行までの一括選択・コピー」を実現するTypeScriptマクロ開発【サクラエディタ移行の集大成】

はじめに：テキスト編集における「範囲選択の不便さ」VSCodeで長いログファイルやドキュメントを編集していて、「この行から特定の文字列まで一気にコピーしたい」と思ったことはありませんか？通常のVSCodeでは、以下のような手順が必要です：開...

caymezon.com

2026.02.08

• VSCodeで「選択行による一括置換」を実現するTypeScriptマクロ

VSCodeで「選択行による一括置換」を実現するTypeScriptマクロ【テキスト編集が10倍速くなる】

はじめにテキスト編集で「複数の文字列を一度に置換したい」と思ったことはありませんか？例えば、こんなシーン：変数名を複数箇所で一括変更テーブル定義のデータ型を複数列で一括更新ドキュメント内の用語統一を複数ワードで一括実施VSCodeの標準機能...

caymezon.com

2026.02.08

• VSCodeで正規表現マッチを一括抽出するTypeScriptマクロ

VSCodeで「正規表現マッチ抽出」を実現するTypeScriptマクロ【ログ解析が10倍速くなる】

はじめにサーバーログやアプリケーションログを解析する時、こんな悩みありませんか？2024-02-08 10:00:00 INFO: Server started2024-02-08 10:01:00 ERROR: Connection fa...

caymezon.com

2026.02.08

• VSCodeでパスを読み取り専用で開くTypeScriptマクロ

VSCodeでカーソル下のパスを開くマクロ【Office読み取り専用・関連付けアプリ・連続起動対応】

はじめにVSCodeでコードやドキュメントを書いている時、テキスト内にパスが書かれていてそのファイルを開きたいこと、ありませんか？作業メモ.txt---設計書: C:\work\documents\設計書_v1.0.docx手順書: C:\...

caymezon.com

2026.02.06

タグ: #VSCode #TypeScript #マクロ #テキスト編集 #生産性向上 #エディタ

The post VSCodeで「デリミタ間テキスト選択コピー」を実現するTypeScriptマクロ【括弧・引用符を1キーで抜き出し】 first appeared on CayTech Lab.

はじめに

テキスト編集で「複数の文字列を一度に置換したい」と思ったことはありませんか？

例えば、こんなシーン：

• 変数名を複数箇所で一括変更
• テーブル定義のデータ型を複数列で一括更新
• ドキュメント内の用語統一を複数ワードで一括実施

VSCodeの標準機能では「1つずつ置換」が限界。複数の置換ペアを一度に処理するには、拡張機能や外部ツールが必要でした。

そこで、サクラエディタで10年以上愛用してきた「選択行一括置換マクロ」をTypeScriptで再実装しました。

この記事で分かること

• 選択行一括置換マクロの機能と使い方
• リテラル置換と正規表現置換の使い分け
• TypeScript実装の詳細コード
• 実務での活用例
• トラブルシューティング

機能の概要

できること

選択した行から置換ペアを読み取り、指定範囲を一括置換

置換指示行（選択する）:
19: aaa	111
20: bbb	222
21: ccc	333

↓ Ctrl+Alt+T で実行

置換対象範囲（21行目以降）:
22: テスト aaa です
23: bbb もあります
24: ccc も置換されます

↓ 結果

22: テスト 111 です
23: 222 もあります
24: 333 も置換されます

2つの置換モード

1. リテラル置換（Ctrl+Alt+T）

   • 文字列をそのまま検索・置換
   • 特殊文字もそのまま扱う
   • 安全で確実

2. 正規表現置換（Ctrl+Shift+Alt+T）

   • パターンマッチングが可能
   • 後方参照・グループ化対応
   • 高度な置換に対応

終了位置の指定（改良版）

実行時にQuickPickダイアログが開き、以下の方法で終了位置を指定できます：

プリセット選択（↑↓キーで選択）

• 空行: 次の空行の1つ前まで
• EOF: ファイル末尾まで（デフォルト）
• ▲: 「▲」を含む行の1つ前まで
• ▲▲▲: 「▲▲▲」を含む行の1つ前まで
• ```: コードブロック終端の1つ前まで
• ---: 区切り線の1つ前まで

直接入力も可能

プリセットを選ばずに、そのまま文字列を入力してEnterでもOK。例えば「TODO」と入力すれば、TODOを含む行の1つ前まで置換されます。

実務での活用例

例1：SQL文のテーブル名一括変更

置換指示行：

old_users	new_users
old_posts	new_posts
old_comments	new_comments

置換対象：

SELECT * FROM old_users WHERE ...;
UPDATE old_posts SET ...;
DELETE FROM old_comments WHERE ...;

結果：

SELECT * FROM new_users WHERE ...;
UPDATE new_posts SET ...;
DELETE FROM new_comments WHERE ...;

例2：Markdown用語統一

置換指示行：

サーバー	サーバ
データベース	DB
ブラウザー	ブラウザ

1行に1つずつ置換ペアを定義するだけで、ドキュメント全体を一括修正！

例3：変数名リファクタリング（正規表現）

置換指示行：

user_(\w+)	customer_$1
old_(\w+)_id	new_$1_id

置換対象：

const user_name = "John";
const user_age = 30;
const old_order_id = 123;

結果：

const customer_name = "John";
const customer_age = 30;
const new_order_id = 123;

正規表現の後方参照も完全対応！

例4：設定ファイルの値一括変更

置換指示行：

localhost	production.example.com
:8080	:443
http://	https://

開発環境から本番環境への設定変更が一瞬で完了。

例5：HTMLタグの一括変更

置換指示行：

<div	<section
</div>	</section>
<span	<strong
</span>	</strong>

セマンティックHTMLへのリファクタリングが簡単に。

サクラエディタからの移植経緯

サクラエディタ時代の実績

この機能、実は10年以上前からサクラエディタで愛用していた自作マクロです。

元記事：【サクラエディタ】１ファイル内一括置換マクロ【画像サンプルあり】

当時の課題：

• VSCodeとサクラエディタを行き来するのが面倒
• Git統合やリモート開発ではVSCodeが必須
• でも一括置換はサクラエディタでないとできない

VSCode移植の決断

VSCodeで開発する機会が増えたため、「どうせなら全部VSCodeで完結させたい」と思い、TypeScriptで再実装を決意。

移植のメリット：

• エディタ統一による効率化
• TypeScriptの型安全性
• Git管理による履歴保持
• 正規表現モードの追加
• QuickPickによる柔軟な入力

TypeScript実装の詳細

終了位置選択の実装（重要な改良点）

従来のshowInputBoxからcreateQuickPickに変更したことで、プリセット選択と直接入力の両方に対応しました。

/**
 * プリセット検索パターン
 */
const PRESET_PATTERNS = [
    { label: '空行', value: 'EMPTY_LINE', description: '次の空行まで' },
    { label: 'EOF', value: 'EOF', description: 'ファイル末尾まで' },
    { label: '▲', value: '▲', description: '▲が含まれる行の前まで' },
    { label: '▲▲▲', value: '▲▲▲', description: '▲▲▲が含まれる行の前まで' },
    { label: '```', value: '```', description: 'コードブロック終端の前まで' },
    { label: '---', value: '---', description: '区切り線の前まで' }
];

/**
 * 終了位置の選択ダイアログ（直接入力も可能）
 */
async function promptForEndLine(
    document: vscode.TextDocument,
    startLine: number
): Promise {
    const quickPick = vscode.window.createQuickPick();
    quickPick.items = PRESET_PATTERNS;
    quickPick.placeholder = '終了位置を選択または直接入力してください';
    quickPick.ignoreFocusOut = true;
    
    return new Promise((resolve) => {
        quickPick.onDidAccept(async () => {
            const selected = quickPick.selectedItems[0];
            const inputValue = quickPick.value.trim();
            
            let pattern: string | null = null;
            
            // 選択肢を選んだ場合
            if (selected) {
                const presetPattern = PRESET_PATTERNS.find(p => p.label === selected.label);
                pattern = presetPattern?.value || null;
            }
            // 直接入力した場合
            else if (inputValue) {
                pattern = inputValue;
            }
            
            quickPick.hide();
            
            if (!pattern) {
                resolve(null);
                return;
            }
            
            // 終了行を検索
            const endLine = await findEndLine(document, startLine, pattern);
            resolve(endLine);
        });
        
        quickPick.onDidHide(() => {
            resolve(null);
            quickPick.dispose();
        });
        
        quickPick.show();
    });
}

/**
 * 終了行を検索
 */
async function findEndLine(
    document: vscode.TextDocument,
    startLine: number,
    pattern: string
): Promise {
    const lastLine = document.lineCount - 1;
    
    // EOFの場合
    if (pattern === 'EOF') {
        return lastLine + 1; // 最終行の次（全体を対象）
    }
    
    // 空行の場合
    if (pattern === 'EMPTY_LINE') {
        for (let i = startLine + 1; i <= lastLine; i++) {
            const line = document.lineAt(i);
            if (line.isEmptyOrWhitespace) {
                return i; // 空行の番号を返す（1行前まで置換）
            }
        }
        
        // 空行が見つからない場合は最終行
        vscode.window.showInformationMessage('空行が見つからないため、ファイル末尾まで置換します');
        return lastLine + 1;
    }
    
    // 文字列検索（該当行の1行前まで）
    for (let i = startLine + 1; i <= lastLine; i++) {
        const lineText = document.lineAt(i).text;
        if (lineText.includes(pattern)) {
            return i; // 該当行の番号を返す（1行前まで置換）
        }
    }
    
    // 見つからない場合はEOF
    vscode.window.showInformationMessage(
        `「${pattern}」が見つからないため、ファイル末尾まで置換します`
    );
    return lastLine + 1;
}

その他の主要コード

置換ペアの抽出や実際の置換処理は従来通りです：

/**
 * 選択範囲から「置換前\t置換後」ペアを抽出
 */
function collectReplacePairs(
    document: vscode.TextDocument,
    startLine: number,
    endLine: number
): Array<[string, string]> {
    const pairs: Array<[string, string]> = [];

    for (let i = startLine; i <= endLine; i++) {
        const lineText = document.lineAt(i).text;
        const tabIndex = lineText.indexOf('\t');

        if (tabIndex < 0) {
            continue; // タブがない行は無視
        }

        const before = lineText.substring(0, tabIndex);
        const after = lineText.substring(tabIndex + 1);

        if (!before) {
            continue; // 置換前が空の行は無視
        }

        pairs.push([before, after]);
    }

    return pairs;
}

/**
 * 実際に置換を適用（修正版：行ごとに全ペアを適用）
 */
async function applyReplacements(
    editor: vscode.TextEditor,
    pairs: Array<[string, string]>,
    startLine: number,
    endLine: number,
    mode: ReplaceMode
) {
    const document = editor.document;
    const lastLine = document.lineCount - 1;
    const actualEndLine = Math.min(endLine - 1, lastLine);

    await editor.edit(editBuilder => {
        // 行ごとにループ（オーバーラップを防ぐため）
        for (let lineNum = startLine; lineNum <= actualEndLine; lineNum++) {
            const line = document.lineAt(lineNum);
            let lineText = line.text;
            const originalText = lineText;

            // 全ペアを順番に適用
            for (const [before, after] of pairs) {
                if (!before || before === after) {
                    continue; // 空文字列や同じ文字列はスキップ
                }

                if (mode === ReplaceMode.Literal) {
                    // リテラル置換
                    lineText = lineText.split(before).join(after);
                } else {
                    // 正規表現置換
                    try {
                        const regex = new RegExp(before, 'g');
                        lineText = lineText.replace(regex, after);
                    } catch (e) {
                        // 正規表現エラーの場合はスキップ
                        console.error(`正規表現エラー: ${before}`, e);
                    }
                }
            }

            // 変更があった場合のみ置換（1行につき1回のreplaceでオーバーラップを回避）
            if (lineText !== originalText) {
                const range = new vscode.Range(
                    new vscode.Position(lineNum, 0),
                    new vscode.Position(lineNum, originalText.length)
                );
                editBuilder.replace(range, lineText);
            }
        }
    });
}

コードのポイント

1. QuickPickによる柔軟な入力

const quickPick = vscode.window.createQuickPick();
quickPick.items = PRESET_PATTERNS;
// プリセット選択 or 直接入力が可能

2. プリセットと直接入力の両対応

if (selected) {
    // プリセット選択
    pattern = presetPattern?.value || null;
} else if (inputValue) {
    // 直接入力
    pattern = inputValue;
}

3. タブ区切りのパース

const tabIndex = lineText.indexOf('\t');
const before = lineText.substring(0, tabIndex);
const after = lineText.substring(tabIndex + 1);

「置換前[Tab]置換後」形式を確実に解析。

4. オーバーラップエラーの回避（重要）

// 行ごとにループ（オーバーラップを防ぐため）
for (let lineNum = startLine; lineNum <= actualEndLine; lineNum++) {
    let lineText = line.text;
    
    // 全ペアを順番に適用
    for (const [before, after] of pairs) {
        lineText = lineText.split(before).join(after);
    }
    
    // 変更があった場合のみ1回だけreplace
    if (lineText !== originalText) {
        editBuilder.replace(range, lineText);
    }
}

同じ行に複数の置換対象がある場合でも、行ごとに全ペアを適用してから1回だけreplaceすることでオーバーラップエラーを回避。

package.jsonの設定

{
  "contributes": {
    "commands": [
      {
        "command": "myMacros.replaceBySelectionLiteral",
        "title": "Replace by Selection (Literal)",
        "category": "My Macros"
      },
      {
        "command": "myMacros.replaceBySelectionRegex",
        "title": "Replace by Selection (Regex)",
        "category": "My Macros"
      }
    ],
    "keybindings": [
      {
        "command": "myMacros.replaceBySelectionLiteral",
        "key": "ctrl+alt+t",
        "when": "editorTextFocus"
      },
      {
        "command": "myMacros.replaceBySelectionRegex",
        "key": "ctrl+shift+alt+t",
        "when": "editorTextFocus"
      }
    ]
  }
}

使い方

基本的な使い方

ステップ1：置換ペアを記述

old_name	new_name
old_value	new_value
old_key	new_key

ステップ2：選択する

置換ペアの行を選択（Shift+↓で複数行選択）

ステップ3：実行

• リテラル置換：Ctrl+Alt+T
• 正規表現置換：Ctrl+Shift+Alt+T

ステップ4：終了位置を指定

QuickPickダイアログが開きます：

• ↑↓でプリセットを選択してEnter
• または直接文字列を入力してEnter

ステップ5：確認

置換内容を確認して「はい」をクリック

応用テクニック

範囲を限定する：

置換指示行（選択）
↓
置換対象範囲
↓
--- （ここで終了）
↓
置換しない範囲

終了位置に「---」を選択またはダイアログで入力すれば、区切り線までのみ置換。

正規表現の後方参照：

(\w+)_old	$1_new
old_(\d+)	new_$1

キャプチャグループを活用した高度な置換が可能。

トラブルシューティング

Q: 「置換指示行を選択してください」と表示される

A: 置換ペアの行を選択していません

• 置換ペアを記述した行を選択してから実行してください
• 選択範囲が空の場合はこのエラーが出ます

Q: 「タブ区切りの置換指定行がありません」と表示される

A: タブ文字が入っていません

• 「置換前[Tab]置換後」の形式で記述してください
• スペースではなく、タブ文字（\t）を使ってください

Q: 正規表現が動かない

A: 正規表現モードで実行していますか？

• リテラル：Ctrl+Alt+T
• 正規表現：Ctrl+Shift+Alt+T
• モードを確認してください

Q: 一部の置換がスキップされる

A: 正規表現エラーの可能性

• コンソールログ（Ctrl+Shift+U → Extension Host）を確認
• 正規表現の構文を見直してください

Q: 「Overlapping ranges are not allowed!」エラーが出る

A: 修正済みです

• 最新版では、同じ行に複数の置換対象がある場合でも正常に動作します
• git pullして最新版を取得してください

他のマクロとの組み合わせ

選択範囲コピーマクロとの連携

1. 置換ペアをテンプレート化
2. 空行までコピーマクロで複製
3. 値だけ書き換えて実行

Git連携

# 置換前
git diff

# 置換実行
Ctrl+Alt+T

# 結果確認
git diff

# 問題なければコミット
git commit -am "Refactor: update variable names"

まとめ

VSCodeで複数の文字列を一括置換する機能、実装してみました。

このマクロの強み：

• シンプルな操作（選択して実行）
• タブ区切りの直感的な書式
• リテラルと正規表現の両対応
• QuickPickによる柔軟な終了位置指定
• プリセット選択と直接入力の両対応
• 確認ダイアログで安全
• オーバーラップエラーを回避

こんな人におすすめ：

• テキスト編集の効率化したい
• リファクタリングが多い
• ドキュメント整備をよくする
• サクラエディタから移行したい

サクラエディタで10年以上愛用してきた機能が、TypeScriptで現代的に蘇りました。

ぜひVSCodeでの快適なテキスト編集にお役立てください！

関連記事

• サクラエディタからの移行経緯

サクラエディタからVSCodeへマクロ移行！快適開発環境の構築記録

はじめに長年愛用してきたサクラエディタのマクロ機能。便利なJavaScript/VBSマクロを多数作成して日常業務で活用してきましたが、最近のAWS開発やブログ執筆でVSCodeを使う機会が増えてきました。「VSCodeでもサクラエディタの...

caymezon.com

2026.01.25

• TypeScriptマクロ開発環境の構築方法

VSCode TypeScriptマクロ開発環境の完全ガイド【セットアップから運用まで】

はじめにVSCodeでカスタムマクロを作成したいけど、どうやって開発環境を構築すればいいか分からない。そんな悩みを持つ方に向けて、TypeScriptでVSCode拡張機能を開発する環境の構築から、実際にマクロを作成して使えるようにするまで...

caymezon.com

2026.01.25

• 空行までの一括選択・コピーマクロ

VSCodeで「任意行までの一括選択・コピー」を実現するTypeScriptマクロ開発【サクラエディタ移行の集大成】

はじめに：テキスト編集における「範囲選択の不便さ」VSCodeで長いログファイルやドキュメントを編集していて、「この行から特定の文字列まで一気にコピーしたい」と思ったことはありませんか？通常のVSCodeでは、以下のような手順が必要です：開...

caymezon.com

2026.02.08

タグ: #VSCode #TypeScript #マクロ #テキスト編集 #正規表現 #生産性向上 #サクラエディタ

The post VSCodeで「選択行による一括置換」を実現するTypeScriptマクロ【テキスト編集が10倍速くなる】 first appeared on CayTech Lab.