JavaScript字符串操作整理

JavaScript操作整理

1、字符串转换

数字类型转String类型

// 1.
var num=24;
var mystr=num.toString();    //"24"

// 2.
var num=24;
var mystr=String(num);    //"24"

// 3.
var num=24;
var mystr="" + num;    //"24"

2、字符串分割

将字符串进行拆分返回一个新的数组

var mystr="qingchenghuwoguoxiansheng,woaishenghuo,woaiziji";
var arr1=mystr.split(",");    //["qingchenghuwoguoxiansheng","woaishenghuo","woaiziji"];
var arr2=mystr.split("");        //["q","i","n","g","c","h","e","n","g","h","u","w","o","g","u","o","x","i","a","n","s","h","e","n","g",",","w","o","a","i","s","h","e","n","g","h","u","o",",","w","o","a","i","z","i","j","i"];


split()的第二个参数，表示返回的字符串数组的最大长度
var arr1=mystr.split(",",2); //["qingchenghuwoguoxiansheng","woaishenghuo"];
var arr2=mystr.split("",8); //["q","i","n","g","c","h","e","n"];

3、字符串替换

只替换一次

var str='我是生长在中国南方的纯正中国人';
var newstr=str.replace('中国','天朝');

全部替换

var str='我是生长在中国南方的纯正中国人';
var reg = new RegExp( '中国' , "g" )
var newstr=str.replace(reg,'天朝');

全部替换封装成函数

String.prototype.myReplacr(a,b){ //把a全部替换成b
    var reg = new RegExp(a,'g');//
    return this.replace(reg,b);
}
使用
var str='我是生长在中国南方的纯正中国人';
var newstr=str.myReplace('中国','天朝');

4、获取字符串长度

var str='我是生长在中国南方的纯正中国人'.length;

5、查询子字符串

indexOf()，该Of() 方法对大小写敏感。返回字符串中一个子串第一处出现的索引（从左到右搜索）。如果没有匹配项，返回 -1 。

var mystr="Hello world!";
var index=mystr.indexOf("llo");    //2
var index1=mystr.indexOf("l");    //2
var index2=mystr.indexOf("l",3);    //3

lastIndexOf()，该方法对大小写敏感。返回字符串中一个子串最后一处出现的索引（从右到左搜索），如果没有匹配项，返回 -1 。

var mystr="Hello world!";
var index=mystr.indexOf("llo");    //2
var index1=mystr.indexOf("l");    //2
var index2=mystr.indexOf("l",3);    //3

6、返回指定位置的字符或其字符编码值

var mystr="Hello World!";
var index=mystr.charAt(7);    //o

查找对应位置的字符编码值

var mystr="Hello World!";
var charCode=mystr. charCodeAt(7);    //111

7、 字符串匹配

match() 方法可在字符串内检索指定的值，或找到一个或多个正则表达式的匹配。

该方法类似 indexOf() 和 lastIndexOf()，但是它返回指定的值，而不是字符串的位置。

字符串 match()

普通字符串的使用方式，此时match方法的返回值是存放首次匹配内容的数组。如果没有找到匹配结果，返回null。语法结构

let str="antzone"; 
console.log(str.match("n"));
代码运行效果：
["n", index: 1, input: "antzone", groups: undefined]

对上述代码运行结果分析如下：
（1）.match方法在有匹配结果的时候返回值是一个数组。
（2）.数组第一个元素是match方法首次匹配到的子字符串，”antzone”虽然有多个”n”，但是返回的数组只存储首次匹配到的”n”，如果match方法的参数是全局匹配的正则，将会存储所有的匹配到的子字符串。
（3）.index属性值返回首次匹配到子字符串的位置。
（4）.input属性值是原字符串”antzone”。
（5）.groups属性当前并不被支持，暂时不做介绍。

正则表达式 match()

match方法可在字符串内查找一个或多个与指定正则表达式匹配的子字符串。
方法的返回值是存放着匹配结果的数组，

一.非全局匹配：
所谓非全局匹配，也就是使用g修饰符
此时，match方法最多只在字符串中成功匹配一次：
（1）.如果不存在匹配的子字符串，返回null。
（2）.如果存在匹配的子字符串，返回一个数组。
返回的数组解析如下：
首先说明一下，数组元素的索引是从0开始的。
（1）.第0个元素是匹配结果。
（2）.第1个元素是第一个引用型分组匹配的子字符串。
（3）.第2个元素存放的是第二个引用型分组匹配的子字符串，依次类推。
返回的数组对象同时具有两个属性：
（1）.index：返回匹配的子字符串起始字符在stringObject源字符串中的位置。
（2）.input：返回stringObject源字符串。

二.全局匹配：
match方法执行全局匹配，获取所有可以匹配的子字符串：
（1）.如果不存在匹配的子字符串，返回null。
（2）.如果存在匹配的子字符串，返回一个数组。
与非全局匹配的区别：
（1）.不具有index和input属性。
（2）.不具有引用型分组匹配的子字符串，数组元素仅包含匹配的所有子字符串。

var str="本站url地址是www.softwhy.com"; 
var reg=/why/;
console.log(str.match(reg));
上面代码采用非全局模式，运行效果如下：

["why", index: 16, input: "本站url地址是www.softwhy.com", groups: undefined]

当前JavaScript并不支持groups
（1）.数组第0个元素是匹配的子字符串。
（2）.index属性值是”why”中”w”在源字符串中的位置。
（3）.input属性值是整个源字符串。

匹配一次

