js中关于string的一些常用的方法

最近总结了一些关于string中的常用方法，

其中大部分的方法来自于《JavaScript框架设计》这本书，

如果有更好的方法，或者有关于string的别的常用的方法，希望大家不吝赐教。

第一部分

字符串中查找，

包括一个字符串是否在另一个字符串内部，是否在开始之处，是否在结尾之处。

 /**
  * 判断一个字符串是否包含另一个字符串
  * @param target
  * @param it
  * @returns {boolean}
  */
 function contains(target,it) {
     return target.indexOf(it) !== -1;
 }
 
 /**
  * 判定目标字符串是否位于原字符串的开始之处
  * @param target
  * @param str
  * @param ignoreCase 是否忽略大小写
  * @returns {boolean}
  */
 function startWith(target,str,ignoreCase) {
     const startStr = target.substr(0,str.length);
     return ignoreCase ? startStr.toLocaleLowerCase() === str.toLocaleLowerCase() :
     startStr === str;
 }
 
 /**
  * 判定目标字符串是否位于原字符串的结束之处
  * @param target
  * @param str
  * @param ignoreCase 是否忽略大小写
  * @returns {boolean}
  */
 function endWith(target,str,ignoreCase) {
     const startStr = target.substr(target.length - str.length);
     return ignoreCase ? startStr.toLocaleLowerCase() === str.toLocaleLowerCase() :
     startStr === str;
 }

es6方法：

includes()：返回布尔值，表示是否找到了参数字符串。

startsWith()：返回布尔值，表示参数字符串是否在源字符串的头部。

endsWith()：返回布尔值，表示参数字符串是否在源字符串的尾部。

const s = 'hello world!';
console.log(s.startsWith('hello')); // true
console.log(s.endsWith('!'));  // true
console.log(s.includes('o'));  // true
 
// 这三个方法都支持第二个参数，表示开始搜索的位置
console.log(s.startsWith('world', 6)); // true
console.log(s.endsWith('hello', 5));  // true
console.log(s.includes('hello', 6));  // false

第二部分

字符串重复，

将一个字符串重复n次后返回

/**
 * 重复字符串
 * @param target    目标字符串
 * @param n         次数
 * @returns {string}
 */
function repeat(target,n) {
    return (new Array(n + 1)).join(target);
}
 
function repeat2(target,n) {
    return Array.prototype.join.call({
        length: n + 1
    },target);
}
 
function repeat3(target,n) {
    let s = target,total = [];
    while (n > 0) {
        if (n % 2 == 1) {
            // 如果是奇数
            total[total.length] = s;
        }
        if (n === 1) {
            break;
        }
        s += s;
        // 将n除以2取其商，或说开二次方
        n = n >> 1;
    }
    return total.join('');
}
 
function repeat4(target,n) {
    if (n === 1) {
        return target;
    }
    let s = this.repeat4(target,Math.floor(n / 2));
    s += s;
    if (n % 2) {
        s += target;
    }
    return s;
}
 
function repeat5(target,n) {
    let s = target,c = s.length * n;
    do {
        s += s;
    } while (n = n >> 1);
    // 这样省去了判断奇偶数
    s = s.substring(0,c);
    return s;
}
 
/**
 * 各个浏览器得分最好的
 * @param target
 * @param n
 * @returns {string}
 */
function repeat6(target,n) {
    let s = target,total = '';
    while ( n > 0) {
        if (n % 2 === 1) {
            total += s;
        }
        if (n === 1) {
            break;
        }
        s += s;
        n = n >> 1;
    }
    return total;
}

es6方法：

repeat()方法返回一个新字符串，表示将原字符串重复n次。

第三部分

字符串长度，

获取一个字符串的字节长度，并支持定制汉字的存储字节数

/**
 *  取得一个字符串所有字节的长度
 * @param target
 * @returns {number}
 */
