제6 주 넷 째 날 필기

1. 정규 표현 식 의 전역 g 가 몇 가지 방법 에 미 치 는 영향 검증

test 검사 방법: 정규 적 인 방법

요약: 1) 전역 g 을 추가 하지 않 을 때 lastIndex 값 은 항상 0 이기 때문에 검사 가 일치 할 때마다 0 부터 찾 고 찾 으 면 true 로 돌아 가 며 찾 지 못 하면 false 로 돌아 갑 니 다.2) 전역 g 을 추가 하면 test 방법 은 lastIndex 값 을 중첩 하여 변경 합 니 다. 검사 할 때마다 lastIndex 값 이 바 뀌 고 다음 에 찾 을 때 lastIndex 값 부터 찾 습 니 다.

 
     var str="yuanmeng00huadianyuanmenghuadian11";
     var reg=/yuanmeng\d+/;
     var reg1=/yuanmeng\d+/g;
     //     g;
     console.log(reg.test(str));//   true;
     //    g;
     console.log(reg1.lastIndex);//   0；
     console.log(reg1.test(str));//   true;       yuanmeng00；
     console.log(reg1.lastIndex);//   10；
     console.log(reg1.test(str));//   false，    10       ，    ，  null;

exec 방법: 정규 적 인 방법

요약: 1) 전체 g 를 추가 하지 않 고 찾 을 때마다 0 부터 reg 의 lastIndex 는 0 입 니 다.2) 정규 exec 방법 에 g 를 추가 하면 한 번 사용 할 때마다 하 나 를 찾 은 다음 에 배열 로 출력 합 니 다. 출력 을 찾 을 때마다 다음 에 찾 는 위 치 는 reg 의 lastIndex 속성 치 를 통 해 기록 되 고 exec 방법 으로 다시 찾 을 때 마지막 에 끝 난 곳 부터 찾 습 니 다.

 
    var str="yuanmenghuadianyuanmenghuadian11";
    var reg=/yuanmeng/;
    var reg1=/yuanmeng/g;
    //2.1        g
    console.log(reg.exec(str));//   ：["yuanmeng", index: 0, input: "yuanmenghuadianyuanmenghuadian11", groups: undefined]
    console.log(reg.lastIndex);//   ：0
    console.log(reg.exec(str));//   ：["yuanmeng", index: 0, input: "yuanmenghuadianyuanmenghuadian11", groups: undefined]
    console.log(reg.lastIndex);//   ：0
    console.log(reg.exec(str));//   ：["yuanmeng", index: 0, input: "yuanmenghuadianyuanmenghuadian11", groups: undefined]
    console.log(reg.lastIndex);//   ：0
    //  ：     g,       ，   0  ，reg lastIndex   0；
    //2.2       g
    console.log(reg1.exec(str));//   ：["yuanmeng", index: 0, input: "yuanmenghuadianyuanmenghuadian11", groups: undefined]
    console.log(reg1.lastIndex);//   ：8
    console.log(reg1.exec(str));//   ：["yuanmeng", index: 15, input: "yuanmenghuadianyuanmenghuadian11", groups: undefined]
    console.log(reg1.lastIndex);//   ：23
    console.log(reg1.exec(str));//   ：null
    console.log(reg1.lastIndex);//   ：0
    console.log(reg1.exec(str));//   ：["yuanmeng", index: 0, input: "yuanmenghuadianyuanmenghuadian11", groups: undefined]
    //  ：  exec     g，  ，          ，          ，       ，         reg lastIndex      ，    exec     ，             ；

match 방법: 문자열 의 방법

요약: 문자열 match 방법 은 본질 적 으로 내용 을 찾 는 것 입 니 다. 하 나 를 찾 으 면 하나의 배열 로 돌아 갑 니 다. 배열 에는 세 가지 가 있 습 니 다.exec 방법 으로 얻 은 것 과 같 음;

요약: 1) 전체 g 를 추가 하지 않 을 때;match 방법 은 exec 방법 에 해당 합 니 다. 내용 을 찾 고 하나의 배열 로 되 돌아 갑 니 다. 안에 세 가지 가 있 습 니 다.2) 전역 g 을 추가 할 때 match 방법 은 reg 규칙 을 만족 시 키 는 모든 내용 을 배열 요소 로 하여 새로운 배열 로 되 돌려 줍 니 다.

 
     var str="yuanmenghuadianyuanmenghuadian11";
     var reg=/yuanmeng/;
     var reg1=/yuanmeng/g;
     console.log(str.match(reg));//   ：["yuanmeng", index: 0, input: "yuanmenghuadianyuanmenghuadian11", groups: undefined]
     console.log(str.match(reg1));//   ：["yuanmeng", "yuanmeng"]
     //  ：      g ；match     exec  ，     ，          ，     ；
     //     g ，match  ，      reg     ，      ，        ；

replace 방법: 문자열 의 방법

