【JavaScript】文字列内から特定の文字列の1つ前の1文字を抽出する方法（indexOf・正規表現・split）

const str = "abcdefg";
const search = "d";

// 検索文字列の位置を取得
const index = str.indexOf(search);

// 1つ前の文字を取得（位置が1以上であることを確認）
if (index > 0) {
  const prevChar = str[index - 1];
  console.log(prevChar); // "c"
}

実行結果

c

indexOf() のポイント

• indexOf() は検索文字列が見つかった最初の位置（0始まり）を返す
• 見つからない場合は -1 を返す
• index > 0 のチェックにより、先頭文字の場合（前に文字がない）も安全に処理できる
• str[index - 1] はブラケット記法で1文字を取得する（charAt() でも可）

/**
 * 指定した検索文字列の直前の1文字を返す
 * @param {string} str - 対象文字列
 * @param {string} search - 検索文字列
 * @returns {string|null} 直前の1文字（見つからない場合は null）
 */
function getCharBefore(str, search) {
  const index = str.indexOf(search);
  if (index <= 0) return null;
  return str[index - 1];
}

// 使用例
console.log(getCharBefore("Hello World", "World"));  // " "（スペース）
console.log(getCharBefore("data-value", "value"));  // "-"
console.log(getCharBefore("abcdef", "a"));       // null（先頭のため）
console.log(getCharBefore("abcdef", "z"));       // null（見つからない）

実行結果

 
-
null
null

const url = "https://example.com?page=1&sort=name";

// "sort" の直前の1文字を取得
const idx = url.indexOf("sort");
if (idx > 0) {
  console.log(url[idx - 1]); // "&"
}

実行結果

&

const str = "JavaScript";
const search = "Script";

const index = str.indexOf(search);

if (index > 0) {
  // charAt() で1つ前の文字を取得
  const prevChar = str.charAt(index - 1);
  console.log(prevChar); // "a"
}

実行結果

a

ポイント：モダンなJavaScript開発では str[index] のブラケット記法が一般的です。ただし、範囲外アクセス時の挙動が異なるため、エラーハンドリングの方法に注意してください。

const str = "abcdefg";
const search = "d";

// 任意の1文字(.)をキャプチャし、その直後に search が続くパターン
const regex = new RegExp(`(.)${search}`);
const match = str.match(regex);

if (match) {
  console.log(match[1]); // "c"（キャプチャグループ1）
}

実行結果

c

正規表現パターンの解説

• (.) – 任意の1文字をキャプチャグループで取得
• d（search変数）- 直後に続く検索文字列
• match[0] – マッチ全体（"cd"）
• match[1] – キャプチャグループ1（"c" = 直前の1文字）

const str = "price:100,tax:10,total:110";

// ":" の直前の1文字を先読みで取得（最初のマッチ）
const match = str.match(/(.(?=:))/);

if (match) {
  console.log(match[1]); // "e"（price の最後の文字）
}

実行結果

e

const str = "price:100";

// ":" の直後の1文字を後読みで取得
const match = str.match(/(?<=:)(.)/);

if (match) {
  console.log(match[1]); // "1"（":" の直後）
}

実行結果

1

注意：後読み（Lookbehind）は ES2018（ES9）で追加された機能です。IE11では対応していません。モダンブラウザ（Chrome 62+、Firefox 78+、Safari 16.4+）では問題なく使用できます。

/**
 * 正規表現の特殊文字をエスケープする
 */
function escapeRegex(str) {
  return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
}

// "(" を含む検索文字列
const str = "func(arg)";
const search = "(arg)";

const escaped = escapeRegex(search);
const regex = new RegExp(`(.)${escaped}`);
const match = str.match(regex);

if (match) {
  console.log(match[1]); // "c"（"func" の最後の文字）
}

実行結果

c

注意：ユーザー入力を正規表現に組み込む場合は、必ずエスケープ処理を行ってください。エスケープしないと、意図しないパターンマッチや正規表現エラー（SyntaxError）が発生する原因になります。

const str = "user-name-value";
const search = "name";

