在 JavaScript 中,正規表達式由 RegExp 物件表示,RegExp 即 Regular Expression 的縮寫。最簡單的模式可以只是一個字元,複雜的模式則能包含更多字元,用於解析、格式檢查、取代等。建立方式有兩種:使用 RegExp() 建構函式,或使用字面量語法。
正規表達式(在程式碼中常簡寫為 regex、regexp 或 RE)是用單一字串來描述、比對一組符合某個語法規則的字串搜尋模式。它可以用於文字搜尋與文字取代。
當你在文字中搜尋資料時,可以用搜尋模式描述你要查的內容。也就是說,正規表達式是描述字元模式的物件,能對字串做模式比對、檢索與取代,是處理字串最強力的工具。
直白地說,它就是「規則表達式」——表達了某種電腦能理解、但人不容易讀懂的規則,適用於所有文字搜尋與取代的場合。
<script>
var str='abcdefgca';
alert(str.charAt()); //返回某一位的字符,此處為 d
alert(str.search('z')); //查找首次出現的位置,此處為 -1
alert(str.match('c')); //只返回第一次出現的 c,不再向後匹配
alert(str.replace('a','i')); //返回 ibcdefgca,只替換第一個 a
var str='--aaa--cd';
var arr = str.split('-'); //返回 ["", "", "aaa", "", "", "cd"]
alert(arr);
</script>
思路:遍歷字串,把數字字元累積到一個暫存字串中;遇到非數字且暫存有值時,就把它推入陣列並清空暫存。迴圈結束後還要再判斷一次,因為最後一段數字可能還沒被推入。
<script>
var str = 'abc d aa c zz -=-=s-';
var arr = [];
var num = '';
for(var i=0; i<str.length; i++){
if(str.charAt(i) >= '0' && str.charAt(i) <= '9'){
num += str.charAt(i);
} else {
if(num){
arr.push(num);
num = '';
}
}
}
if(num){
arr.push(num);
num = '';
}
alert(arr);
</script>
邏輯清楚,但程式碼不短。改用正則,一個表達式就能取代這一切。
建構語法:
var re = new RegExp('模式', '修飾符');
模式即表達式本體,修飾符用於指定全域比對、忽略大小寫等行為。這寫法就是典型的 new 建構物件——但正則真正的實力不在這裡,日常實作幾乎都採用另一種更簡潔的字面量風格:
var re = /模式/修飾符;
這種寫法簡潔得多,也正好符合正則「該短就短」的性格。
修飾符用於全域比對與忽略大小寫:
i:ignore,忽略大小寫g:global,全域比對 <script>
var str='AbCdEFgiX';
var reg = new RegExp('abc', 'i');
alert(str.match(reg)); // 返回 AbC
var re = /efg/i;
alert(str.match(re)); // 返回 EFg
</script>
① 任意字元 表達式:[abc]
比對方括號中的任一字元,[] 在此處是「或」的意思。
<script> var str='apc xpc ppc bpc spc opc'; var re = /[apx]pc/g; // a、p、x 中任一個出現皆可 alert(str.match(re)); // 返回 apc, ppc, xpc </script>
② 範圍比對
[0-9]:任一 0~9 的數字[a-z]:任一 a~z 的字元[A-z]:任一 大寫A~小寫z 的字元[A-Z]:任一 大寫A~大寫Z 的字元③ 排除比對
[^abc]:任一不在括號中的字元[^a-z]:任一非字母字元,含數字、符號、中文、外文[^0-9]:任一非數字字元<script> var str='ot out o.t o t o`t ot ot'; var re = /o[^0-9]t/g; // o 與 t 中間除了數字,什麼都可以 alert(str.match(re)); // 返回 out, o.t, o t, o`t </script>
④ 選擇比對 表達式:(a|b|c),比對 a 或 b 或 c。
⑤ 組合模式 例如 [a-z0-9A-Z] 表示任意大小寫字母與數字;[^a-z0-9] 表示除了字母數字以外什麼都可以。
元字元是帶有特殊意義的字元:
. 單一字元,代表任意字元(不含換行與行結束符)。容易出問題,不建議使用。\w 單字字元,含英文、數字、底線,等同 [a-z0-9_]\W 非單字字元,等同 [^a-z0-9_]\d 數字,等同 [0-9]\D 非數字,等同 [^0-9]\s 空白字元,含空格、回車、定位、換行、換頁等不可見字元\S 非空白字元\b 位於單字開頭或結尾的邊界比對,未比中則回傳 null\B 非單字邊界的比對,即比對位置的左右字元同屬單字或同屬非單字;字串首尾視為非單字,未比中則回傳 null\n 換行符\f 換頁符\r 回車符\t 定位字元量詞就是數量詞,用於指定出現次數:
* 零次或任意次,等同 {0,}。範圍太廣、不夠精確,不推薦。? 零次或一次,等同 {0,1}。例:/10?/g 全域搜尋 1,含其後緊跟的零或一個 0。+ 一次或任意次,等同 {1,}。例:/\w+/g 搜尋至少一個單字字元。{n} 正好 n 次。例:/\d{4}/g 搜尋含四位數的數字。{n,} 至少 n 次,上限不限。例:/\d{3,}/g{n,m} 至少 n 次、最多 m 次。例:/\d{3,4}/g^a 任何以 a 開頭的字元,表示行首。例:/^\d/ 以數字開頭a$ 任何以 a 結尾的字元,表示行尾。例:/\d$/ 以數字結尾?=a 任何其後緊跟 a 的字元。例:/a(?=b)/g 搜尋 a 後緊跟 b 的情形?!a 任何其後沒有緊跟 a 的字元。例:/c(?!d)/g實例:找出字串中第一次出現數字的位置。
<script> var str = 'asdf zxcvbnm'; var re = /\d/; // 元字元 \d 代表數字 alert(str.search(re)); // 返回第一個數字出現的位置 </script>
<script> var str = 'asdf zxcvm'; var re = /\d/; // 未指定要找幾個,找到一處就返回 alert(str.match(re)); re = /\d/g; // 加上 g,會回傳所有符合的單一數字 alert(str.match(re)); re = /\d\d/g; // 指定兩位一組,但位數不一定固定 alert(str.match(re)); re = /\d+/g; // 用 + 表示「若干位」,這才是正解 alert(str.match(re)); </script>
實例:用正則找出字串中所有數字
<script> var str = ' abc d aa c zz -=-=s-'; alert(str.match(/\d+/g)); // 元字元 \d 也可用 [0-9] 代替 alert(str.match(/[0-9]+/g)); </script>
正則就是這樣強大的字串比對工具,一行抵上一堆迴圈。
<script>
var str = 'abc zaaz deaxcaa';
alert(str.replace('a', 1)); // 只把第一個 a 換成 1
var re = /a/g;
alert(str.replace(re, 1)); // 所有 a 都換成 1
</script>
敏感詞指的是法律不允許出現的詞語,涵蓋範圍很廣:危害國家安全、違反憲法基本原則、散布謠言、擾亂社會秩序、色情暴力賭博、誹謗騷擾、粗俗猥褻等等。最常見的莫過於日常口語中攻擊他人的詞。以下列舉幾個網路用語作為示範。
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>JavaScript實例</title>
<script>
window.onload = function (){
var oBtn = document.getElementById('btn');
var oTxt = document.getElementById('txt');
oBtn.onclick = function (){
// 這裡的 | 在正則中表示「或」
var re = /元芳|萌萌哒|然並卵|毛線|二貨|城會玩/g;
oTxt.value = oTxt.value.replace(re, '***');
};
};
</script>
</head>
<body>
<textarea id="txt" rows="5" cols="30"></textarea><br>
<input id="btn" type="button" value="過濾"><br>
<textarea id="txt2" rows="5" cols="30"></textarea>
</body>
</html>
在第一個文字框輸入含敏感詞的句子,點擊過濾即可看到效果。
此外,支援正則的字串方法還包括 split(),可把字串依模式切分成陣列。
用於檢測字串是否符合某個模式,即判斷是否含有某子字串。含有則回傳 true,否則 false。
語法:RegExpObject.test(str)
等價寫法:re.exec(str) != null。
<script> var str = 'The best things in life are free, like hugs, smiles, friends, kisses, family, love and good memories.'; alert(/i/.test(str)); // true alert(/z/.test(str)); // false </script>
用於檢索字串中的正則比對結果,回傳一個陣列存放結果;未找到則回傳 null。搭配迴圈可提取全部或指定位置的資料。
語法:RegExpObject.exec(str)
exec() 是 test() 的升級版——不只檢測,還能直接提取結果。
<script> var str = 'good good study day day up'; var re = /good/; var arr = re.exec(str); console.log(arr); // ["good"],展開後含 index 與 input 屬性 console.log(arr.index); // 匹配文本第一個字元的位置 console.log(arr.input); // 被檢索的字串 </script>
若找到匹配,回傳陣列:第 0 個元素是整個比對結果,第 1 個是與第 1 個子表達式匹配的內容,以此類推。此外還有兩個屬性:index 記錄匹配首字元位置,input 記錄被檢索的字串。
什麼是子表達式?就是正則中包含在圓括號中的部分:
<script> var str = 'good good study day day up'; var re = /g(o+)d/; var arr = re.exec(str); console.log(arr); // ["good", "oo"],長度 2 console.log(arr.length); // 2 var reg = /(o+)/; var arr2 = reg.exec(str); console.log(arr2); // ["oo", "oo"] console.log(arr2.length);// 2 </script>
子表達式是整個表達式的一部分,必須用 () 包起來。一個表達式可有多個子表達式,也支援多層嵌套。把表達式拆成多個子表達式,是為了能把它們當作獨立元素使用——既可隨整個表達式一起回傳,也能單獨取出。括號中還可用 | 做多重選擇,順序依括號出現的先後排列。
若使用全域比對,exec() 會記住位置並從 lastIndex 續找:
<script>
var str = 'good good study day day up';
var re = /good/g;
var arr;
do{
arr = re.exec(str);
console.log(arr);
console.log(re.lastIndex);
} while(arr !== null)
// 第一次:["good"],lastIndex 為 4
// 第二次:["good"],lastIndex 為 9
// 第三次:null,lastIndex 歸 0
</script>
全局模式下,exec() 會從 lastIndex 指定的位置開始檢索;比中後把 lastIndex 設為匹配文本下一個字元的位置,因此可以反覆呼叫來遍歷所有結果。找不到時回傳 null 並把 lastIndex 重置為 0。
務必注意:若要在比對完一個字串後接著檢索新字串(仍用舊的 re),必須手動把 lastIndex 重設為 0,否則會從上次的位置續找而漏掉開頭。
無論是否全局模式,exec() 都會回傳完整的細節;而 String.match() 在全局模式下回傳的資訊少得多。因此可以說,迴圈中反覆呼叫 exec() 是取得全局模式完整比對資訊的唯一方式。
用於在腳本執行期間編譯正則表達式,也可用來改變並重新編譯,主要作用是切換比對模式。
語法:RegExpObject.compile(模式, 修飾符)
<script> var str = 'Today is a beautiful day, Day day happy!'; var re = /day/gi; str = str.replace(re, '天'); console.log(str); // To天 is a beautiful 天, 天 天 happy! var reg = /(to)?day/gi; reg.compile(reg); str = str.replace(reg, '日'); console.log(str); // 日 is a beautiful 日, 日 日 happy! </script>
正則也叫規則表達式,寫作流程與寫 JavaScript 一樣:先想清楚再動手。最重要的是搞明白它要表達什麼規則——先仔細端詳目標的外觀,看它長什麼樣、以什麼格式存在,再依這個格式去寫表達式。
實務經驗是:直接把格式描述成表達式,往往不會一次就達到預期。但好消息是主框架已經在了,只需找出哪裡沒符合預期,在框架上微調即可。
以手機號為例:台灣手機號碼為 10 位數字、開頭是 0,其後第二位依電信商而異,剩下 8 位是任意數字。於是先規定開頭、再限定第二位、最後放寬其餘位數,主框架就完成了。若還有 +886 這類特殊寫法要支援,再對框架做補強即可。
說起來簡單,實際上手卻不容易——症結就在於這種「一般人看不懂」的表達方式。自己寫的時候清楚明白,過一陣子回頭看卻完全不認得。這是熟能生巧的過程,多寫多推敲自然就順了。
更重要的是思路:讓程式碼始終跟著「要達成什麼目的」走,怎麼簡單怎麼來(不是偷工減料,而是清楚知道什麼需要、什麼不需要)。有了這層思路,程式碼就能保持清晰簡潔,除錯與優化也都跟著變容易。
思路:QQ 號全是數字且首位不為 0,可寫 /^[1-9]/。常見位數為 5~10 位,用 {n,m} 限制:整串寫成 /\d{5,10}/。但首位既已限定,後面就該是 4~9 位,所以改成 /\d{4,9}/,最後再鎖住結尾不能是非數字。
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>JavaScript實例</title>
<script>
window.onload = function (){
var oBtn = document.getElementById('btn');
oBtn.onclick = function (){
var oTxt = document.getElementById('txt').value;
var re = /^[1-9]\d{4,9}$/;
if(re.test(oTxt)){
alert("格式正確");
} else {
alert('輸入錯誤');
}
};
};
</script>
</head>
<body>
<input id="txt" type="text" placeholder="請輸入QQ">
<input id="btn" type="button" value="驗證">
</body>
</html>
思路:先端詳 email 的外觀,例如 abc123_@ss789.xyz。大致可分五部分:若干字母數字底線、一個 @、若干字母數字、一個點、最後若干字母。對應寫法:
\w+(若干英文、數字、底線)@[a-z0-9]+\.——點在正則中代表任意字元,必須轉義[a-z]+整理後:/\w+@[a-z0-9]+\.[a-z]+/i
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>JavaScript實例</title>
<script>
window.onload = function (){
var oBtn = document.getElementById('btn');
var oTxt = document.getElementById('txt');
oBtn.onclick = function (){
var re = /\w+@[a-z-]+\.[a-z]+/i;
if(re.test(oTxt.value)){
alert('合法郵箱');
} else {
alert('非法郵箱');
}
};
};
</script>
</head>
<body>
<input id="txt" type="text" placeholder="請輸入郵箱">
<input id="btn" type="button" value="驗證">
</body>
</html>
拿 abc123_@ss789.xyz 來測,回傳「合法」。但換成 正則abc123_@ss789.xyz 也回傳合法——這顯然不對。
原因出在 test() 的特性:只要字串中的某一部分符合,就回傳 true。解法是加上行首行尾 ^...$,強制整串都要被檢測:
var re = /^\w+@[a-z-]+\.[a-z]+$/i;
再測一次,第一個合法、第二個非法,這個表達式才算到位。
當然它仍不夠嚴謹。現今網站多數會提供後綴下拉選單(如 @qq.com),若要求使用者自行輸入完整信箱,就得對後綴做白名單限定,否則 abc@随便.随便 這種也會通過。
最後一個觀念:前端驗證不可能做到完美,寫得再嚴謹也容易被繞過。格式檢查的職責在於「引導使用者正確輸入」,真正的資料驗證永遠該由後端把關。前端先擋掉明顯錯誤,再搭配後端確認,才是事半功倍的做法。
1. test() RegExpObject.test(string) 判斷 string 中是否有符合表達式的內容,有則 true,否則 false。
var patt1 = new RegExp("e");
document.write(patt1.test("The best things in life are free")); // true
2. exec() RegExpObject.exec(string) 檢索指定值,回傳被找到的內容;未發現則回傳 null。
var str = "cat2,hat8"; var reg = /c(at)\d/; // 有分組 console.info(reg.exec(str)); // ["cat2", "at"]
3. match() string.match(RegExpObject) 與 exec 類似,都回傳陣列,但兩點差異:正則中有 g 時,match 回傳所有匹配,而 exec 永遠只回傳第一個匹配的資訊;沒有 g 但有分組時,兩者結果相同。
var someText = "web2.0 .net2.0"; var pattern = /(\w+)(\d)\.(\d)/g; var outCome_exec = pattern.exec(someText); // ["web2.0","web","2","0"] var outCome_matc = someText.match(pattern); // ["web2.0","net2.0"]
4. search() stringObject.search(regexp) 回傳第一個匹配的起始位置。
5. replace() stringObject.replace(regexp/substr, replacement) 回傳替換後的新字串。第一參數為字串時只換第一個;為含 g 的正則時全部替換。回呼函式也能當第二參數:
function fn() {
for(var i = 0; i < arguments.length; i++){
alert("第"+(i+1)+"個參數的值:"+arguments[i]);
}
}
var str = '<div id="{wo}" >{ni}</div>';
str.replace(/\{([a-z]+)\}/ig, fn);
6. split() stringObject.split(separator, howmany) 第一參數是字串或正則,第二參數限制回傳陣列的最大長度。
var str = "cat2,hat8"; var reg = /at/; console.info(str.split(reg)); // ["c", "2,h", "8"] console.info(str.split(reg, 2)); // ["c", "2,h"]
7. compile() 用於改變 RegExp,既可改檢索模式,也可增刪第二參數。
var patt1 = new RegExp("e");
document.write(patt1.test("The best things in life are free")); // true
patt1.compile("d");
document.write(patt1.test("The best things in life are free")); // false
8. $1~$99 的捕獲群組
var str = "alert.login.verifyfailed=Your email or password is incorrect!"; var reg = /^alert\.\w*(?:\.\w*)=((?:\w*[ !\.])*)$/; var out = str.match(reg); console.info(out);
9. 測試 RegExp 屬性
function demo(){
var str = "abcdd abcsszabcdddccabAbcddABCEE";
var regex = /a(bc)/gi;
var t = null;
while(t = regex.exec(str)){
var result = "index = " + t.index + ", match = " + t[0] + ", group = " + t[1];
result += "/n$1=" + RegExp.$1 + ", lastMatch=" + RegExp.lastMatch
+ ", leftContext=" + RegExp.leftContext;
alert(result);
}
}
正則的學習曲線確實陡,但它換來的是程式碼上難以替代的簡潔度。多寫、多推敲、多留意邊界條件,自然就上手了。