요약: 1) 문자열 replace 방법 을 사용 할 때 문자열 에서 교 체 된 내용 을 찾 으 면 중단 하고 교체 한 다음 에 새로운 문자열 을 되 돌려 줍 니 다.주의: 하나만 찾 으 면 끝 납 니 다.2) 정규 표현 식 이 전체 g 를 추가 하지 않 을 때 이 때 는 한 번 찾 는 것 을 의미 합 니 다. 사용 할 때 하 나 를 찾 으 면 멈 춥 니 다. 교 체 된 내용 을 하나의 규칙 으로 바 꾸 었 을 뿐 본질 은 변 하지 않 습 니 다.3) 정규 표현 식 에 전역 g 을 추가 한 후 전역 에서 정규 규칙 에 만족 하 는 모든 내용 을 찾 은 다음 에 모든 바 꾸 고 새로운 문자열 을 되 돌려 주 는 것 을 의미 합 니 다.

 
     var str="yuanmenghuadianyuanmenghuadian11";
     var reg=/yuanmeng/;
     var reg1=/yuanmeng/g;
     console.log(str.replace(reg,"meihao"));//   ：meihaohuadianyuanmenghuadian11
     console.log(str.replace(reg1,"meihao"));//   ：meihaohuadianmeihaohuadian11
     //  ，     g，        ，       ，     ，   ，       ；
     //    g，        ，     ，      ，   ，       ；

2. 문자열 의 repalce 방법 과 정규 배합 후의 변화

요약:

문자열 replace 방법 은 본질 적 으로 교 체 된 내용 을 찾 은 다음 에 바 꾸 고 새로운 문자열 로 돌아 가 는 것 입 니 다. 그러나 주의해 야 할 것 은 찾 을 때마다 하나만 찾 고 하나만 있 으 면 멈 춘 다음 에 하 나 를 바 꾸 는 것 입 니 다. 끝 날 때 두 개의 요 구 를 만족 시 키 는 내용 을 바 꾸 지 않 습 니 다.

전역 g 을 추가 하지 않 습 니 다. 상기 방법 결과 와 마찬가지 로 하나만 찾 은 다음 에 하 나 를 교체 하고 끝 냅 니 다.

전역 g 을 추가 하고 찾기 규칙 을 변경 합 니 다. 찾 을 때 규칙 에 만족 하 는 내용 을 모두 찾 은 다음 에 모두 바 꾸 고 마지막 으로 끝 냅 니 다.

정규 적 으로 변 경 된 것 은 하나의 규칙 일 뿐 replace 의 특성 을 바 꾸 지 않 고 찾기 규칙 만 바 꾸 었 습 니 다.

실질: 문자열 에 있 는 replace 방법 은 특성 이 바 뀌 지 않 았 습 니 다. 정규 만 추가 하여 찾 는 규칙 을 바 꾸 었 을 뿐 입 니 다.원래 하 나 를 찾 는 것 에서 모든 것 을 찾 는 것 으로 바 뀌 었 는데 이것 이 결정적 인 역할 을 하 는 것 은 바로 정규 이 고 그 가 제정 한 규칙 이다.


    //  ：      replace  ， str    huadian，     huandianxiehe;
    var str="huadianhuadian";
    str=str.replace("huadian","huadianxiehe");
    console.log(str);//   ：huadianxiehe huadian;
    str=str.replace("huadian","huadianxiehe");
    console.log(str);//   ：huadianxiehe xiehe huadian;
    //  ：   replace  ，            ，      ，         ，         ，         ，        ，      ，  ，               ；
    //    ，       ，         ，         ，         ，    ，     ，      ，    huadian        ；

    //    replace  ；
    //1.           g；
    var str="huadianhuadian";
    var reg=/huadian/;
    str=str.replace(reg,"huadianxiehe");
    console.log(str);//   ：huadianxiehe huadian
    str=str.replace(reg,"huadianxiehe");
    console.log(str);//   ：huadianxiehe xiehe huadian
    //  ：     g，         ，        ，      ，  ；
    //2.        g,
    var str="huadianhuadian";
    var reg=/huadian/g;
    console.log(str.replace(reg,"huadianxiehe"));//   ：huadianxiehe huadianxiehe
    //  ，    g,      ，      ，             ，      ，    ；
    //   ：     ，      ，    replace   ，         ；
    //  ：      replace  ，      ，          ，         ；        ，      ，              ，      ；

3. replace 방법 중의 리 셋 함수

리 셋 함수: 함수 의 정의 단 계 를 매개 변수 로 하고 다른 함수 에 부여 합 니 다. 이런 함 수 를 리 셋 함수 라 고 합 니 다.

replace 방법 중의 반전 함수:

replace 방법 중의 리 셋 함수 호출 횟수 는 정규 일치 횟수 에 따라 몇 번 일치 하면 몇 번 호출 합 니까?

replace 방법 은 정규 에 맞 는 내용 을 찾 을 때마다 함 수 를 호출 하고 현재 가 져 온 내용 의 세 가지 매개 변 수 를 입력 합 니 다. 사실은 내용 에 대한 모든 만족 상황 을 옮 겨 다 니 는 것 으로 볼 수 있 습 니 다.