// search で分割し、最初の要素の末尾1文字を取得
const parts = str.split(search);

if (parts[0].length > 0) {
  const prevChar = parts[0].slice(-1);
  console.log(prevChar); // "-"
}

実行結果

-

split() の仕組み

• "user-name-value".split("name") → ["user-", "-value"]
• 最初の要素 "user-" の末尾1文字 → "-"
• slice(-1) は文字列の末尾1文字を返す便利なメソッド

const str = "aXbXcXd";
const search = "X";

const parts = str.split(search);

// 最初の要素以外の各要素について、前の要素の末尾1文字が「直前の文字」
const prevChars = parts
  .slice(0, -1)  // 最後の要素を除外
  .map(part => part.slice(-1))
  .filter(ch => ch.length > 0); // 先頭にsearchがある場合を除外

console.log(prevChars); // ["a", "b", "c"]

実行結果

["a", "b", "c"]

const str = "img_001.thumb.jpg";
const search = ".";

// 最後のドット（.）の直前1文字を取得
const lastIdx = str.lastIndexOf(search);

if (lastIdx > 0) {
  const prevChar = str[lastIdx - 1];
  console.log(prevChar); // "b"（.jpg の前 → thumb の "b"）
}

実行結果

b

function getCharBeforeExtension(filename) {
  const dotIndex = filename.lastIndexOf(".");
  if (dotIndex <= 0) return null;
  return filename[dotIndex - 1];
}

console.log(getCharBeforeExtension("report.pdf"));       // "t"
console.log(getCharBeforeExtension("archive.tar.gz"));   // "r"（.gz の前）
console.log(getCharBeforeExtension(".gitignore"));      // null（ドットが先頭）
console.log(getCharBeforeExtension("noextension"));     // null（ドットなし）

実行結果

t
r
null
null

function getAllCharsBefore(str, search) {
  const results = [];
  let pos = 0;

  while (true) {
    const index = str.indexOf(search, pos);
    if (index === -1) break;

    if (index > 0) {
      results.push({
        char: str[index - 1],
        position: index - 1,
        matchAt: index
      });
    }
    pos = index + search.length;
  }

  return results;
}

const str = "the cat sat on the mat";
const results = getAllCharsBefore(str, "at");

results.forEach(r => {
  console.log(`位置${r.matchAt}: 直前の文字 = "${r.char}"`);
});

実行結果

位置5: 直前の文字 = "c"
位置9: 直前の文字 = "s"
位置20: 直前の文字 = "m"

const str = "the cat sat on the mat";

// matchAll() で全マッチのイテレータを取得
const matches = [...str.matchAll(/(.)at/g)];

matches.forEach(m => {
  console.log(`マッチ: "${m[0]}" → 直前の文字: "${m[1]}"`);
});

実行結果

マッチ: "cat" → 直前の文字: "c"
マッチ: "sat" → 直前の文字: "s"
マッチ: "mat" → 直前の文字: "m"

ポイント：matchAll() は ES2020 で追加されたメソッドです。g フラグ付きの正規表現で全マッチの詳細情報（キャプチャグループ含む）を取得できます。

/**
 * 検索文字列の直前N文字を取得する
 * @param {string} str - 対象文字列
 * @param {string} search - 検索文字列
 * @param {number} n - 取得する文字数（デフォルト: 1）
 * @returns {string|null}
 */
function getCharsBefore(str, search, n = 1) {
  const index = str.indexOf(search);
  if (index <= 0) return null;

  // 取得開始位置（0未満にならないよう制限）
  const start = Math.max(0, index - n);
  return str.slice(start, index);
}

console.log(getCharsBefore("Hello World", "World", 1));  // " "
console.log(getCharsBefore("Hello World", "World", 3));  // "lo "
console.log(getCharsBefore("Hello World", "World", 10)); // "Hello "（最大6文字まで）

実行結果

 
lo 
Hello 

/**
 * 文字列操作ユーティリティ
 */
