字符串操作

1、length
获取字符串长度

var str = "hello world";
    str.length     
    //返回 11

2、索引
通过下标获取字符串指定位置的字符，但是不能改变该索引对应的值

var str = "hello world"
str[0] = "H";//不会影响str,但也不会报错

3、toUpperCase
将字符串全部转为大写，并返回原字符串不变

var str = "hello world";
str.toUpperCase();
//返回 "HELLO WORLD"

4、toLowerCase
将字符串全部变小写，并返回原字符串不变

var str = "hello world";
alert(str.toLowerCase());

5、indexOf
搜索指定字符串出现的位置，接收两个参数，第一个参数表示要查找的元素，第二个参数表示要查找的位置，若找到则返回对应元素所在的位置，否则返回-1

var s = 'hello world!';
alert(s.indexOf('world'));//返回6
alert(s.indexOf('World'));//返回-1
alert(s.indexOf('o'));//返回4
alert(s.indexOf('o',6));//从第六位开始查找，返回7

6、concat
将一个或多个字符串拼接起来，返回拼接到的新的字符串，原字符串不变

var str1 = "hello ";
var res = str1.concat(" world","!");
alert(res);//返回hello world！
alert(str1);//返回hello

7、slice
返回被操作字符的子字符串，原字符串不变，接受两个参数，字符串的起始位置和结束位置，返回的字符串不包含结束位置的字符，第一个参数要小于第二个参数，否则返回”“,若只有一个参数，返回起始位置到字符串结尾的所有字符串，若传递的参数为负数，将传入的负值与字符创的长度相加

var str = "hello world!";
alert(str.slice(3,7));//返回lo w
alert(str.slice(3));//返回lo world!
alert(str.slice(9,5));//返回""
alert(str.slice(-7,-3));//负数与长度相加，即str.slice(5,9)返回 wor
alert(str.slice(5,9));//返回 wor

8、substring
当传入的参数是正数时，substring与slice的功能基本相同，唯一的区别是当第一个参数大于第二个参数时，方法将第二个参数作为截取的起始位置而将第一个参数作为截取结束的位置，且截取的字符串不包含第一个参数位置对应的值，当传入的参数是负值时，该方法会将所有的负值转化为0

var str = "hello world!";
alert(str.substring(3,7));//返回lo w
alert(str.substring(3));//返回lo world!
alert(str.substring(9,5));//返回 wor,即str.substring(5,9),不包含第九项
alert(str.substring(-7,-3));//负数与长度相加，即str.substring(0,0)返回""
alert(str.substring(-7,3));//负数与长度相加，即str.substring(0,3)返回hel

9、substr
返回指定位置开始的指定长度的字符串，原字符串不变，若第二个参数缺省就一直截取到字符串结束，当传递的参数为负值时，方法会将负的第一个参数与字符串的长度相加，将负的第二个参数转化为0

var s = 'hello world!'
alert(s.substr(0, 5));//从索引0开始，截取5个字符串，返回hello
alert(s.substr(7)); //从索引7开始截取，一直到结束，返回orld!
alert(s.substr(-7,3));//负数与长度相加，即str.substr(5,3),返回 wo
alert(s.substr(-7,-3));//负数与长度相加，即str.substr(5,0),返回""

10、trim
删除元素前置及后缀的所有空格，然后返回结果，远数组不变

var str1 = "      hello world   ";
var str2 = str1.trim();
alert(str1);//返回"      hello world   "
alert(str2);//返回"hello world"

11、split
基于指定的分隔符将一个字符串分割成多个字符串，并将结果存放在一个数组中，可以传两个参数，第一个参数为分隔符，第二个参数用于指定返回数组的大小，若省略该参数，则返回整个数组

//1、 只传一个参数，默认分割整个字符串
var str ="a,b,c,d,e";
str.split(','); // 返回分割的字符串数组：["a", "b", "c", "d", "e"]
//2、传入两个参数
var str ="a,b,c,d,e";
str.split(',',3); //指定限定长度，则返回对应的数组：["a", "b", "c"]
//3、使用正则表达式匹配，不包含分割字符串
var str = "aa44bb55cc66dd";
str.split(/\d+/); //通过匹配数字进行分割字符串，但不包含分割的字符串，则返回的结果为：["aa","bb","cc","dd"];
//4、使用正则表达式匹配，包含分割字符串
var str = "aa44bb55cc66dd";
str.split(/(\d+)/); //通过匹配数字进行分割字符串，且分割的字符串是包含在子表达式中，则返回的结果为：["aa", "44", "bb", "55", "cc", "66", "dd"]