replace 방법 중의 리 셋 함 수 는 실제 인삼 에 들 어 갑 니 다. 들 어 오 는 내용 은 exec 에서 얻 은 세 가지 내용 값 입 니 다. 예 를 들 어 1) item: 큰 정규 내용 (작은 그룹 이 있 으 면 두 번 째 항목 은 작은 그룹의 내용) 입 니 다.2) index: 찾 을 때마다 시작 에 대응 하 는 색인 값;3) 입력: 문자열;

 
     //    ：                      ，           ；
     var str="yuanmengyuanmeng";
     var reg=/yuanmeng/g;
     //replace           ，            ；
     //replace      ，      exec          ；
     str=str.replace(reg,function (item,index,input) {
         //              ， arguments
         console.log(arguments);//   ：["yuanmeng", 0, "yuanmengyuanmeng"]；
         return "yuanmengpeixun";
     });
     console.log(str);//   ：yuanmengpeixunyuanmengpeixun

인 스 턴 스 1: 민감 한 단 어 를 걸 러 내 는 것, 즉 replace 방법 을 이용 하여 특정한 단 어 를 대응 하 는 수의 * 번호 로 교체 하 는 것 이다.

지식 점: replace 방법 에서 리 셋 함 수 를 사용 하여 첫 번 째 정규 내용 파 라미 터 를 얻 습 니 다.

 
                             IE   IE  ，          IE            ，                  ；
 
 
  <script>
     var oT1=document.getElementById("t1");
     var oT2=document.getElementById("t2");
     var oBtn=document.getElementsByTagName("input")[0];
     var reg=/(   |     |  )/g;
     oBtn.onclick=function(){
         oT2.value=oT1.value.replace(reg,function (item) {
             //                ，    ，     ，  ，       ，     ，   *   
             var str="";
             for(var i=0; i<item.length; i++){
                 str+="*";
             }
             return str;
         });
     };
 
 </script>
 
</code></pre> </li> 
  <li>  2：     
   <ul> 
    <li>   ：replace         ，                  ，          ；</li> 
   </ul> <pre><code> <script>
     var str="my name is {0},i come from {1},my age is {2}";
     var ary=["   ","  ",26];
     var reg=/{(\d)}/g;
     var res=str.replace(reg,function ($1, $2) {
         //$1        ，$2        
         return ary[$2];
     });
     console.log(res);//   ："my name is    ,i come from   ,my age is 26"
 </script>
</code></pre> </li> 
  <li>  3：      <pre><code> <script>
     //  ：       ；
     var str="           15555 ";
     var ary=[" "," "," "," "," "," "," "," "," "," "];
     var res=str.replace(/\d/g,function ($1) {
         return ary[$1];
     });
     console.log(res);//   ：                 
 </script>
</code></pre> </li> 
  <li>  4：          <pre><code> <script>
     var str="   meihoa   miehfaofie    ";
     //  1：           
     var reg=/(^\s+)|(\s+$)/g;
     var res=str.replace(reg,"");
     console.log("("+res+")");//   ：(meihoa   miehfaofie)
     //  2：       
     var reg2=/\s+/g;
     var res2=str.replace(reg2,"");
     console.log("("+res2+")")//   ：(meihoamiehfaofie)
 </script>
</code></pre> </li> 
  <li>  5：                     
   <ul> 
    <li>  ： 
     <ol> 
      <li>          ，    ，       </li> 
      <li>         ；   </li> 
      <li>       </li> 
     </ol> </li> 
   </ul> <pre><code> <script>
     //  ：          （     ），        ；
     //   ：          ，    ，       
     var str="aaaabbdddDJJJLLLIIEEaaBBDbbcccCCC";
     var obj={};
     for(var i=0; i<str.length; i++){
         var cur=str[i].toLowerCase();
         if(obj[cur]){
             obj[cur]++;
         }else{
             obj[cur]=1;
         }
     }
     //   ：         ；
     //   ：  a     
     var max=obj.a;
     for(var attr in obj){
         if(obj[attr]>max){
             max=obj[attr];
         }
     }
     //   ，       
     var ary=[];
     for(var atr in obj){
         if(obj[atr]==max){
             ary.push(atr);
         }
     }
     var str=ary.join("、");
     console.log("          :"+str);//   ：          :a、b、c
     console.log("         "+max+" ");//   ：         6 
 </script>