const StringUtils = {

  /** 最初の出現箇所の直前1文字を取得 */
  getCharBefore(str, search) {
    const idx = str.indexOf(search);
    return idx > 0 ? str[idx - 1] : null;
  },

  /** 最後の出現箇所の直前1文字を取得 */
  getCharBeforeLast(str, search) {
    const idx = str.lastIndexOf(search);
    return idx > 0 ? str[idx - 1] : null;
  },

  /** 全出現箇所の直前1文字を配列で取得 */
  getAllCharsBefore(str, search) {
    const results = [];
    let pos = 0;
    while (true) {
      const idx = str.indexOf(search, pos);
      if (idx === -1) break;
      if (idx > 0) results.push(str[idx - 1]);
      pos = idx + search.length;
    }
    return results;
  },

  /** N番目の出現箇所の直前1文字を取得 */
  getCharBeforeNth(str, search, n = 1) {
    let pos = 0;
    let count = 0;
    while (true) {
      const idx = str.indexOf(search, pos);
      if (idx === -1) return null;
      count++;
      if (count === n) {
        return idx > 0 ? str[idx - 1] : null;
      }
      pos = idx + search.length;
    }
  }
};

// 使用例
const csv = "name,age,city,country";
console.log(StringUtils.getCharBefore(csv, ","));          // "e"
console.log(StringUtils.getCharBeforeLast(csv, ","));      // "y"
console.log(StringUtils.getAllCharsBefore(csv, ","));      // ["e", "e", "y"]
console.log(StringUtils.getCharBeforeNth(csv, ",", 2));   // "e"（2番目のカンマの前）

実行結果

e
y
["e", "e", "y"]
e

/**
 * URLにクエリパラメータを安全に追加する
 * ?がすでにあれば&で、なければ?で追加
 */
function addQueryParam(url, key, value) {
  const separator = url.includes("?") ? "&" : "?";
  return `${url}${separator}${key}=${encodeURIComponent(value)}`;
}

/**
 * 特定パラメータの直前の区切り文字を確認する実例
 */
function getParamSeparator(url, paramName) {
  const idx = url.indexOf(paramName);
  if (idx <= 0) return null;
  const prevChar = url[idx - 1];
  return prevChar; // "?" or "&"
}

const url1 = "https://example.com?page=1&sort=name";
console.log(getParamSeparator(url1, "page")); // "?"
console.log(getParamSeparator(url1, "sort")); // "&"

実行結果

?
&

/**
 * CSVの各フィールドの直前の文字を分析し、
 * クォートで囲まれたフィールドかどうかを判定
 */
function analyzeCSVField(csvLine, fieldValue) {
  const idx = csvLine.indexOf(fieldValue);
  if (idx <= 0) return { found: false };

  const prevChar = csvLine[idx - 1];
  return {
    found: true,
    isQuoted: prevChar === '\"',
    isFirstField: idx === 0,
    prevChar: prevChar
  };
}

const line = 'name,"Tokyo, Japan",25';
console.log(analyzeCSVField(line, "Tokyo"));

実行結果

{ found: true, isQuoted: true, isFirstField: false, prevChar: '"' }

/**
 * ログ行からエラーレベルタグの直前文字を取得し、
 * ログフォーマットの種類を判定する
 */
function detectLogFormat(logLine) {
  const levels = ["ERROR", "WARN", "INFO", "DEBUG"];

  for (const level of levels) {
    const idx = logLine.indexOf(level);
    if (idx > 0) {
      const prev = logLine[idx - 1];
      if (prev === "[") return "bracket-format";  // [ERROR]
      if (prev === " ") return "space-separated"; // ... ERROR ...
      if (prev === "|") return "pipe-separated";  // ...|ERROR|...
    }
  }
  return "unknown";
}

console.log(detectLogFormat("2024-01-15 [ERROR] DB connection failed"));
console.log(detectLogFormat("2024-01-15 ERROR DB connection failed"));
console.log(detectLogFormat("2024-01-15|ERROR|DB connection failed"));

実行結果

bracket-format
space-separated
pipe-separated

const str = "Hello World";