12、replace
替换字符串中所有指定字符的方法

//替换第一个匹配
var str = 'abc+ad/eacf';
var str1 = str.replace('a', 'o');
console.log(str1);  
// 打印结果： obc+ad/eacf

 //全局替换
var str2 = str.replace(/a/g, 'o');
console.log(str2);  
//打印结果： bc+od/eocf,

//转义  在转义字符前面加\
var str3.replace(/\+/g, "-").replace(/\//g, "_");
console.log(str3);
//打印结果： bc-od_eocf,

13、match
返回值是包含了匹配结果的数组。

// 全局匹配
var str = "1 plus 2 equals 3";
str.match(/\d/g); // 匹配字符串中出现的所有数字，并返回一个数组： [1,2,3]

// 非全局匹配
var str = "visit my blog at http://www.example.com";
str.match(/(\w+):\/\/([\w.]+)/); 
// 返回结果：["http://www.example.com", "http", "www.example.com"]
// 正则表达式匹配的结果为：http://www.example.com
// 第一个子表达式 (\w+)匹配结果：http
// 第二个子表达式 ([\w.])匹配结果： www.example.com

//全局匹配
str.match(/(\w+):\/\/([\w.]+)/g);
// 返回结果：["http://www.example.com"]

14、search
search()方法将在字符串str中检索与表达式regexp相匹配的字串，并且返回第一个匹配字串的第一个字符的位置。如果没有找到任何匹配的字串，则返回-1。
search()方法不支持全局搜索，因为会忽略正则表达式参数的标识g，并且也忽略了regexp的lastIndex属性，总是从字符串的开始位置进行检索，所以它会总是返回str的第一个匹配的位置。

var str = "Javascript";
str.search(/script/); // 返回 script 中s的位置为 4
str.search(/j/i); // 设置正则表达是标识i：忽略大小写，则匹配到J，返回位置0

15、test
test() 方法用于检测一个字符串是否匹配某个模式.
返回 true 或 false。

var str = "Visit W3School";
var patt1 = new RegExp("W3School");
var result = patt1.test(str);
console.log("Result: " + result);
//返回结果 Result: true

// 2012-12-12 12:12:12
var regex = /\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}/g;
// true
alert(regex.test("2012-12-12 12:12:12"));
// false
alert(regex.test("2012-12-12 12:12:12"));
//执行结果已经在代码注释里了，可以看到：对于同一个正则表达式对象regex，不能重复调用：第一次返回true，第二次就返回false，很显然这种效果不是我们想要的。这是因为RegExp.test()方法，第一次从位置0开始查找，可以匹配；第二次的查找位置就不是0了，说以就不能匹配了。

解决方式挺简单：每次都让test从第0个位置开始匹配就可以了：
// 2012-12-12 12:12:12
var regex = /\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}/g;
// true
alert(regex.test("2012-12-12 12:12:12"));
regex.lastIndex = 0;
// true
alert(regex.test("2012-12-12 12:12:12"));

13、数组转换为字符串

//arr.join(分隔符)      以,连接
//arr.join('')            无缝连接
//arr.join('-')          以-连接
//arr.join('<span>' + str + '</span>')       以表达式连接

var arr=["a","b","c"]; 
var str=arr.join("-"); 
var str1 = arr.join("");
console.log("类型是："+typeof(str)+"，字符串是："+str); 
//打印结果： 类型是：string，字符串是：a-b-c
console.log(str1)
//打印结果： 类型是：string，字符串是：abc

14、json字符串与对象相互转换
用到两个函数：JSON.stringify() 和 JSON.parse()。

JSON字符串:
var str1 = '{ "name": "cxh", "sex": "man" }'; 
JSON对象:
var str2 = { "name": "cxh", "sex": "man" };

JSON.parse(str1); //由JSON字符串转换为JSON对象
//结果：{name: "cxh", sex: "man"}

JSON.stringify(str2); //将JSON对象转化为JSON字符
//结果：'{ "name": "cxh", "sex": "man" }'