</code></pre> </li> 
 </ul> 
 <h3>4. replace   exec   match       </h3> 
 <ul> 
  <li>exec  ：       reg     ，      ，      ；               ；</li> 
  <li>match  ：         reg     ，          ，  ；             ；</li> 
  <li>replace  ：          reg     ，    ；          ；    match    ；      ，         ，       ，    exec      ，     exec       ，     ；              ，          ，         ，    match            ，    match            ；</li> 
 </ul> 
 <h3>5.RegExp       lastIndex</h3> 
 <ul> 
  <li>lastIndex  ：  RegExp        ； 
   <ul> 
    <li>      ，      g， lastIndex    0，test   exec       ，      0    ；</li> 
    <li>      ，     g； test   exec  ，   lastIndex     ，lastIndex           ，            ，      ，    lastIndex     ；         ，  lastIndex       ；</li> 
   </ul> <pre><code> <script>
     var str="meihao1231meihao443343tiankong23243meihao5";
     var reg=/meihao\d{1}/;
     //1.      g ，lastIndex    0;
     console.log(reg.lastIndex);//   ：0；
     console.log(reg.exec(str));//   ：["meihao1", index: 0, input: "meihao1231meihao443343tiankong23243meihao5", groups: undefined]
     console.log(reg.lastIndex);//   ：0；
     console.log(reg.exec(str));//   ：["meihao1", index: 0, input: "meihao1231meihao443343tiankong23243meihao5", groups: undefined]
     console.log(reg.lastIndex);//   ：0；
     console.log(reg.exec(str));//   ：["meihao1", index: 0, input: "meihao1231meihao443343tiankong23243meihao5", groups: undefined]
     //2.      g ，lastIndex    
     //2.1 exec lastIndex   
     var reg1=/meihao\d{1}/g;
     console.log(reg1.lastIndex);//   ：0；
     console.log(reg1.exec(str));//   ：["meihao1", index: 0, input: "meihao1231meihao443343tiankong23243meihao5", groups: undefined]
     console.log(reg1.lastIndex);//   ：7；
     console.log(reg1.exec(str));//   ：["meihao4", index: 10, input: "meihao1231meihao443343tiankong23243meihao5", groups: undefined]
     console.log(reg1.lastIndex);//   ：17；
     console.log(reg1.exec(str));//   ：["meihao5", index: 35, input: "meihao1231meihao443343tiankong23243meihao5", groups: undefined]
     console.log(reg1.lastIndex);//   ：42；
     console.log(reg1.exec(str));//   ：null;
     console.log(reg1.lastIndex);//   ：0；
     console.log(reg1.exec(str));//   ：["meihao1", index: 0, input: "meihao1231meihao443343tiankong23243meihao5", groups: undefined]
     //  ：exec    lastIndex     ；lastIndex           ，            ，      ，    lastIndex     ；
     //2.2 test lastIndex   
     var reg2=/meihao\d{1}/g;
     console.log(reg2.lastIndex);//   ：0；
     console.log(reg2.test(str));//   ：true;
     console.log(reg2.lastIndex);//   ：7；
     console.log(reg2.test(str));//   ：true;
     console.log(reg2.lastIndex);//   ：17；
     console.log(reg2.test(str));//   ：true;
     console.log(reg2.lastIndex);//   ：42；                  ；        ，          ；
     console.log(reg2.test(str));//   ：false;
     console.log(reg2.lastIndex);//   ：0；       ，  ；
     console.log(reg2.test(str));//   ：true;
     //  ：test    lastIndex     ；lastIndex           ，            ，      ，    lastIndex     ；
     //2.3          lastIndex    ；
     var reg3=/meihao\d{1}/g;
     console.log(reg3.lastIndex);//   ：0；
     console.log(reg3.test(str));//   ：true;
     console.log(reg3.lastIndex);//   ：7；
     console.log(reg3.exec(str));//   ：["meihao4", index: 10, input: "meihao1231meihao443343tiankong23243meihao5", groups: undefined]；
     console.log(reg3.lastIndex);//   ：17；
     console.log(reg3.test(str));//   ：true；
     console.log(reg3.lastIndex);//   ：42；
     console.log(reg3.exec(str));//   ：null；
     console.log(reg3.lastIndex);//   ：0；
     console.log(reg3.exec(str));//   ：["meihao1", index: 0, input: "meihao1231meihao443343tiankong23243meihao5", groups: undefined]；
     //  ：       ，         lastIndex       ；     exec   ，   lastIndex   ；
 </script>
</code></pre> 
   <ul> 
    <li>  ：</li> 
   </ul> <pre><code> <script>
     var str="alpha(opacity:10)";
     var reg=/alpha\(opacity:(\d+)\)/g;//          ，      ；
     console.log(reg.lastIndex);//   0；
     if(reg.test(str)){//    test  ， lastIndex   
         console.log(reg.lastIndex);//   17；     ，   17    ；
         console.log(reg.exec(str));//   null;  exec lastIndex     ；
         console.log(reg.lastIndex);//   0；
     }else{
         alert(false);
     }
     //       g ，    test   exec   ，   lastIndex     ；
 </script>