var mystr="hi,mynameisguoxiansheng6,33iswho?";
var matchStr=mystr.match("guo");    //guo
var matchStr1=mystr.match("Guo");    //nullvar regexp1=/\d+/g;
var regexp2=/guo/g;
var regexp3=/guo/;
var matchStr2=mystr.match(regexp1);    //["6","33"]
var matchStr3=mystr.match(regexp2);    //["guo"]
var matchStr3=mystr.match(regexp3);    //["guo",index:11,input:"hi,mynameisguoxiansheng6,33iswho?"]
matchStr3.index    //11
matchStr3.input    //hi,mynameisguoxiansheng6,33iswho?

exec()函数

仅仅是把正则和字符串换了个位置，即exec()函数是在正则上调用，传递字符串的参数。对于上面两个方法，匹配的结果都是返回第一个匹配成功的字符串，如果匹配失败则返回null。

var mystr="hi,mynameisguoxiansheng6,33iswho?";
var regexp1=/guo/g;
var matchStr=regexp1.exec(mystr);  //["guo"]
var regexp2=/guo/;
var matchStr1=regexp2.exec(mystr);    //["guo",index:11,input:"hi,mynameisguoxiansheng6,33iswho?"]

search()函数

进行正则匹配查找。如果查找成功，返回字符串中匹配的索引值。否则返回 -1

var mystr = "hi,mynameisguoxiansheng6,33iswho?";
var regexp1 = /guo/;
var matchStr = mystr.search(regexp1);    //11

8、字符串连接

加法操作进行字符串连接

var mystr1="Hello";
var mystr2="world!";
var newStr=mystr1+" "+mystr2;    //Hello world!

concat()函数

var mystr1="Hello";
var mystr2="world!";
var newStr=mystr1.concat(mystr2);    //Hello world!

concat()函数可以有多个参数，传递多个字符串，拼接多个字符串

9、字符串切割和提取

有三种可以从字符串中抽取和切割的方法：

slice()函数：

var mystr="hello world!";
var sliceStr1=mystr.slice(-3);    //ld!
var sliceStr2=mystr.slice(-3,-1);    //ld
var sliceStr3=mystr.slice(3);    //lo world!
var sliceStr4=mystr.slice(3,7);    //lo w

substring()函数

var mystr="hello world!";
var sliceStr1=mystr.substring(3);    //lo world!
var sliceStr2=mystr.substring(3,7);    //lo w

substr()函数

substr函数方法是返回一个从指定位置开始的指定长度的子字符串。使用方法

var mystr="hello world!";
var sliceStr1=mystr.substr(3);    //lo world!
var sliceStr2=mystr.substr(3,7);    //lo wo

注：1.slice() 可以为负数，如果起始位置为负数，则从字符串最后一位向前找对应位数并且向后取结束位置，如果为正整数则从前往后取起始位置到结束位置。
　　2.substring()只能非负整数，截取起始结束位置同slice()函数一致。

　　3.substr()与第一、第二种函数不同，从起始位置开始截取，结束位置为第二个参数截取的字符串最大长度。

以上三种函数未填第二参数时，自动截取起始位置到字符串末尾。

js中substr和substring都是截取字符串中子串，非常相近，可以有一个或两个参数。
语法：substr(start [，length]) 第一个字符的索引是0，start必选 length可选
　　　substring(start [, end]) 第一个字符的索引是0，start必选 end可选
相同点：当有一个参数时，两者的功能是一样的，返回从start指定的位置直到字符串结束的子串
var str = “hello Tony”;
str.substr(6); //Tony
str.substring(6); //Tony

不同点：有两个参数时
（1）substr(start,length) 返回从start位置开始length长度的子串
“goodboy”.substr(1,6); //oodboy
【注】当length为0或者负数，返回空字符串
（2）substring(start,end) 返回从start位置开始到end位置的子串（不包含end）
“goodboy”.substring(1,6); //oodbo

10、字符串大小写转换

var mystr="Hello World!";
var lowCaseStr=mystr.toLowerCase();    //hello world!
var upCaseStr=mystr. toUpperCase();    //HELLO WORLD!

11、字符串去空格

trim方法用来删除字符串前后的空格

var mystr="     hello world      ";  
var trimStr=mystr.trim();    //hello world

常用的字符串操作

1.字符串去重

var str="aahhgggsssjjj";
function removeRepeat(msg){  
    var res=[];  
    var arr=msg.split("");  
    for(var i=0;i<arr.length;i++){  
        if(res.indexOf(arr[i])==-1){  
            res.push(arr[i]);  
        }  
    }  
    return res.join("");  
}  
removeRepeat(str);    //ahgsj

2、判断字符串中字符出现的次数

/*  
    1.先实现字符串去重  
    2.然后对去重后的数组用for循环操作，分别与原始数组中各个值进行比较，如果相等则count++,循环结束将count保存在sum数组中，然后将count重置为0  
    3.这样一来去重后的数组中的元素在原数组中出现的次数与sum数组中的元素是一一对应的  
*/  
var str="aacccbbeeeddd";  
var sum=[];  
var res=[];  
var count=0;  
var arr=str.split("");  
for(var i=0;i<arr.length;i++){  
    if(res.indexOf(arr[i])==-1){  
        res.push(arr[i]);  
    }  
}  
for(var i=0;i<res.length;i++){  
    for(var j=0;j<arr.length;j++){  
        if(arr[j]==res[i]){  
            count++;  
        }  
    }  
    sum.push(count);  
    count=0;  
}  
console.log(res);    //["a", "c", "b", "e", "d"]  
for(var i=0;i<res.length;i++){  
    var str=(sum[i]%2==0)?"偶数":"奇数";  
    console.log(res[i]+"出现了"+sum[i]+"次");  
    console.log(res[i]+"出现了"+str+"次");  
}