Javascript算法练习（三）

最新推荐文章于 2021-07-29 08:00:00 发布

若叶岂知秋vip

最新推荐文章于 2021-07-29 08:00:00 发布

阅读量653

点赞数

分类专栏： Javascript 数据结构文章标签： javascript 算法 slice

本文链接：https://blog.csdn.net/gccll/article/details/51765611

版权

Javascript 同时被 2 个专栏收录

41 篇文章 1 订阅

订阅专栏

数据结构

7 篇文章 0 订阅

订阅专栏

Javascript算法练习（三）

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

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

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

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!