</code></pre> </li> 
 </ul> 
 <h3>6.RegExp     </h3> 
 <ul> 
  <li>RegExp     ：       ，     ，         ，     ，       test   exec     ，     $1        ； <pre><code> <script>
     var str="alpha(opacity:10)";
     var reg=/alpha\(opacity:(\d+)\)/;//          ，      ；
     console.log(RegExp.$1);//   ： ；        RegExp       $1  ，     ，   ；
     if(reg.test(str)){
        console.log(RegExp.$1);//   ：10；
     }else{
         alert(false);
     }
     //exec   test  ，             ；
     //        exec   test    ，          ，        ；
     //$1         ，       ，       ；
     //  $1,        ；$2，        
     //    lastIndex  ；
 </script>
</code></pre> </li> 
 </ul> 
 <h3>7.     </h3> 
 <ul> 
  <li>  ：    ，   "\1","\2"   ，      ："\1"             ；"\2"             ； <pre><code>  <script>
      //    ：  \1         ；\2         ；
      var reg=/\w(\w)\1(\w)\2/;
      console.log(reg.test("abbcc"));//   ：true;
      console.log(reg.test("12233"));//   ：true;
      //  reg    ，     ，         （      ），         （      ）；
      var reg2=/\w(\w)(\w)\w\1\2/;
      console.log(reg2.test("abcdbc"));//   ：true;
      console.log(reg2.test("abcdbb"));//   ：false;
      //  reg2    ，     ，         （      ），         （      ）；
      //    \1,\2      ，               ；
  </script>
</code></pre> </li> 
  <li>  ：                 
   <ul> 
    <li>  ： 
     <ol> 
      <li> str    ，      ，          ；</li> 
      <li>      ，  replace  </li> 
     </ol> </li> 
    <li>   ： 
     <ul> 
      <li>        ，  sort  ，         ；</li> 
      <li>     <code>var reg=/(\w)\1+/gi</code>  ：           ，         ，"+"          ，"g"        ，"i"       ；</li> 
      <li>replace          </li> 
     </ul> </li> 
   </ul> <pre><code> <script>
     var str="aaaabbdddDJJJLLLIIEEaaBBDbbcccCCC";
     //   ： str    ，      
     //  ：      ，  sort  ，       
     var ary=str.split("");//         ；
     ary.sort(function (a, b) {
         return a.localeCompare(b);
     });//sort  ，    a-z     ；
     var str2=ary.join("");//         ；
     //   str2 "aaaaaabbbbBBcccCCCdddDDEEIIJJJLLL";
     //   ：      ，  replace  
     var reg=/(\w)\1+/gi;
     //  ：           ，         ，"+"          ，"g"        ，"i"       ；
     var max=0;
     var maxStr="";
     str2.replace(reg,function ($1,$2) {
         //  ，     ，          ，          ；
         //$1              ，$2         
         //   ，     ；
         if($1.length>max){
             max=$1.length;
             maxStr=$2;
         }else if($1.length==max){
             maxStr+=" "+$2;
         }
     });
     console.log("         "+max+" ");//   ：         6 
     console.log("          :"+maxStr);//   ：          :a b c
 </script>
</code></pre> </li> 
 </ul> 
 <h3>8.   urlParse()  </h3> 
 <ul> 
  <li>  ：    ，           ，           </li> 
  <li>   ： 
   <ul> 
    <li>               ；</li> 
    <li>     <code>var reg=/([^?=&]+)=([^?=&]+)/g;</code>  ："[^?=&]"      ?,=,&     ，"+"  ，"="      ；</li> 
    <li>    ：  ，    ，this         ，             ；  ，             ，               ；</li> 
   </ul> </li> 
 </ul> 
 <pre><code> <script>
     //  ：    ，           ，           
     //  ：       ，  replace  ，          ，           ，            ；
     var str="https://baike.baidu.com/pic/%E6%9C%B4%E4%BF%A1%E6%83%A0/3420577/0/e61190ef76c6a7eff1edd899f5faaf51f2de6641?fr=lemma&ct=single&pic=e61";
     //          ，      ；
     //    ：           
     String.prototype.urlParse=function () {
         //this  str
         var reg=/([^?=&]+)=([^?=&]+)/g;
         //  ："[^?=&]"      ?,=,&     ，"+"  ，"="      
         var obj={};
         this.replace(reg,function($0,$1,$2){
             obj[$1]=$2;
         });
         return obj;//       ，         ，          ，        ；
     };
     var obj=str.urlParse();
     console.log(obj);//   ：{fr: "lemma", ct: "single", pic: "e61"}；
 </script>
</code></pre> 
 <h3>9.        formatDate()  </h3> 
 <ul> 
  <li>        ：<code>var str="2018-08-22 20:35:56"</code>,           ，       
   <ul> 
    <li>    ： 
     <ul> 
      <li>  ：      ，        ，     ，        ，    replace           ，      call    arguments        ，      ，      ；</li> 
     </ul> <pre><code> <script>
     var str="2018-08-22 20:35:56";
     var reg=/^(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})$/;
     var ary;
     str.replace(reg,function(){
         ary=Array.prototype.slice.call(arguments,1,arguments.length-2);
     });
     console.log(ary);//   ：["2018", "08", "22", "20", "35", "56"]
 </script>