function byteLen(target) {
    let byteLength = target.length,i = 0;
    for(;i < target.length; i++) {
        if (target.charCodeAt(i) > 255) {
            byteLength++;
        }
    }
    return byteLength;
}
 
/**
 * 使用正则，并支持定制汉字的存储字节数
 * @param target
 * @param fix
 * @returns {Number}
 */
function byteLen2(target,fix) {
    fix = fix ? fix : 2;
    const str = new Array(fix + 1).join('-');
    return target.replace(/[^\x00-\xff]/g,str).length;
}

第四部分

字符串替换，

包括字符串截取替换，移除html中的一些标签，替换字符串中对HTML不安全的标签

/**
 * 对字符串进行截断处理，当超过限定长度，默认添加三个点号或其他什么的
 * @param target
 * @param length
 * @param truncation
 * @returns {string}
 */
function truncate(target,length,truncation) {
    length = length || 30;
    truncation = truncation === void(0) ? '...' : truncation;
    return target.length > length ?
    target.slice(0,length - truncation.length) + truncation : String(target);
}
 
/**
 * 移除字符串中的HTML标签
 * @param target
 * @returns {string}
 */
function stripTags(target) {
    return String(target || '').replace(/<[^>]+>/g,'');
}
 
/**
 * 移除字符串中所有的script标签
 * @param target
 * @returns {string}
 */
function stripScripts(target) {
    return String(target || '').replace(/<script[^>]*>([\S\s*?])<\/script>/img,'');
}
 
/**
 * 将字符串经过HTML转义得到适合在页面显示的内容
 * @param target
 * @returns {string|XML}
 */
function escapeHTML(target) {
    return target.replace(/&/g,'&amp;')
        .replace(/</g,'&lt;')
        .replace(/>/g,'&gt;')
        .replace(/' '/g,'&quot;')
        .replace(/'/g,''');
}

第五部分

字符串填充，

将特定的字符串填充到另一个字符串中，使得目标字符串得到相应的长度，包括向前填充和向后填充。

/**
 * 获取n位数，不够的前面补0
 * @param target
 * @param n  位数
 * @returns {string}
 */
function pad(target,n) {
    const zero = new Array(n).join('0');
    const str = zero + target;
    return str.substr(-n);
}
 
function pad2(target,n) {
    let len = target.toString().length;
    while (len < n) {
        target = '0' + target;
        len++;
    }
    return target;
}
 
/**
 * 支持多种填充，并可以选择填充的位置（前面或后面）
 * @param target
 * @param n
 * @param filling
 * @param right
 * @param radix
 * @returns {string}
 */
function pad8(target,n,filling,right,radix) {
    var num  = target.toString(radix || 10);
    filling = filling || '0';
    while (num.length < n) {
        if (!right) {
            num = filling + num;
        } else {
            num += filling;
        }
    }
    return num;
}

es6方法：

padStart()用于头部补全，padEnd()用于尾部补全。

第六部分

清除字符串前后的空格，

/**
 * 去除字符串前后的空格
 * @param str
 * @returns {string|XML}
 */
function trim(str) {
    return str.replace(/^\s\s*/,'').replace(/\s\s*$/,'');
}
 
function trim2(str) {
    return str.replace(/^\s+/,'').replace(/\s+$/,'');
}
 
function trim3(str) {
    return str.substring(Math.max(str.search(/\S/),0),
        str.search(/\S\s*$/) + 1);
}
 
function trim4(str) {
    return str.replace(/^\s+|\s+$/g,'');
}
 
function trim5(str) {
    str = str.match(/\S+(?:\s+\S+)*/);
    return str ? str[0] : '';
}
 
function trim6(str) {
    return str.replace(/^\s*(\S*(\s\S+)*)\s*$/,'$1');
}
 
function trim7(str) {
    return str.replace(/^\s*(\S*(?:\s+\S+)*)\s*$/,'$1');
}
 
function trim8(str) {
    return str.replace(/^\s*((?:[\S\s]*\S)?)\s*$/,'$1');
}