譯者注：如何用不到40行的程式碼構建一個正則表示式引擎？作者在本文就將他本人的解決思路記錄了下來，如果你也想挑戰，不妨借鑑一下作者的思路，說不定你寫的程式碼可能不到30行。以下為譯文。

無意之間我發現了一篇文章，Rob Pike用C語言實現了一個正則表示式引擎的模型。於是我也嘗試用Javascript寫一個，並且增加了測試規範。測試規範和解決方案都放在了GitHub倉庫上面。本文將重點介紹解決方案。

問題描述

正則表示式引擎將支援以下語法：

最終目標是用最少的程式碼提供最強大的功能，從而滿足上述正則表示式用例。

單字元匹配

第一步是編寫一個函式，該函式有兩個入參，返回值是一個布林型別，表示匹配結果。.

簡單舉一些用例：

matchOne('a', 'a') -> true

matchOne('.', 'z') -> true

matchOne('', 'h') -> true

matchOne('a', 'b') -> false

matchOne('p', '') -> false

function matchOne(pattern, text) {
  if (!pattern) return true // Any text matches an empty pattern
  if (!text) return false   // If the pattern is defined but the text is empty, there cannot be a match
  if (pattern === ".") return true // Any inputted text matches the wildcard
  return pattern === text
}
 

相同長度的字串匹配

現在需要增加引數的長度，並且暫時只考慮pattern和string長度相同的情況。根據以前的經驗，我很自然的認為這種情況非常適合用遞迴來解決。 我們只需要反覆呼叫matchOne函式就可以了。

function match(pattern, text) {
  if (pattern === "") return true  // Our base case - if the pattern is empty, any inputted text is a match
  else return matchOne(pattern[0], text[0]) && match(pattern.slice(1), text.slice(1))
}
 

上面的程式碼首先將pattern[0]與text[0]進行比較，然後將pattern[1]與text[1]進行比較，並繼續將pattern[i]與text[i]進行比較，直到i === pattern.length - 1。如果在某個地方沒有匹配成功，那麼最終返回的結果就是匹配失敗。

我們來舉個例子。假設呼叫match（'a.c'，'abc'），實際上返回的就是matchOne（'a'，'a'）&& match（'.c'，'bc'）。

如果繼續分析下去，其實最終的結果就是matchOne（'a'，'a'）&& matchOne（'.'，'b'）&& matchOne（'c'，'c'）&& match（""，""） ，這就相當於true && true && true && true，所以返回結果就是true！

$字元

接下來增加特殊字元$的支援，它可以匹配字串後面的所有字元。要想實現該功能，只需要在上一步的match函式中增加一個額外基本情況的判斷就可以了。

function match(pattern, text) {
  if (pattern === "") return true
  if (pattern === "$" && text === "") return true
  else return matchOne(pattern[0], text[0]) && match(pattern.slice(1), text.slice(1))
}

^字元

讓我們新增對特殊模式字元^的支援，它允許匹配字串的開頭。這裡我將介紹一個新的函式–search。

function search(pattern, text) {
  if (pattern[0] === "^") {
    return match(pattern.slice(1), text)
  }
}

這個函式將成為程式碼的新入口。到目前為止只是在文字開始時才開始匹配。現在只是通過強迫使用者以^來開始。但是如何支援文字中出現的任何模式呢？

任意位置的匹配

截止到目前為止，下面的表示式將會返回true。

search("^abc", "abc")

search("^abcd", "abcd")

但是search("bc", "abcd")返回的卻是undefined。我們期望讓它返回true。

如果使用者沒有指明要從第一個字元開始就要匹配，那麼我們希望在文字內的每個可能的起始點進行搜尋。這是預設的處理規則，除非pattern是以^開始。

function search(pattern, text) {
  if (pattern[0] === "^") {
      return match(pattern.slice(1), text)
  } else {
      // This code will run match(pattern, text.slice(index)) on every index of the text.
      // This means that we test the pattern against every starting point of the text.
      return text.split("").some((_, index) => {
      return match(pattern, text.slice(index))
    })
  }
}

?字元

使用?的話，那麼在?前面的0個或者1個字元可以進行匹配。

這裡有一些範例：

search("ab?c", "ac") -> true

search("ab?c", "abc") -> true

search("a?b?c?", "abc") -> true

search("a?b?c?", "") -> true

