js中關於string的一些經常使用的方法

最近總結了一些關於string中的經常使用方法，

其中大部分的方法來自於《JavaScript框架設計》這本書，

若是有更好的方法，或者有關於string的別的經常使用的方法，但願你們不吝賜教。

第一部分

字符串中查找，

包括一個字符串是否在另外一個字符串內部，是否在開始之處，是否在結尾之處。

 1 /**
 2  * 判斷一個字符串是否包含另外一個字符串
 3  * @param target
 4  * @param it
 5  * @returns {boolean}
 6  */
 7 function contains(target,it) {
 8     return target.indexOf(it) !== -1;
 9 }
10 
11 /**
12  * 斷定目標字符串是否位於原字符串的開始之處
13  * @param target
14  * @param str
15  * @param ignoreCase 是否忽略大小寫
16  * @returns {boolean}
17  */
18 function startWith(target,str,ignoreCase) {
19     const startStr = target.substr(0,str.length);
20     return ignoreCase ? startStr.toLocaleLowerCase() === str.toLocaleLowerCase() :
21     startStr === str;
22 }
23 
24 /**
25  * 斷定目標字符串是否位於原字符串的結束之處
26  * @param target
27  * @param str
28  * @param ignoreCase 是否忽略大小寫
29  * @returns {boolean}
30  */
31 function endWith(target,str,ignoreCase) {
32     const startStr = target.substr(target.length - str.length);
33     return ignoreCase ? startStr.toLocaleLowerCase() === str.toLocaleLowerCase() :
34     startStr === str;
35 }

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,'&#39;');
}

第五部分

字符串填充，

將特定的字符串填充到另外一個字符串中，使得目標字符串獲得相應的長度，包括向前填充和向後填充。

/**
 * 獲取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');
}