正則的理解

　　元字元、量詞的合寫　　　

　　　/\d+/　　至少有一個數字

　　在字串中查詢與正則匹配的字元；

　　n+案例　

　　var st="heoollo"

　　var reg=/o+/g　　在字串中至少有一個o

　　console.log(st.match(reg))　結果為["oo","o"]

　　n*案例

　　var st="heoollo";

　　var reg=/o*/g　　在字串中匹配包含0個或多個o

　　console.log(st.match(reg))　　結果為["","","oo","","","o"];

　　顯然這不是我們想要的結果；

　　所以另一種寫法：在前面新增相鄰的字母 

　　案例

　　var st="heloollo"

　　var reg=/lo*/g　 匹配 l 之後帶0個或多個0的字元

　　console.log(st.match(reg))　　結果為["loo","l","lo"]

　　n?

　　var st="hellohlool"

　　var reg=/lo?/g　　包含 l 之後帶0個或1個o的字元

　　console.log(st.match(reg))　　結果為["l","lo","lo","l"];

　　n{x}　　x個n

　　var st="helloohoo"

　　var reg=/lo{2}/g　　翻譯為：var reg=/loo/g

　　console.log(st.match(reg));　　結果為["loo"]

　　?=n　　指定一個後面必須跟著n的字串，返回結果不帶n，使用過程中加()

　　var st="hellohho"

　　var reg=/h(?=o)/g　　全域性匹配找一個h後面找o的h

　　console.log(st.match(reg));　　結果為["h"]

　　/ln+/　　l後面至少有一個n；

　　/ln*/　　l後面有0個或多個n；

　　/ln?/　　l後面有0個或1個n；

　　/l(?=n)/　　l後面緊跟著n，返回的是l，如果l後面沒有n，返回的是null；

　　正則RegExp（類）

　　概念：用來檢驗字串的規則；

　　定義：通過這兩種方法定義一個正則；

　　　　1.var reg=/格式/

　　　　2.var reg=new RegExp

　　其本質都是一個物件

　　方法：

　　　　1.test()　　匹配的方法

　　　　2.exec()　　捕獲的方法

　　修飾符：　i　　m　　g

　　[ ]

　　元字元：

　　量詞　　（詳情見上一章）

　　正則的理解：

　　1.正則的懶惰性：

　　2.正則的貪婪性；

　　懶惰性；

　　　　每一次在exec()中捕獲的時候，只捕獲第一次匹配的內容，而不往下捕獲了，我們把這種方式叫正則的懶惰性；

　　捕獲開始的位置都是從0開始；

　　解決正則的懶惰性

　　　　修飾符：g 全域性匹配；

　　案例：　　

　　　　var st="hello45612world12345"

　　　　var reg=/\d+/g

　　　　console.log(reg.exec(st));　　結果為：45612　　這就是正則的懶惰性，每次只輸出第一次匹配上的

　　　　console.log(reg.exec(st));　　結果為：12345　　再次輸出的話，就發現他捕獲的位置從第一次輸出後就開始捕獲，不再從零捕獲（正是因為g的全域性捕獲）

　　　　正則的例項物件reg有一個lastlndex的屬性，捕獲的起始位置；

　　　　如何將捕獲的內容匯聚在一起：

　　　　console.log(st.match(reg))；　　利用字元換中match的方法即可

　　正則的貪婪性：

　　　　正則每次捕獲都是按照最長的結果，我們把這種功能叫正則的貪婪性；

　　案例：

　　　　var st="hello12345"

　　　　var reg=/\d+/g;

　　　　console.log(reg.exec(st));　　結果為["12345"]　　只捕獲到最長的數字 不會是1，或1，2直接就是1，2，3，4，5

　　怎樣處理正則的貪婪性：

　　　　在元字元量詞的後面加？

　　　　案例：

　　　　var st="hello456121245"

　　　　var reg=/\d+?/g

　　　　console.log(st.match(reg))

　　分組捕獲，正則裡面帶（），就是分組捕獲；

　　/(a)(b)/　　解析：外面一個大正則，裡面帶了兩個小正則； 　　　　（先算（））

　　分組捕獲的優點：1.可以改變優先順序；

　　　　　　　　　　2.可以分組引用；

　　分組引用\1,\2　　\1代表和第一個分組出現的一模一樣，\2和第二個分組出現的一模一樣

　　在數分組的個數時，從左往右；

　　/(a)(b)/　　　　　　（分組也是一個整體）

　　第一組：（ab）

　　第二組：（a）　　　　　　

　　第三組：（b）

　　案例：

　　　　var reg=/(\w)\1(\w)\2/

　　　　var st="ssdd";

　　　　console.log(reg.test(reg))　　只有這樣才會返回true

　　案例二：

　　　　var reg=/(a)\1(b)\2/

　　　　var st="aabb"

　　　　console.log(reg.test(reg))　　只用這樣才會返回true

　　　　解析這種寫法的意思：

　　　　　　第一個是分組，且是一個單詞字元，第二個是個分組引用，要求和第一組一模一樣，第三個是第二個分組且是一個單詞字元，第四個是一個分組引用，要求和第二組一模一樣

　　分組捕獲：

　　　　分組捕獲的前提是正則存在分組，不僅把大正則的內容捕獲到把小正則的內容捕獲到；

　　　　案例：

　　　　　　var st="absd";

　　　　　　var reg=/(a)(b)/;

　　　　　　console.log(reg.exec(st))　　結果為["ab","a","b"]

　　怎麼解除分組捕獲，如果你不想捕獲某一個分組的內容，在分組前面加一個?:就可以了；

　　　　案例：

　　　　　　var st="absd";

　　　　　　var reg=/(a)(?:b)/

　　　　　　console.log(reg.exec(st))　　結果為["ab","a"]