第一步是修改match函式，當檢測到?字元出現以後就開始呼叫matchQuestion函式，matchQuestion函式的定義將會在下面的內容看到。

function match(pattern, text) {
  if (pattern === "") {
    return true
  } else if (pattern === "$" && text === "") {
    return true
  // Notice that we are looking at pattern[1] instead of pattern[0].
  // pattern[0] is the character to match 0 or 1 of.
  } else if (pattern[1] === "?") {
    return matchQuestion(pattern, text)
  } else {
    return matchOne(pattern[0], text[0]) && match(pattern.slice(1), text.slice(1))
  }
}

matchQuestion函式需要處理兩種情況：

1. ?之前的字元沒有匹配成功，但是?後面所有的文字都和pattern的剩餘部分匹配成功了；
2. ?之前的字元都匹配成功了，並且其餘的文字（這裡應該減去一個字元）也和pattern的剩餘部分匹配成功了；

上面兩種情況中只要滿足一種，那麼matchQuestion函式就會返回true。

讓我們先考慮第一種情況。如果pattern中的文字除了_?不一樣以外，其它都能匹配成功，這種情況我們怎麼去檢查呢？換句話說，如果?前面的字元只出現了0次，這種情況我們怎麼去檢查呢？我們從pattern剔除掉2個字元（第一個字元就是?前面的哪個，第二個字元就是?本身），然後再呼叫match函式。

function matchQuestion(pattern, text) {
  return match(pattern.slice(2), text);
}

第二種情況更具挑戰性，但是和上面介紹的一樣，它還是重用了之前已經寫好的函式。

function matchQuestion(pattern, text) {
  if (matchOne(pattern[0], text[0]) && match(pattern.slice(2), text.slice(1))) {
    return true;
  } else {
    return match(pattern.slice(2), text);
  }
}

如果text[0]跟pattern[0]匹配上了，而且其它的文字和pattern中剩餘的也能匹配上，那麼我們就成功了。注意，程式碼我們也可以這麼寫：

function matchQuestion(pattern, text) {
  return (matchOne(pattern[0], text[0]) && match(pattern.slice(2), text.slice(1))) || match(pattern.slice(2), text);
}

我更喜歡後面一個方法的原因是因為它明確地指出了有兩種情況，只要滿足其中一種，那麼返回的結果就是true。

*字元

我們希望能夠匹配*前面0個或多個字元。

下面這些表示式的返回結果都應該是true。

search("a*", "")

search("a*", "aaaaaaa")

search("a*b", "aaaaaaab")

這個跟?的情況很相似，我們在match函式裡面再增加一個matchStar方法。

function match(pattern, text) {
  if (pattern === "") {
    return true
  } else if (pattern === "$" && text === "") {
    return true
  } else if (pattern[1] === "?") {
    return matchQuestion(pattern, text)
  } else if (pattern[1] === "*") {
    return matchStar(pattern, text)
  } else {
    return matchOne(pattern[0], text[0]) && match(pattern.slice(1), text.slice(1))
  }
}

matchStar和matchQuestion一樣，也要處理兩種情況：

1. *前面的部分沒有匹配成功，但是其它文字和pattern中*後面的都匹配成功了；
2. *前面的部分匹配成功了，並且其它文字和pattern中*後面的也都匹配成功了；

由於這兩種情況都能決定匹配的結果，因此我們知道matchStar可以用布林型別OR來實現。此外，matchStar的情況1與matchQuestion的情況1完全相同，因此同樣也可以使用match（pattern.slice（2），text）進行實現。這意味著我們只需要制定滿足情況2的表示式。

function matchStar(pattern, text) {
  return (matchOne(pattern[0], text[0]) && match(pattern, text.slice(1))) || match(pattern.slice(2), text);
}

重構

現在我們可以回過頭來，對search函式進行簡化，而且正好可以將我從Peter Norvig寫的類裡面學到的一個技巧應用上。

function search(pattern, text) {
  if (pattern[0] === "^") {
    return match(pattern.slice(1), text)
  } else {
    return match(".*" + pattern, text)
  }
}

我們使用*字元本身來允許pattern中字串可以出現在任何地方。前面的.*表示在pattern前面出現了任何數量的任何字元，我們也希望能匹配成功。

結論

功能如此強大，但是程式碼卻如此簡潔明瞭，這真是一件很了不起的事情。完整的原始碼可以再GitHub倉庫中找到。