1. 程式人生 > >正則的理解 正則的理解

正則的理解 正則的理解

正則的理解

  元字元、量詞的合寫   

   /\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"]