　　元字元、量詞的合寫　　　

　　　/\d+/　　至少有一個數字

　　在字串中查詢與正則匹配的字元；

　　n+案例　

　　var st="heoollo"

　　var reg=/o+/g　　在字串中至少有一個o

　　console.log(st.match(reg))　結果為["oo","o"]

　　n*案例

　　var st="heoollo";

　　var reg=/o*/g　　在字串中匹配包含0個或多個o

　　console.log(st.match(reg))　　結果為["","","oo","","","o"];

　　顯然這不是我們想要的結果；

　　所以另一種寫法：在前面新增相鄰的字母 

　　案例

　　var st="heloollo"

　　var reg=/lo*/g　 匹配 l 之後帶0個或多個0的字元

　　console.log(st.match(reg))　　結果為["loo","l","lo"]

　　n?

　　var st="hellohlool"

　　var reg=/lo?/g　　包含 l 之後帶0個或1個o的字元

　　console.log(st.match(reg))　　結果為["l","lo","lo","l"];

　　n{x}　　x個n

　　var st="helloohoo"

　　var reg=/lo{2}/g　　翻譯為：var reg=/loo/g

　　console.log(st.match(reg));　　結果為["loo"]

　　?=n　　指定一個後面必須跟著n的字串，返回結果不帶n，使用過程中加()

　　var st="hellohho"

　　var reg=/h(?=o)/g　　全域性匹配找一個h後面找o的h

　　console.log(st.match(reg));　　結果為["h"]

　　/ln+/　　l後面至少有一個n；

　　/ln*/　　l後面有0個或多個n；

　　/ln?/　　l後面有0個或1個n；

　　/l(?=n)/　　l後面緊跟著n，返回的是l，如果l後面沒有n，返回的是null；

　　正則RegExp（類）

　　概念：用來檢驗字串的規則；

　　定義：通過這兩種方法定義一個正則；

　　　　1.var reg=/格式/

　　　　2.var reg=new RegExp

　　其本質都是一個物件

　　方法：

　　　　1.test()　　匹配的方法

　　　　2.exec()　　捕獲的方法

　　修飾符：　i　　m　　g

　　[ ]

　　元字元：

　　量詞　　（詳情見上一章）

　　正則的理解：

　　1.正則的懶惰性：

　　2.正則的貪婪性；

　　懶惰性；

　　　　每一次在exec()中捕獲的時候，只捕獲第一次匹配的內容，而不往下捕獲了，我們把這種方式叫正則的懶惰性；

　　捕獲開始的位置都是從0開始；

　　解決正則的懶惰性

　　　　修飾符：g 全域性匹配；

　　案例：　　

　　　　var st="hello45612world12345"

　　　　var reg=/\d+/g

　　　　console.log(reg.exec(st));　　結果為：45612　　這就是正則的懶惰性，每次只輸出第一次匹配上的

　　　　console.log(reg.exec(st));　　結果為：12345　　再次輸出的話，就發現他捕獲的位置從第一次輸出後就開始捕獲，不再從零捕獲（正是因為g的全域性捕獲）

　　　　正則的例項物件reg有一個lastlndex的屬性，捕獲的起始位置；

　　　　如何將捕獲的內容匯聚在一起：

　　　　console.log(st.match(reg))；　　利用字元換中match的方法即可

　　正則的貪婪性：

　　　　正則每次捕獲都是按照最長的結果，我們把這種功能叫正則的貪婪性；

　　案例：

　　　　var st="hello12345"

　　　　var reg=/\d+/g;

　　　　console.log(reg.exec(st));　　結果為["12345"]　　只捕獲到最長的數字 不會是1，或1，2直接就是1，2，3，4，5

　　怎樣處理正則的貪婪性：

　　　　在元字元量詞的後面加？

　　　　案例：

　　　　var st="hello456121245"

　　　　var reg=/\d+?/g

　　　　console.log(st.match(reg))

　　分組捕獲，正則裡面帶（），就是分組捕獲；

　　/(a)(b)/　　解析：外面一個大正則，裡面帶了兩個小正則； 　　　　（先算（））

　　分組捕獲的優點：1.可以改變優先順序；

　　　　　　　　　　2.可以分組引用；

　　分組引用\1,\2　　\1代表和第一個分組出現的一模一樣，\2和第二個分組出現的一模一樣

　　在數分組的個數時，從左往右；

　　/(a)(b)/　　　　　　（分組也是一個整體）

　　第一組：（ab）

　　第二組：（a）　　　　　　

　　第三組：（b）

　　案例：

　　　　var reg=/(\w)\1(\w)\2/

　　　　var st="ssdd";

　　　　console.log(reg.test(reg))　　只有這樣才會返回true

　　案例二：

　　　　var reg=/(a)\1(b)\2/

　　　　var st="aabb"

　　　　console.log(reg.test(reg))　　只用這樣才會返回true

　　　　解析這種寫法的意思：

　　　　　　第一個是分組，且是一個單詞字元，第二個是個分組引用，要求和第一組一模一樣，第三個是第二個分組且是一個單詞字元，第四個是一個分組引用，要求和第二組一模一樣

　　分組捕獲：

　　　　分組捕獲的前提是正則存在分組，不僅把大正則的內容捕獲到把小正則的內容捕獲到；

　　　　案例：

　　　　　　var st="absd";

　　　　　　var reg=/(a)(b)/;

　　　　　　console.log(reg.exec(st))　　結果為["ab","a","b"]

　　怎麼解除分組捕獲，如果你不想捕獲某一個分組的內容，在分組前面加一個?:就可以了；

　　　　案例：

　　　　　　var st="absd";

　　　　　　var reg=/(a)(?:b)/

　　　　　　console.log(reg.exec(st))　　結果為["ab","a"]