// "Hello" は先頭にあるため、直前の文字は存在しない
const idx = str.indexOf("Hello"); // 0

// 危険な実装（index - 1 が -1 になる）
console.log(str[idx - 1]); // undefined

// 安全な実装
if (idx > 0) {
  console.log(str[idx - 1]);
} else {
  console.log("直前の文字は存在しません");
}

実行結果

undefined
直前の文字は存在しません

const str = "abcdef";
const idx = str.indexOf("xyz"); // -1

// 危険！ str[-2] は undefined だがエラーにはならない
console.log(str[idx - 1]); // undefined

// 必ず indexOf の結果をチェックしてから使う
if (idx !== -1 && idx > 0) {
  console.log(str[idx - 1]);
} else {
  console.log("検索文字列が見つかりません");
}

実行結果

undefined
検索文字列が見つかりません

// 空文字列で検索すると indexOf は 0 を返す
console.log("abc".indexOf("")); // 0

// 対象文字列が空の場合
console.log("".indexOf("a")); // -1

// 安全な関数は両方のケースを考慮する
function safeGetCharBefore(str, search) {
  if (!str || !search) return null;
  const idx = str.indexOf(search);
  return idx > 0 ? str[idx - 1] : null;
}

const str = "I like cats";

// 絵文字はサロゲートペア（2コードユニット）
console.log(str.length);     // 13（"I like " = 7, 絵文字 = 2, "cats" = 4）
console.log(str[7]);         // サロゲートペアの前半（文字化け）

// indexOf は正しく動作する
const idx = str.indexOf("cats"); // 9
console.log(str[idx - 1]); // サロゲートペアの後半（文字化け！）

// 対策: Array.from() で正しく文字単位に分割
const chars = Array.from(str);
const catIdx = chars.findIndex((_, i) =>
  chars.slice(i, i + 4).join("") === "cats"
);
if (catIdx > 0) {
  console.log(chars[catIdx - 1]); // 正しく絵文字全体を取得
}

注意：絵文字や特殊文字を含む文字列を扱う場合は、Array.from() や [...str]（スプレッド構文）で正しい文字単位に分割してから処理してください。str[index] や charAt() はコードユニット単位のため、サロゲートペアの半分だけを返す可能性があります。

/**
 * 大文字・小文字を区別せずに直前の1文字を取得
 */
function getCharBeforeCI(str, search) {
  // 方法1: toLowerCase() で揃える
  const idx = str.toLowerCase().indexOf(search.toLowerCase());
  return idx > 0 ? str[idx - 1] : null;
}

/**
 * 正規表現の i フラグを使う方法
 */
function getCharBeforeCIRegex(str, search) {
  const escaped = search.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
  const match = str.match(new RegExp(`(.)${escaped}`, "i"));
  return match ? match[1] : null;
}

console.log(getCharBeforeCI("Hello WORLD", "world"));     // " "
console.log(getCharBeforeCIRegex("Hello WORLD", "world")); // " "

実行結果

/**
 * 堅牢版：あらゆるエッジケースに対応した直前文字取得
 * @param {string} str - 対象文字列
 * @param {string} search - 検索文字列
 * @param {Object} options - オプション
 * @param {boolean} options.caseInsensitive - 大文字小文字を無視
 * @param {number} options.occurrence - N番目の出現（デフォルト: 1）
 * @param {boolean} options.fromEnd - 末尾から検索
 * @returns {string|null}
 */
function getCharBeforeRobust(str, search, options = {}) {
  // 入力バリデーション
  if (typeof str !== "string" || typeof search !== "string") {
    return null;
  }
  if (str.length === 0 || search.length === 0) {
    return null;
  }

  const { 
    caseInsensitive = false, 
    occurrence = 1, 
    fromEnd = false 
  } = options;

  // 末尾から検索
  if (fromEnd) {
    const s = caseInsensitive ? str.toLowerCase() : str;
    const q = caseInsensitive ? search.toLowerCase() : search;
    const idx = s.lastIndexOf(q);
    return idx > 0 ? str[idx - 1] : null;
  }

  // N番目の出現を検索
  const s = caseInsensitive ? str.toLowerCase() : str;
  const q = caseInsensitive ? search.toLowerCase() : search;
  let pos = 0;
  let count = 0;

  while (pos < s.length) {
    const idx = s.indexOf(q, pos);
    if (idx === -1) break;
    count++;
    if (count === occurrence) {
      return idx > 0 ? str[idx - 1] : null;
    }
    pos = idx + q.length;
  }

  return null;
}