</code></pre> </li> 
    <li>match   
     <ul> 
      <li>  ：      ，           ；</li> 
     </ul> <pre><code> <script>
     var str="2018-08-22 20:35:56";
     var reg=/\d+/g;
     var ary=str.match(reg);
     console.log(ary);//   ：["2018", "08", "22", "20", "35", "56"]
 </script>
</code></pre> </li> 
    <li>split   
     <ul> 
      <li>  ：      ，         ；</li> 
     </ul> <pre><code> <script>
     var str="2018-08-22 20:35:56";
     var reg=/[^\d]+/g;//        ；
     var ary=str.split(reg);
     console.log(ary);//   ：["2018", "08", "22", "20", "35", "56"]
 </script>
</code></pre> </li> 
   </ul> </li> 
  <li>      ，       ； 
   <ul> 
    <li>  ：                    ，           ，        ，    ；</li> 
   </ul> <pre><code> <script>
     var str="2018-08-22 20:35:56";
     var strTemplate="{0} {1} {2}  {3} {4} {5} ";
     var reg=/\d+/g;
     var ary=str.match(reg);
     var reg2=/{(\d)}/g;
     var str2=strTemplate.replace(reg2,function ($0, $1) {
          return ary[$1];
     });
     console.log(str2);//   ：2018 08 22  20 35 56 
 </script>
</code></pre> </li> 
  <li>       formatDate()   <pre><code> <script>
     var str="2018-8-22 20:35:56";
     //var strTemplate="{0} {1} {2}  {3} {4} {5} ";   strTemplate     ，        ，    ；
     //         ；
     String.prototype.formatDate=function(template){
         template=template || "{0} {1} {2}  {3} {4} {5} ";
         //  ：      ，template     ，      ，  template undefined， template         ；
         var ary=this.match(/\d+/g);
         var reg=/{(\d)}/g;
         var rem=template.replace(reg,function ($0, $1) {
             return ary[$1];
         });
         return rem;//           ，  this，      this；
     };
     var res=str.formatDate();
     console.log(res);//   ：2018 8 22  20 35 56 
     var res2=str.formatDate("{0} {1} {2} ");
     console.log(res2);//   ：2018 8 22 
     var res3=str.formatDate("{3} {4} {5} ");
     console.log(res3);//   ：20 35 56 
 </script>
</code></pre> </li> 
 </ul> 
 <h3>10.      </h3> 
 <h4>10.1 "||" "&&"   </h4> 
 <ul> 
  <li>   ： 
   <ul> 
    <li>  <code>a || b</code> ， a  ，  b； a  ，  a；</li> 
    <li>  <code>a && b</code> ， a  ，  b； a  ，  a；</li> 
   </ul> </li> 
  <li>  ： <pre><code> <script>
     //   1："||"         
     var temp="tiankong";
     var mm=temp||"meihao";
     console.log(mm);//   ："tiankong"
     var temp1=false;//   undefined，    ；
     var mm1=temp1||"meihao";
     console.log(mm1);//   ："meihao"
     var temp2;
     var ttn=null;
     var mm2=temp2||ttn;
     console.log(mm2);//   ："null"；
     //  ：  ：  a || b  ，1）  a  ，     b，      a   ，   true，  a   ;2）  a  ，   b，      b   ，b    ，     ，     b;（   false,undefind，null）；
 
     //   2："&&"         
     var xmp="tiankong";
     var nn=xmp && "meihao";
     console.log(nn);//   ："meihao"；
 
     var xmp1="tiankong";
     var xxn;
     var nn1=xmp1 && xxn;
     console.log(nn1);//   ："undefined"；
 
     var xmp2;
     var nn2=xmp2 && "meihao";
     console.log(nn2);//   ："undefined"；
 
     var xmp3;
     var xxn3=null;
     var nn3=xmp3 && xxn3;
     console.log(nn3);//   ："undefined"；
 
     var xmp4=(4==5);
     var nn4=xmp4 && xxn4;
     console.log(nn4);//   ："false"；
     //  ：  a && b  ，1）  a  ，     b，      a   （   false,undefind，null）;2）  a  ，   b，      b   ，b    ，     ，     b;
 </script>
</code></pre> </li> 
  <li>    ：     ，"||"           <pre><code> <script>
     var ary=[1,2,3];
     var ary1=[4,5,6];
     function add(arg) {
         //          ，     undefined；
         arg=arg || ary;
         //  ：  arg  ，        ，  arg     ；  arg  ，          ，  arg  ary;
         console.log(arg);
     }
     add();//     ，      ：[1,2,3]；
     add(ary1);//     ，      ：[4,5,6]；
 </script>
</code></pre> </li> 
 </ul> 
 <h4>10.2         </h4> 
 <ul> 
  <li>   ：      ，             ，        ，           ，             ，     ；</li> 
  <li>  ：<code>var reg1=/tiankong(?:\d+)/</code>     <code>(\d+)</code>   ，         ； <pre><code> <script>
     var str="tiankong123";
     var reg=/tiankong(\d+)/;
     console.log(reg.exec(str));//   ：["tiankong123", "123", index: 0, input: "tiankong123", groups: undefined]
     //  ：     ，     ，           ；  "?:";
     var reg1=/tiankong(?:\d+)/;
     console.log(reg1.exec(str));//   ：["tiankong123", index: 0, input: "tiankong123", groups: undefined]
 </script>
