Javascript算法练习（三）

Javascript算法练习（三）

判断一段字符串是否是以指定字符串结尾

1. Javascript原生方法：string.endWith( sTarget, iLen ), 参数sTarget: 指定的结尾字符串；iLen: 假设整个字符串的长度，即限定字符串的长度。

   // -----------  原生JS方法：endsWith();
   // 判断一段字符串是否以指定字符串结尾
   console.log( "Hello world! This is Javascript Method endsWith()".endsWith( "endsWith()" ) );        // true
   // 截取第二个参数指定的字符串长度，再进行判断
   // 下面一句相当于："Hello world!".endsWith( "endWith() ");
   console.log( "Hello world! This is Javascript Method endsWith()".endsWith( "endsWith()", 12 ) );    // false
   console.log( "Hello world! This is Javascript Method endsWith()".endsWith( "world!", 12 ) );        // true
   

2. 将一段字符串转成字符串数组，取得数组中最后一个元素，和目标字符串比较得出结果（兼容头尾有空格的情况）

   function myEndsWith( srcStr, dstStr ) {
   
       if ( !srcStr ) return "Null source string!";
       // 去除字符串头尾的空格
       var aSrc    = srcStr.replace(/(^\s*)|(\s*$)/g, "").split(" "),
           sLast   = aSrc[ aSrc.length - 1 ],  // 取出最后一个字符串元素
           sSub    = "";       // 保存从sLast中取到的和dstStr相关的子串 
   
       if ( sLast.length < dstStr.length ) return false;
       // -------------------------- substring ---------------------------------
       // substring( startIndex [, endIndex ] )，
       // 1. 找出子字符串，从startIndex开始到endIndex结束, 但是不包括endIndex所在的字符
       // 如果 startIndex > endIndex，则在查找之前会先将两个数值交换之后在查找
       // 即：substring( 3, 10 ) == substring( 10, 3 );
       // 2. 当 startIndex < 0 时会被当做 0 处理；当 endIndex > str.length 时，endIndex = str.length;
       // sSub = sLast.substring( sLast.length - dstStr.length, sLast.length );
   
       // -------------------------- substr ---------------------------------
       // substr( startIndex [, length ] );
       // 1. startIndex 子串开始位置，< 0 时，从结尾处开始算，往后取length长子串
       // 如："hello".substr( -2, 2 ); 即取最后两个字符"lo"，此时第二个参数length可以省略
       // 2. 需要注意点：（不建议使用，可用 substring 和 slice 代替）
       // 重要事项：ECMAscript 没有对该方法进行标准化，因此反对使用它。
       // 重要事项：在 IE 4 中，参数 start 的值无效。在这个 BUG 中，start 规定的是第 0 个字符的位置。在之后的版本中，此 BUG 已被修正。
       sSub = sLast.substr( - dstStr.length);
       // 或者 sSub = sLast.substr( - dstStr.length, dstStr.length );
   
       console.log( sSub + dstStr.length );
       return sSub == dstStr ? true : false;
   }
   console.log( myEndsWith( "Hello world! This is Javascript Method endsWith()", "world!" ) ); // false
   console.log( myEndsWith( "Hello world! This is Javascript Method endsWith()", "endsWith()" ) ); // true
   console.log( myEndsWith( "Hello world! This is Javascript Method endsWith()    ", "With()" ) ); // true

将一个字符串复制指定次数到自身返回

如：hello复制三次：hello -> hellohellohello

• 通过用 “+” 操作符直接连接字符串

  function repeatStringNumTimes__1( _targetStr, _num ) {
      var sTmp = "";
  
      if ( _num <= 0 || !_targetStr ) return "";
  
      var t1 = new Date().getTime();
      for ( var i = 0; i < _num; i++ ) {
          sTmp += _targetStr;
      }
  
      var used = new Date().getTime() - t1;
  
      console.log("t1 = " + t1 + ", used = " + used);
  
      return sTmp;
  } 

• 通过数组 + join方法

  function repeatStringNumTimes__2( _targetStr, _num ) {
      var aStr = [];
  
      var t1 = new Date().getTime();
      for ( var i = 0; i < _num; i++ ) {
          aStr.push( _targetStr );
      }
      var used = new Date().getTime() - t1;
  
      console.log("t1 = " + t1 + ", used = " + used);
  
      return aStr.join("");
  }

• 上述两种方法耗时对比结果

  repeatStringNumTimes__1( "hello", 100000 );
  repeatStringNumTimes__2( "hello", 100000 );
  
  // 不知道为啥对比了 1,000 & 10,000 & 100,000 & 1,000,000次两个结果每次都会变
  // 并且有时候方法一时间长，有时候方法二时间长，不知何故？？？？？
  // 看下结果吧：（整的chrome都不行了，也没看出哪个快慢，惨~~~~~）
  // 1,000    : 基本不耗时间，都在 0 - 1 ms之间
  // 10,000   : 同上，0 - 3 ms之间
  // 100,000: 10ms内徘徊
  // 1,000,000: 30 - 105 ms之间
  // 10,000,000: 300 - 500 ms之间
  // 100,000,000: (⊙﹏⊙)b 会不会死机o(╯□╰)o！！！！
  // 果然，O(∩_∩)O哈哈~，我去，一晃三点了都，苦逼的明天要加班，睡觉哦~~~~~！

截取字符串，然后加上后缀

• 方法：function truncateString__1 ( __str, __num )；

几种情况分析：

• 参数不合法判断：return “Invalid Arguments!”;
• __num === 0 ， 直接返回__str;
• __num长度，小于等于后缀的长度
  
  1. __num小于原字符串长度，截取__num个加上后缀返回;
  2. __num大于等于原字符串长度，直接返回原字符串；

• __num长度，大于后缀长度

  1. __num大于等于原字符串长度，直接返回原字符串；
  2. __num小于原字符串长度，截取__num - 后缀长度，加上后缀返回

• 代码实现如下：

  function truncateString__1 ( __str, __num ) {
  
      if ( !__str || __num < 0) return "Invalid Arguments !";
  
      // 所截取的长度为0，直接返回源字符串
      if ( __num === 0 ) return __str;
  
      var iLen        = __str.length,
          sSuffix     = "...",
          iSuffixLen  = sSuffix.length;
  
      if ( __num <= iSuffixLen ) {        // 1. 截取长度小于或等于后缀长度
          if ( iLen <= __num ) {      // 1.1 字符串长度小于截取长度，直接返回原字符串
              return __str;
          } else {    // 1.2 字符串长度大于截取的长度，但是截取的长度却小于后缀长度，直接截取__num个，再加上后缀返回
              return __str.slice(0, __num) + sSuffix;
          }
      } else {    // 2. 截取长度大于后缀长度
          if ( __num >= iLen ) {  // 2.1 只要传入的长度大于原字符串长度，直接返回原字符串
              return __str;
          } else { // 2.2 __num减去后缀长度
              return __str.slice(0, __num - iSuffixLen) + sSuffix;
          }
      }
  }
  
  console.log( truncateString__1("A$", 3) );
  console.log( truncateString__1("A$", 1) );
  console.log( truncateString__1("A-CCLL!", 6) );
  console.log( truncateString__1("A-CCLL!", 10) );
  console.log( truncateString__1("A-CCLL!", 8) );
  
  // result:
  algorithm-03.htm:82 A$
  algorithm-03.htm:83 A...
  algorithm-03.htm:84 A-C...
  algorithm-03.htm:85 A-CCLL!
  algorithm-03.htm:86 A-CCLL! 

• 知识点
  
  1. 截取+后缀的情况分析；
  2. slice(begin, end)方法的使用；