// 使用例
const text = "aXbXcXd";
console.log(getCharBeforeRobust(text, "X"));                        // "a"
console.log(getCharBeforeRobust(text, "X", { occurrence: 2 }));     // "b"
console.log(getCharBeforeRobust(text, "X", { fromEnd: true }));     // "c"
console.log(getCharBeforeRobust(text, "x", { caseInsensitive: true })); // "a"

実行結果

a
b
c
a

const str = "abcdefghijklmnopqrstuvwxyz".repeat(100);
const search = "xyz";
const ITERATIONS = 100000;

// indexOf
console.time("indexOf");
for (let i = 0; i < ITERATIONS; i++) {
  const idx = str.indexOf(search);
  if (idx > 0) str[idx - 1];
}
console.timeEnd("indexOf");

// 正規表現
console.time("regex");
const regex = new RegExp(`(.)${search}`);
for (let i = 0; i < ITERATIONS; i++) {
  const m = str.match(regex);
  if (m) m[1];
}
console.timeEnd("regex");

// split
console.time("split");
for (let i = 0; i < ITERATIONS; i++) {
  const parts = str.split(search);
  if (parts[0].length > 0) parts[0].slice(-1);
}
console.timeEnd("split");

実行結果（参考値）

indexOf: 12ms
regex: 45ms
split: 380ms

パフォーマンスのポイント

• indexOf() が圧倒的に高速（文字列探索に最適化されている）
• 正規表現はパターンコンパイルのオーバーヘッドがある（ループ外でnew RegExpを1回だけ実行すると改善）
• split() は文字列全体を分割するため、長い文字列では遅くなる
• 通常の用途ではどの方法でも十分高速なので、可読性を優先して選択するのがベスト

ポイント：迷ったら indexOf() を使いましょう。最もシンプルで高速、かつ可読性も高い方法です。正規表現は複雑なパターンが必要な場合にのみ使用するのがベストプラクティスです。

function getCharAfter(str, search) {
  const idx = str.indexOf(search);
  if (idx === -1) return null;
  const afterIdx = idx + search.length;
  return afterIdx < str.length ? str[afterIdx] : null;
}

console.log(getCharAfter("Hello World", "Hello")); // " "
console.log(getCharAfter("abc", "abc"));         // null（後ろに文字がない）

実行結果

 
null

function getCharBefore(str: string, search: string): string | null {
  const index: number = str.indexOf(search);
  if (index <= 0) return null;
  return str[index - 1];
}

// 戻り値が string | null なので null チェックが必要
const result = getCharBefore("Hello", "llo");
if (result !== null) {
  console.log(result.toUpperCase()); // "E"（型安全に操作可能）
}

この記事のポイント

• 基本：indexOf() で位置を取得し、str[index - 1] で直前の1文字を取得するのが最もシンプル
• 末尾検索：最後の出現箇所が必要な場合は lastIndexOf() を使用
• 正規表現：(.) キャプチャグループや先読み (?=...) で柔軟なパターンマッチが可能
• 全マッチ：matchAll() や indexOf() のループで全出現箇所の直前文字を取得
• split()：分割結果の各要素の末尾文字 = 各出現箇所の直前文字
• エッジケース：先頭マッチ、未検出、空文字列、サロゲートペアに注意
• パフォーマンス：indexOf() が最速。通常は可読性を優先して選択

ポイント：実務では入力バリデーション（null/undefined/空文字チェック）と境界条件（先頭マッチ・未検出）の処理を必ず入れましょう。堅牢な関数を一度作っておけば、プロジェクト全体で安全に再利用できます。