</code></pre> </li> 
 </ul> 
 <h4>10.3       </h4> 
 <ul> 
  <li>  </li> 
  <li>     ：<code>/^(18|19)$/</code>;  18 19； <pre><code> <script>
      //  ：  18 19
      var reg=/^18|19$/;//  ：1 8 1 9， 1  ， 9  ；
      console.log(reg.test("18219"));//   true;
      console.log(reg.test("119"));//   true;
      //  ：   |         ；
      //    ：
      var reg1=/^(18|19)$/;
      console.log(reg1.test("189"));//   false;
      console.log(reg1.test("18"));//   true;
 </script>
</code></pre> </li> 
  <li>   ：     </li> 
  <li>   ：      ，      <code>?:</code>； <pre><code> <script>
     var str="tiankong123";
     var reg=/tiankong(\d+)/;
     console.log(reg.exec(str));//   ：["tiankong123", "123", index: 0, input: "tiankong123", groups: undefined]
     //  ：     ，     ，           ；  "?:";
     var reg1=/tiankong(?:\d+)/;
     console.log(reg1.exec(str));//   ：["tiankong123", index: 0, input: "tiankong123", groups: undefined]
 </script>
</code></pre> </li> 
  <li>  ：               <code>(</code> <code>)</code>        ""; <pre><code> <script>
     var str="alpha(opacity:10)";
     var reg=/alpha\(opacity:10\)/;//          ，      ；
     console.log(reg.test(str));//   ：true;
 </script>
</code></pre> </li> 
 </ul> 
 <h4>10.4       </h4> 
 <ul> 
  <li>           ；      ； <pre><code> <script>
      //[abc]   abc      ；      ；
      var reg=/^[11-89]$/;//  ：1 1-8 9，        
      console.log(reg.test("1"));//   true;
      console.log(reg.test("6"));//   true;6 1-8  ；
      console.log(reg.test("11"));//   false;11      ；
 </script>
</code></pre> </li> 
  <li>   []            ，     
   <ul> 
    <li> "+","."     ，   ，   ；       ；                   ，      ； 
     <ul> 
      <li>  1：<code>[+-]</code>   + -，      ；       + ，      ，        ；</li> 
      <li>  2：<code>(\+|-)</code>   + -，      ；        +        ；        ；</li> 
     </ul> </li> 
    <li> "\w","\s","\d"     ，              ；</li> 
    <li>           ：        ，      ；       ； 
     <ul> 
      <li>   ：<code>[ab]</code>    a,b       ；</li> 
      <li>   ：<code>(a|b)</code>    a,b       ；</li> 
      <li>  ： a，b    ，       ，      ，      ，      ； <code>[1234]</code>      1234          ； <code>(12|34)</code>    12 34；</li> 
      <li>  ：        ，   exec     ，          ；     ；   <code>?:</code>  ；</li> 
     </ul> </li> 
   </ul> </li> 
 </ul> 
 <h4>10.5      "?"     </h4> 
 <ul> 
  <li> <code>0 1</code>:      ；              ； 
   <ul> 
    <li> ：<code>(\.\d+)?)</code>             ；</li> 
   </ul> </li> 
  <li>           ：                
   <ul> 
    <li> ：<code>var reg=/\d+?/g</code>       ，         ，        ，       ；</li> 
   </ul> </li> 
  <li>      ：     ，          <code>?:</code>; 
   <ul> 
    <li> ：<code>var reg1=/tiankong(?:\d+)/</code>      ，    (\d+)  ，      (  )      ；</li> 
   </ul> </li> 
 </ul> 
 <h3>11     callback</h3> 
 <ul> 
  <li>  ：        ，    ，        ，           ；</li> 
  <li>   ： 
   <ul> 
    <li>      this，   window，    call  this  ；</li> 
    <li>callback       ，        ，   father    </li> 
    <li>        </li> 
    <li>        ，           ，         ，       ，       ，        father  ；</li> 
   </ul> <pre><code> <script>
     var obj={};
     function f1(n,m){
         console.log(this+(n+m));
         return "meihao";
     }
     function father(n){
         var ary=[];
         for(var i=0; i<4; i++){
            /* n(2,3);//      ，    ；this window;*/
             n.call(obj,2,3);//        this   obj，      ；
             ary.push(n(2,3));//               ；
         }
         return ary;
     }
     var res=father(f1);//       ，        ，            f1，   f1    ，  father  ， f1       ；
 </script>
