概要：整理出字符串常用的一些方法
|
1 2 3 4 5 6 |
字符串的截取 字符串的查找 字符串的拼接 字符串转数组 字符串的替换 字符串的相关 |
字符串的截取 – substr( ) | substring( ) | slice( )
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
定义和用法： substr() 方法可在字符串中抽取从 start 下标开始的指定数目的字符 语法：str.substr(start,length) start： 开始提取字符的位置。 如果为负值，则被看作 strLength + start， 其中 strLength 为字符串的长度（例如，如果 start 为 -3，则被看作 strLength + (-3)） length：可选。提取的字符数。必须是数值。 如果省略了该参数，那么返回从 str 的开始位置到结尾的字串。 描述： start 是一个字符的索引。首字符的索引为 0，最后一个字符的索引为 字符串的长度减去1。 substr 从 start 位置开始提取字符，提取 length 个字符（或直到字符串的末尾）。 如果 start 为正值，且大于或等于字符串的长度，则 substr 返回一个空字符串。 如果 start 为负值，则 substr 把它作为从字符串末尾开始的一个字符索引。 如果 start 为负值且 abs(start) 大于字符串的长度，则 substr 使用 0 作为开始提取的索引。 如果 length 为 0 或负值，则 substr 返回一个空字符串。如果忽略 length，则 substr 提取字符，直到字符串末尾。 |
|
1 2 3 4 5 6 7 |
var str = "abcdefghij"; console.log("(1,2): " + str.substr(1,2)); // (1,2): bc console.log("(-3,2): " + str.substr(-3,2)); // (-3,2): hi console.log("(-3): " + str.substr(-3)); // (-3): hij console.log("(1): " + str.substr(1)); // (1): bcdefghij console.log("(-20, 2): " + str.substr(-20,2)); // (-20, 2): ab console.log("(20, 2): " + str.substr(20,2)); // (20, 2): |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
定义和用法 ： substring() 方法返回一个字符串在开始索引到结束索引之间的一个子集, 或从开始索引直到字符串的末尾的一个子集 语法： str.substring(indexStart,indexEnd) indexStart：一个 0 到字符串长度之间的整数。 indexEnd：可选。一个 0 到字符串长度之间的整数。 返回值：包含给定字符串的指定部分的新字符串。 描述: substring 提取从 indexStart 到 indexEnd（不包括）之间的字符，特别地： 如果 indexStart 等于 indexEnd，substring 返回一个空字符串。 如果省略 indexEnd，substring 提取字符一直到字符串末尾。 如果任一参数小于 0 或为 NaN，则被当作 0。 如果任一参数大于 stringName.length，则被当作 stringName.length。 如果 indexStart 大于 indexEnd，则 substring 的执行效果就像两个参数调换了一样。见下面的例子。 |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
var anyString = "Mozilla"; // 输出 "Moz" console.log(anyString.substring(0,3)); console.log(anyString.substring(3,0)); console.log(anyString.substring(3,-3)); console.log(anyString.substring(3,NaN)); console.log(anyString.substring(-2,3)); console.log(anyString.substring(NaN,3)); // 输出 "lla" console.log(anyString.substring(4,7)); console.log(anyString.substring(7,4)); // 输出 "" console.log(anyString.substring(4,4)); // 输出 "Mozill" console.log(anyString.substring(0,6)); // 输出 "Mozilla" console.log(anyString.substring(0,7)); console.log(anyString.substring(0,10)); |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
定义和用法 ： slice() 方法提取一个字符串的一部分，并返回一新的字符串。 语法： str.slice(beginSlice, endSlice) beginSlice： 从该索引（以 0 为基数）处开始提取原字符串中的字符。 如果值为负数，会被当做 sourceLength + beginSlice 看待， 这里的sourceLength 是字符串的长度 (例如,如果beginSlice 是-3则看作是: sourceLength - 3) endSlice： 可选。在该索引（以 0 为基数）处结束提取字符串。如果省略该参数，slice会一直提取到字符串末尾。 如果该参数为负数，则被看作是 sourceLength + endSlice， 这里的 sourceLength 就是字符串的长度(例如，如果 endSlice 是 -3，则是, sourceLength - 3)。 返回值：返回一个从原字符串中提取出来的新字符串 描述: slice() 从一个字符串中提取字符串并返回新字符串。在一个字符串中的改变不会影响另一个字符串。 也就是说，slice 不修改原字符串，只会返回一个包含了原字符串中部分字符的新字符串 注意：slice() 提取的新字符串包括beginSlice但不包括 endSlice。 |
|
1 2 3 4 5 6 |
var str1 = 'The morning is upon us.'; var str2 = str1.slice(4, -2); console.log(str2); // OUTPUT: morning is upon u str.slice(-3); // returns 'us.' str.slice(-3, -1); // returns 'us' str.slice(0, -1); // returns 'The morning is upon us' |
字符串的查找
|
1 2 3 4 5 6 7 8 9 10 11 |
索引找字符 概述: charAt() 方法从一个字符串中返回指定的字符。 语法: str.charAt(index) index: 一个介于0 和字符串长度减1之间的整数,(0~length-1)如果没有提供索引，charAt() 将使用0。 描述: 字符串中的字符从左向右索引，第一个字符的索引值为 0， 最后一个字符（假设该字符位于字符串 stringName 中）的索引值为 stringName.length - 1。 如果指定的 index 值超出了该范围，则返回一个空字符串。 |
|
1 2 3 4 5 6 7 8 |
var str = "Brave new world"; console.log(str.charAt());//'B' console.log(str.charAt(0));//'B' console.log(str.charAt(1));//'r' console.log(str.charAt(2));//a console.log(str.charAt(3));//'v' console.log(str.charAt(4));//'e' console.log(str.charAt(999));//'' |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
字符找索引 概述: indexOf()方法返回调用 String 对象中第一次出现的指定值的索引，开始在 fromIndex进行搜索。 如果未找到该值，则返回-1。 语法: str.indexOf(searchValue,fromIndex) searchValue： 一个字符串表示被查找的值。 fromIndex:可选;表示调用该方法的字符串中开始查找的位置。可以是任意整数。默认值为 0 返回值:指定值的第一次出现的索引; 如果没有找到 -1。 描述: 字符串中的字符被从左向右索引。 首字符的索引（index）为 0，字符串 stringName 的最后一个字符的索引是 stringName.length - 1。 如果 fromIndex < 0 则查找整个字符串（如同传进了 0）。 如果 fromIndex >= str.length，则该方法返回 -1，除非被查找的字符串是一个空字符串， 此时返回 str.length。 |
|
1 2 3 4 5 6 7 8 9 |
var str ="Blue Whale"; console.log(str.indexOf("Blue")); // 0 console.log(str.indexOf("Blute")); // -1 console.log(str.indexOf("Whale", 0)); // 5 console.log(str.indexOf("Whale", 5)); // 5 console.log(str.indexOf("", 9)); // 9 console.log(str.indexOf("", 10)); // 10 console.log(str.indexOf("", 11)); // 10 //lastIndexOf()从该字符串的后面向前查找，从 fromIndex 处开始。 |
字符串的拼接
|
1 2 3 4 5 6 |
字符串的拼接性能：优先使用 + += 拼接字符串 概述:concat() 方法将一个或多个字符串与原字符串连接合并，形成一个新的字符串并返回。 语法:str.concat(string2, string3, ..., stringN) string2...stringN:和原字符串连接的多个字符串 描述: concat 方法将一个或多个字符串与原字符串连接合并，形成一个新的字符串并返回。 concat 方法并不影响原字符串。 |
|
1 2 3 |
var str ="ab"; var str1 ="cd"; console.log(str.concat(str1)); // abcd |
字符串转数组
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
概述: split() 方法使用指定的分隔符字符串将一个String对象分割成字符串数组, 以将字符串分隔为子字符串,以确定每个拆分的位置 语法:str.split(separator,limit) separator: 指定表示每个拆分应发生的点的字符串。separator 可以是一个字符串或正则表达式。 如果纯文本分隔符包含多个字符，则必须找到整个字符串来表示分割点。 如果在str中省略或不出现分隔符，则返回的数组包含一个由整个字符串组成的元素。 如果分隔符为空字符串，则将str原字符串中每个字符的数组形式返回。 limit： 一个整数，限定返回的分割片段数量。 当提供此参数时，split 方法会在指定分隔符的每次出现时分割该字符串，但在限制条目已放入数组时停止。 如果在达到指定限制之前达到字符串的末尾，它可能仍然包含少于限制的条目。新数组中不返回剩下的文本。 返回值:返回源字符串以分隔符出现位置分隔而成的一个 Array 描述: 找到分隔符后，将其从字符串中删除，并将子字符串的数组返回。 如果没有找到或者省略了分隔符，则该数组包含一个由整个字符串组成的元素。 如果分隔符为空字符串，则将str转换为字符数组。 如果分隔符出现在字符串的开始或结尾，或两者都分开，分别以空字符串开头，结尾或两者开始和结束。 因此，如果字符串仅由一个分隔符实例组成，则该数组由两个空字符串组成。 |
|
1 2 3 4 5 |
var str ="abcdefg"; console.log(str.split()); // ["abcdefg"] console.log(str.split('')); // "a", "b", "c", "d", "e", "f", "g"] console.log(str.split('d')); // ["abc", "efg"] console.log(str.split('d',1)); // ["abc"] |
字符串的倒置
|
1 2 3 |
var str ="abcdefg"; var reverseStr=str.split('').reverse().join(''); console.log(reverseStr)//gfedcba |
字符串的替换
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 |
概述: replace（）方法返回一个由替换值替换一些或所有匹配的模式后的新字符串。 模式可以是一个字符串或者一个正则表达式, 替换值可以是一个字符串或者一个每次匹配都要调用的函数。 语法:str.replace(regexp|substr, newSubStr|function) regexp (pattern): 一个RegExp 对象或者其字面量。该正则所匹配的内容会被第二个参数的返回值替换掉。 substr (pattern)： 一个要被 newSubStr 替换的字符串。其被视为一整个字符串，而不是一个正则表达式。仅仅是第一个匹配会被替换。 newSubStr (replacement): 用于替换掉第一个参数在原字符串中的匹配部分的字符串。该字符串中可以内插一些特殊的变量名。 参考使用字符串作为参数。 function (replacement): 一个用来创建新子字符串的函数，该函数的返回值将替换掉第一个参数匹配到的结果。 参考指定一个函数作为参数。 返回值:一个部分或全部匹配由替代模式所取代的新的字符串。 描述: 该方法并不改变调用它的字符串本身，而只是返回一个新的替换后的字符串。 在进行全局的搜索替换时，正则表达式需包含 g 标志。 使用字符串作为参数，替换字符串可以插入下面的特殊变量名： 变量名 代表的值 $$ 插入一个 "$"。 $& 插入匹配的子串。 $` 插入当前匹配的子串左边的内容。 $' 插入当前匹配的子串右边的内容。 $n 假如第一个参数是 RegExp对象，并且 n 是个小于100的非负整数，那么插入第 n 个括号匹配的字符串。 |
|
1 2 3 4 |
//一般用法 var str='ABCDAFG'; var newstr=str.replace('A','|') console.log(newstr)//|BCDAFG 只能替换掉第一个 后面的无法替换 |
|
1 2 3 4 |
//全局匹配替换 var str='ABCDAFGa'; var newstr=str.replace(/A/gi,'|') console.log(newstr)// |BCD|FG| 全局替换 |
|
1 2 3 4 5 |
//交换位置 var re = /(\w+)\s(\w+)\s(\w+)/; var str = "John and Smith"; var newstr = str.replace(re, "$3, $2, $1"); console.log(newstr);// Smith, and, John |
|
1 2 3 4 5 6 7 8 9 10 11 |
/*字符串替换-其他方法 替换掉字符串里所有指定的字符串: swtichParse('abc=def=hjk','||') => 'abc||def||hjk' */ var str='abc=def=hjk'; //字符串 var replaceStrting='=';//被替换字符串 var targetString='||';//代替的字符串 function swtichParse(str,replaceStrting,targetString){ return str.split(replaceStrting).join(targetString) } console.log(swtichParse(str,replaceStrting,targetString)) //abc||def||hjk |
字符出现的次数统计
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
var str = 'To be, or not to be, that is the question.'; function totalCount(str){ var count = 0; var pos = str.indexOf('e'); while (pos !== -1) { count++; pos = str.indexOf('e', pos + 1); } return count } function totalCount1(str,searchStr){ return str.split(searchStr).length-1 } console.log(totalCount(str)); // 4 console.log(totalCount1(str,'e')); // 4 这种方法更加简单 博主无意琢磨出来的 嘿嘿 可以随意指定字符 |
获取字符串某个字符串的所有索引值集合
|
1 2 3 4 5 6 7 8 9 10 11 12 |
//getIndexArr(str,'a') = > [0, 7, 11, 16, 20] var str = 'To be, or not to be, that is the question.'; function getIndexArr(str,targetStr){ var indexArr=[]; for(var i=0;i<str.length;i++){ if(str[i]===targetStr){ indexArr.push(i); } } return indexArr; } console.log(getIndexArr(str,'e')); // [4, 18, 31, 35] |
字符串转换成驼峰式写法
|
1 2 3 4 5 6 7 |
var str = "border-left-color"; function swtichHump(str){ return str.replace(/-(\w)/g,function(match,r1){ return r1.toUpperCase() }) } console.log(swtichHump(str))//borderLeftColor |
|
1 2 3 4 5 6 7 8 |
function swtichHump(str){ var arr=str.split('-'); for(var i=1;i<arr.length;i++){ arr[i]=arr[i].charAt(0).toUpperCase()+arr[i].substr(1) } return arr.join('') } console.log(swtichHump(str))//borderLeftColor |
查找字符串中出现最多的字符和个数
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
//查找字符串中出现最多的字符和个数 var str =" fdadffddfdffj"; function more(str){ var obj={},max=0,maxStr; for(var i=0;i<str.length;i++){ if(!obj[str[i]]){ obj[str[i]]=1 }else{ obj[str[i]]+=1 } } for(var k in obj){ if(obj[k]>max){ max=obj[k]; maxStr=k } } return {maxStr:maxStr,maxNum:max} } console.log(more(str))//{maxStr: "f", maxNum: 6} |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
var str ="fdadffddfdffj"; function more(str){ var newArr=str.split('').sort().join(''),max=0,maxStr; newArr.replace(/(\w)\1+/g,function(match,r1){ if(match.length>max){ max=match.length maxStr=r1 } }) return {maxStr: maxStr, maxNum: max} } console.log(more(str))//{maxStr: "f", maxNum: 6} // /(\w)\1+/g:在这个例子里表示匹配到子串并且子串长度大于1 // 成功匹配的match:ddddd ffffff 而a只有一个不满足故没有上榜 // r1是子串里的字母 d f |
如何给字符串加千分符
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 |
//此种方法博主无意琢磨出来的 嘿嘿 觉得思路更加清晰 var str = '123235549949945';//235,549,949,945 function thousands(str){ var len=str.length; if(len<3)return str; //是否刚好被3除尽 var isDiv=len%3==0 //可以几等分 var iNum=parseInt(len/3) //不能均等分时 前面的位数 可能是1位或2位 var frontNum=len%3 var arr=[]; if(isDiv){//刚好被3除尽 for(var i=0;i<len;i++){ if(i%3==0){ arr.push(str.slice(i,i+3)) } } return arr.join(',') }else{//被3除不尽 var firstStr=str.substr(0,frontNum) var secoundStr=str.substr(frontNum) for(var i=0;i<secoundStr.length;i++){ if(i%3==0){ arr.push(secoundStr.slice(i,i+3)) } } return firstStr+','+arr.join(',') } } console.log(thousands(str)); |
|
1 2 3 4 5 6 |
var str = '235549949945'; function test(str){ var reg =/(?=(?!\b)(\d{3})+$)/g; return str.replace(reg,',') } console.log(test(str)); |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
var str = '35549949945'; function test(str){ var iNum = str.length%3; var prev = ''; var arr=[]; var tmp =''; var iNow =0; if(iNum !=0){ prev = str.substring(0,iNum); arr.push(prev); } str = str.substring(iNum); for(var i=0;i<str.length;i++){ iNow++; tmp +=str[i]; if(iNow ==3&&tmp){ arr.push(tmp); tmp=''; iNow=0; } } return arr.join(','); } console.log(test(str)); |
平分字符串
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
/* deuceStr(str,n)方法：n个字符一组为一等份，分到最后不足n的，自动单独为一等份 超出或等于字符串长度的 整个字符串为一组作为一个等份 */ var str = '1234567891'; var str1 = '来自散人笔记的一个方法'; function deuceStr(str,n){ var len=str.length,arr=[]; for(var i=0;i<str.length;i++){ if(i%n==0){ arr.push(str.slice(i,i+n)) } } return arr } console.log(deuceStr(str,3));//["123", "456", "789", "1"] console.log(deuceStr(str1,3));//["来自散", "人笔记", "的一个", "方法"] |
寻找所有子串的位置
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
var str = '1234567891'; function substrPosition (str, substr) { /* find all the substr position */ var position_arr = []; var index = str.indexOf(substr); while(index != -1) { position_arr.push(index); index = str.indexOf(substr, index+1); } return position_arr; } console.log(substrPosition (str, '1'))//[0, 9] |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
var str = '1234567891'; function substrPosition (str, substr) { /* find all the substr position */ var position_arr = []; for(var i=0;i<str.length;i++){ if(str[i]===substr){ position_arr.push(i) } } return position_arr; } console.log(substrPosition (str, '1'))//[0, 9] |
解析url参数
|
1 2 3 4 5 6 7 8 9 10 |
var url= 'http://moxiaofei.com/a.php?a=1&b=2&c=3&d=xxx' function parseUrl(url){ var paramPartStr=url.split('?')[1];//a=1&b=2&c=&d=xxx' var result={} paramPartStr.replace(/(\w)=(\w)&?/g,function(r1){ result[r1.split('=')[0]]=r1.split('=')[1].replace('&','') }) return result } console.log(parseUrl(url))//{a: "1", b: "2", c: "3", d: "x"} |
根据一个字符串每个字符的出现次数从大到小排序
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 |
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>demo</title> </head> <body> <input type="text" id="ipt"> <p>根据字符串中每个字符出现的次数从大到小的一个排名</p> <p id="view"></p> <ul id="show"></ul> </body> <script> var ipt=document.querySelector('#ipt'); var view=document.querySelector('#view'); var show=document.querySelector('#show'); ipt.oninput=function(){ view.innerHTML=sortResult(this.value).str var obj=sortResult(this.value).obj; var html=''; for(var k in obj){ html+=`<li>${k}出现次数为:${obj[k]}</li>` } show.innerHTML=html } //排序方法 function sortResult(str){ if(str.length===0){return false} var obj={} var head=[] for(var i=0;i<str.length;i++){ if(!obj[str[i]]){ obj[str[i]]=1 }else{ obj[str[i]]++ } } var _obj=deepCopy(obj); max(obj); function max(obj){ var n=0; var newStr=''; for(var key in obj){ if(obj[key]>n){ n=obj[key]; newStr=key; } } if(newStr==''){ head=head; return false; } head.push(newStr); delete obj[newStr]; max(obj); } return {str:head.join(''),obj:_obj} } //深度拷贝 function deepCopy(p,c){ var c = c || {}; for (var i in p) { if (typeof p[i] === 'object') { c[i] = (p[i].constructor === Array) ? [] : {}; deepCopy(p[i], c[i]); } else { c[i] = p[i]; } } return c; } </script> </html> |
|
1 2 3 4 5 6 |
需求描述: var str='sadfddfsgffsdssssddddddf';//一个字符串 根据目测:字符串里有5种类别分别是:s a d f g 根据目测:s a d f g在str中出现的次数分别是:s:7 a:1 d:10 f:5 g:1 请写个方法返回按次数大小排序的字符串: sortByCountDdisplay(str)返回 'dsfag' |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 |
var str='sadfddfsgffsdssssddddddf'; function sortByCountDdisplay(str){ var arr=[] var obj={} for(var i=0;i<str.length;i++){ if(!obj[str[i]]){ obj[str[i]]=1 }else{ obj[str[i]]++ } } getMax(obj) function getMax(obj){ var max=0; var maxValue=null; for(var k in obj){ if(obj[k]>max){ max=obj[k] maxValue=k } } if(maxValue==null){ return arr } arr.push(maxValue) delete obj[maxValue] getMax(obj) } return arr.join('') } console.log(sortByCountDdisplay(str))//dsfag |