</code></pre> </li> 
 </ul> 
 <h3>12   forEach  </h3> 
 <ul> 
  <li>  ：  forEach             ，          ，           ；</li> 
  <li>   ： 
   <ul> 
    <li>forEach         ：callback,thisArg;(         ，      this   );</li> 
    <li>forEach        ，              ，     ；</li> 
    <li>      3   ：item(       ) index(  ) input(    )；</li> 
    <li>forEach         ；</li> 
    <li>     thisArg，     ，       this    window，    ，  this   thisArg ；</li> 
    <li>   ：IE8          ；</li> 
   </ul> <pre><code> <script>
     //  forEach      ：         undefined，  forEach       ；           ，     undefined，    forEach      ，           ；
     var ary=[10,20,30,40,50];
     var obj={};
     var res=ary.forEach(function (item,index,input) {
         console.log(arguments);
         //         ，         ：[10, 0, Array(5)]，  forEach     ；
     },obj);
     console.log(res);//   ：undefined;  forEach     ；
 </script>
</code></pre> </li> 
 </ul> 
 <h3>13         ForEach  </h3> 
 <ul> 
  <li>   ： 
   <ul> 
    <li>             ：            forEach  ， in  ；</li> 
    <li>    ：         ，       ，      ；</li> 
   </ul> </li> 
  <li>    ： 
   <ul> 
    <li>    ，          </li> 
    <li>      ，  forEach  ，        ，           ；</li> 
    <li>     ，      ，      ，       </li> 
    <li>forEach               ，               ，    thisArg ，         ，   this  ；</li> 
    <li>forEach   ，       ，         ，   ：item     ，index         ， input    ；</li> 
    <li>forEach         ；</li> 
   </ul> <pre><code> <script>
     //  ：  forEach         ， ary      
     var ary=[10,20,30,40,50];
     //       ，     ：                  forEach  ；   in     ，a in b    a   b   
     //          
     Array.prototype.ForEach=function (callback,thisarg) {
         thisarg=thisarg || window;//   ：      ， thisarg     ，        ，  thisarg window;  window   ；
         //  this      ary;
         //1）       ,           ；
         if("forEach" in Array.prototype){
             this.forEach(callback,thisarg);
           //Array.prototype.forEach.call(this,callback,thisarg);        ；
             return;//      ；      ；
         }
         //2）            
         //        ，            ，   thisArg;
         //     ，             ，            ；
        for(var i=0; i<this.length; i++) {
            callback.call(thisarg, this[i], i, this);
            //     ，       return；
        }
     };
     function fn(item,index,input) {
          console.log(arguments);
     }
     ary.ForEach(fn);
 </script>
</code></pre> </li> 
 </ul> 
 <h3>14   map  </h3> 
 <ul> 
  <li>  ：  map       forEach    ，      ，        ，      this  ，        ，map      ，        ，                  ；</li> 
  <li>   ： 
   <ul> 
    <li>map        ，     ，        ，                ；</li> 
    <li>map        forEach    ；</li> 
    <li>map  ：IE8          ；</li> 
   </ul> <pre><code> <script>
     var ary=[10,20,30,40,50];
     var res=ary.map(function (item, index, input) {
         return item+index;
     });
     console.log(res);//   ：[10, 21, 32, 43, 54]
 </script>
</code></pre> </li> 
 </ul> 
 <h3>15         Map  </h3> 
 <ul> 
  <li>   ： 
   <ul> 
    <li> forEach     ,map       ;</li> 
   </ul> <pre><code> <script>
     var ary=[10,20,30,40,50];
     //               
     Array.prototype.Map=function (callback, thisarg) {
         thisarg=thisarg || window;
         if("map" in Array.prototype){
             return this.map(callback,thisarg);
         }
         var ary1=[];
         for(var i=0; i<this.length; i++){
             var rem=callback.call(thisarg,this[i],i,this);
             ary1.push(rem);
         }
         return ary1;
     };
     function fn($1,$2) {
         return $1*$2;
     }
     var res=ary.Map(fn);
     console.log(res);//   ：[0, 20, 60, 120, 200]
 </script>
</code></pre> </li> 
 </ul> 
</article>
                            </div>
                        </div>

이 내용에 흥미가 있습니까?

현재 기사가 여러분의 문제를 해결하지 못하는 경우 AI 엔진은 머신러닝 분석(스마트 모델이 방금 만들어져 부정확한 경우가 있을 수 있음)을 통해 가장 유사한 기사를 추천합니다:

다양한 언어의 JSON

JSON은 Javascript 표기법을 사용하여 데이터 구조를 레이아웃하는 데이터 형식입니다. 그러나 Javascript가 코드에서 이러한 구조를 나타낼 수 있는 유일한 언어는 아닙니다. 저는 일반적으로 '객체'{}...

텍스트를 자유롭게 공유하거나 복사할 수 있습니다.하지만 이 문서의 URL은 참조 URL로 남겨 두십시오.

CC BY-SA 2.5, CC BY-SA 3.0 및 CC BY-SA 4.0에 따라 라이센스가 부여됩니다.

제6 주 넷 째 날 필기

좋은 웹페이지 즐겨찾기