String类型

typeof '' === 'string'
Object.prototype.toString.call('') === '[object String]'

创建方式

1.1 字面量

var str = 'strsdf';

console.log(typeof str);  //'string'
console.log(Object.prototype.toString.call(str))   // '[object String]'

1.2 构造函数

var str1 = new String('strsdf');

console.log(typeof str1 === 'object');  //true
console.log(Object.prototype.toString.call(new String(" ")) )   // '[object String]'

字符串一旦创建就不可以改变

var str2 = 'name';
str2 = str2 + ' is gzh';
// 在内存中一共创建了 3 个 字符串   str2 -> 'is gzh' -> '然后创建一个 name is gzh'

转换方法

str.toString() 返回指定对象的字符串形式。
str.valueOf() 返回一个String对象的原始值
str.toLowerCase() 转小写
str.toUpperCase() 转大写

2.1 toString()、valueOf()

toString 没有继承Object.toString()方法，而是跟valueOf的实现一样 valueOf() 返回一个String对象的原始值

console.log("---------------  valueOf  ----------------------")

var strObj = new String("str");
var str = "str";
console.log(new String('str'))
console.log('str')

console.log(typeof strObj === 'object') //true
console.log(typeof strObj.valueOf() === 'string')      //true
console.log(typeof strObj.toString() === 'string')     //true

2.1 toLowerCase()、toUpperCase()

字符串转大写

console.log("---------------  toLowerCase  ----------------------")

var str = "str";
console.log('str'.toUpperCasse()); //"STR"
console.log('StR'.toLowerCasse()); //"str"

截取方法

slice() 提取一个字符串的一部分，并返回一新的字符串。
substr() 返回一个字符串中从指定位置开始到指定字符数的字符。
substring() 方法返回一个字符串在开始索引到结束索引之间的一个子集, 或从开始索引直到字符串的末尾的一个子集。
split() 使用指定的分隔符字符串将一个String对象分割成字符串数组，以将字符串分隔为子字符串，以确定每个拆分的位置。

3.1 slice()

提取一个字符串的一部分，并返回一新的字符串。

var newStr = str.slice(beginIndex[, endIndex]);

入参：

beginIndex ：截取开始位置的索引，如果是负数则当做beginIndex + length (包含)
endIndex : 截取结束位置的索引(没有的话就是字符串结尾),如果是负数则当做beginIndex + length (不包含)

出参：

newStr ：截取的字符串

1、包含开始的索引位置字符，不包含结束的索引位置字符。

2、如果 beginIndex > endIndex 结果为空 '';

3、如果是负数只会加一次字符串的长度，不会多次相加;

： IE 都支持

var str = 'abcdefg';
console.log(str.slice(1,3));   //bc
console.log(str.slice(1));   //bcdefg
console.log(str.slice(1,200));   //bcdefg
console.log(str.slice(1,-2));   //bcde
console.log(str.slice(1,-9));   // ''
console.log(str.slice(-7,-9));   // ''

3.2 substr()

返回一个字符串中从指定位置开始到指定字符数的字符。

var newStr = str.substr(beginIndex[, length]);

入参：

beginIndex ：截取开始位置的索引，如果是负数则当做beginIndex + length (包含)
length : 提取的字符长度

出参：

newStr ：截取的字符串

1、包含开始索引位置的字符。

2、如果开始位置的索引大于字符串的长度则结果肯定为 ''；

3、如果开始位置的索引为负数，则不断相加length直到其为正数。

： IE 都支持

console.log("---------  substr  -----------")
var str = 'abcdefg';
console.log(str.substr(1,3));   //bcd
console.log(str.substr(1));   //bcdefg
console.log(str.substr(1,200));   //bcdefg
console.log(str.substr(-1,2));   // g
console.log(str.substr(-9,2));   // ab
console.log(str.substr(9,2));   // ''
console.log(str.substr(9,10));   // ''

3.3 substring()

返回一个字符串在开始索引到结束索引之间的一个子集, 或从开始索引直到字符串的末尾的一个子集。

var newStr = str.substring(beginIndex[, endIndex]);

入参：

beginIndex : 截取开始位置的索引，如果是负数当做0 如果大于length当做length
endIndex : 截取结束位置的索引(没有的话就是字符串结尾),如果是负数当做0 如果大于length当做length

出参：

newStr ：截取的字符串

1、如果 indexStart 等于 indexEnd，substring 返回一个空字符串。

2、如果省略 indexEnd，substring 提取字符一直到字符串末尾。

3、如果任一参数小于 0 或为 NaN，则被当作 0。

4、如果任一参数大于 stringName.length，则被当作 stringName.length。

5、如果 indexStart 大于 indexEnd，则 substring 的执行效果就像两个参数调换了一样。

： IE 都支持

console.log("---------  substring  -----------")
var str = 'abcdefg';
console.log(str.substring(1,3));   //bc
console.log(str.substring(1));   //bcdefg
console.log(str.substring(1,200));   //bcdefg
console.log(str.substring(199,200));   //''
console.log(str.substring(1,-2));   //a
console.log(str.substring(1,-9));   // a
console.log(str.substring(-14,-9));   // ''
console.log(str.substring(-14,2));   // ''

1、 substr(begin,length)与 slice()、substring()第二个参数前面是截取字符串的长度，后面两个是结束位置的索引。

2、 substr(begin,length)、slice()的索引都是如果小于0 则按照index+length的方式，如果大于length 则按照length计算substring(begin,end)则是按照小于0则为0，大于length就为length。

3、 slice()、substr()、substring()第二个参数都可以省略，此时就按照从开始到结尾截取计算。

3.4 split()

使用指定的分隔符字符串将一个String对象分割成字符串数组，以将字符串分隔为子字符串，以确定每个拆分的位置。

var arr = str.split(separator[,limitNumber])

入参：

separator : 截取的字符串、正则表达式。如果正则表达式包含括号，则是分割后括号类的内容作为单独的一个字符串。
limitNumber : 限制分割后数组的长度。

出参：

newStr ：截取的字符串

： IE 都支持

console.log("---------  split  ----------")
var str = ' Ab cd A SD';
var str1 = 'my name is agzh';
console.log(str.split(" "))       // ["", "Ab", "cd", "A", "SD"]
console.log(str.split(""))        // [" ", "A", "b", " ", "c", "d", " ", "A", " ", "S", "D"]
console.log(str.split())          // [" Ab cd A SD"]
console.log(str1.split(/a/))      // ["my n", "me is ", "gzh"]
console.log(str1.split(/(a)/))    // ["my n", "a", "me is ", "a", "gzh"]
console.log(str1.split(/n(a)/))   // ["my ", "a", "me is agzh"]
console.log(str1.split("",3))     // ["m", "y", " "]

字符串的拼接

concat() 将一个或多个字符串与原字符串连接合并，形成一个新的字符串并返回。不修改源字符串。

4.1 concat()

将一个或多个字符串与原字符串连接合并，形成一个新的字符串并返回。

var newStr = str.concat(str1,str2 ...);

入参：

str : 源字符串。
str1 : 拼接的字符串。

出参：

newStr ：拼接后的字符串

： IE 都支持

console.log("---------  concat  ----------")
var str = 'ab';
console.log(str.concat('cd'));    //abcd
console.log(str);                 //ab

console.log(1+'0');   // 10
console.log(1+ 1 + '12');   // 212  而不是 1112
// 所以我们需要拼接字符串的时候请使用concat()
function concat(){
    return String.prototype.concat.apply('',arguments);
}
console.log(concat(1,1,'12'))   // 1112
console.log(concat(1,1))        // 11

1、我们字符串拼接可以使用 + 但是 + 会进行类型隐式转换 1+ 1 + '12' 结果为 212。

2、字符串的拼接请使用concat不要使用 +。

字符串查询

charAt(index) 从一个字符串中返回指定的字符。
indexOf(str) 返回调用 String 对象中第一次出现的指定值的索引，开始在 fromIndex进行搜索。
includes() 用于判断一个字符串是否包含在另一个字符串中，根据情况返回 true 或 false。
search() 执行正则表达式和 String对象之间的一个搜索匹配。
match() 执行正则表达式和 String对象之间的一个搜索匹配。

5.1 charAt(index)

获取指定索引的字符串(0-length-1)

var char = str.charAt(index);

入参：

str : 源字符串。
index : 索引下标(0-length-1), 默认为 0 。

出参：

char ：获取的索引字符，没有为 '';

1、如果不在这个返回返回一个空字符串 ''。

2、如果没有传入索引。则默认索引为 0。

：都支持

var str = 'abcdefg';
console.log(str.charAt(2));   // c
console.log(str.charAt(11))   // ''
console.log(str.charAt())     // a

5.2 str.indexOf(searchValue[,fromIndex])

返回调用String 对象中第一次出现的指定值的索引，开始在 fromIndex进行搜索,没有则返回 -1

var index = str.indexOf(searchValue[,fromIndex])

入参：

searchValue : 查询的字符串。
fromIndex : 从什么位置开始查询。

出参：

char ：获取的字符串，没有返回 -1;

1、如果不在这个返回返回一个空字符串 ''。

2、如果没有传入索引。则默认索引为 0。

：都支持

console.log("---------  indexOf  ----------")
var str = 'abcabef';
console.log(str.indexOf('ab'));  //0
console.log(str.indexOf('ab',1));  //3
console.log(str.indexOf('abcd',1));  //-1
console.log(str.indexOf('bca',-3));  //1  
console.log(str.indexOf('bca','-3'));  //1
console.log(str.indexOf('bca',10));  //-1

5.3 str.lastIndexOf(searchValue[,fromIndex])

返回调用 String 对象中从后往前第一次出现的指定值的索引，开始在 fromIndex进行搜索,没有则返回 -1

var index = str.lastIndexOf(searchValue[,fromIndex])

入参：

searchValue : 查询的字符串。
fromIndex : 从什么位置开始查询（默认值为length。如果为负值，则被看作0。如果 fromIndex>length，则fromIndex被看作length。）

出参：

char ：获取的字符串，没有返回 -1;

：都支持

console.log("---------  lastIndexOf  ----------")
var str = 'abcabef';
console.log(str.lastIndexOf('ab'));  //3
console.log(str.lastIndexOf('ab',2));  //0
console.log(str.lastIndexOf('ab',4));  // 3  此时从 a开始往前 匹配发现a加后面的成功就成功
console.log(str.lastIndexOf('abcd',1));  // -1
console.log(str.lastIndexOf('bca',-3));  // -1 
console.log(str.lastIndexOf('bca','-3'));  // -1
console.log(str.lastIndexOf('bca',10));  //1

相同点：

1、其都是获取第一次查询到的字符串的下标。

2、没有都返回-1。

不同点：

3、 indexOf()的查询是从左至右进行查询，lastIndexOf()是从右至左进行查询。

5.4 var boolean = str.includes(searchValue[,fromIndex])

用于判断一个字符串是否包含在另一个字符串中，根据情况返回 true 或 false。

var boolean = str.includes(searchValue[,fromIndex])

入参：

searchValue : 查询的字符串。
fromIndex : 从什么位置开始查询

出参：

boolean ：是否包含在字符串中

：都支持

console.log("---------  includes  ----------")
var str = 'abcabef';

console.log(str.includes('ab'));  //true
console.log(str.includes('ab',1));  //true
console.log(str.includes('abcd',1));  //false
console.log(str.includes('bca',-3));  //true     
console.log(str.includes('bca','-3'));  //true     
console.log(str.includes('bca',10));  //false     

if(!String.prototype.includes){
    String.prototype.includes = function(searchValue,fromIndex){
        return this.indexOf(searchValue , fromIndex);
    }
}

5.5 search()

用指定的正则搜索匹配字符串,返回匹配到索引的下标，没有返回-1。相对于test。

var firstIndex = str.search(RegExp)

入参：

RegExp : 正则表达式。

出参：

firstIndex ：第一次出现的下标，没有返回-1

：都支持

console.log("---------  search  ----------")
var str = 'abcabef';

console.log(str.search(/bca/));  //1
console.log(str.search(/ab/));   //0
console.log(str.search(/abdasd/));   //-1
console.log(str.search('ab'));      //0

5.5 match()

用指定的正则搜索匹配字符串,返回数组。

var array = str.match(RegExp)

入参：

RegExp : 正则表达式。

出参：

array 数组的第一项是进行匹配完整的字符串，之后的项是用圆括号捕获的结果。如果没有匹配到，返回null

：都支持

console.log("---------  match  ----------")
var str = 'abcabef';

console.log(str.match(/bca/));  // ['bac',index: 1 ,input : 'abcabef']
console.log(str.match(/ab/));   // ["ab", index: 0, input: "abcabef"]
console.log(str.match(/ab/i));   //["ab", index: 0, input: "abcabef"]
console.log(str.match(/ab/g));   //["ab", "ab"]
console.log(str.match(/abdasd/));   //null
console.log(str.match('ab'));      //["ab", index: 0, input: "abcabef"]

相同点：

1、都是通过正则去匹配字符串。

[ ] 待研究正则

不同点：

1、 search()相当于test match()相当于exec。所以search更快。

2、返回结果不同，search是下标，match是一个数组

字符串的替换

replace()
trim()

6.1 replace()

返回一个由替换值替换一些或所有匹配的模式后的新字符串。模式可以是一个字符串或者一个正则表达式, 替换值可以是一个字符串或者一个每次匹配都要调用的函数。

var newStr = str.replace(regexp|substr, newSubStr|function);

入参：

regexp : 正则表达式。该正则所匹配的内容会被第二个参数的返回值替换掉。
substr : 一个要被 newSubStr 替换的字符串。其被视为一整个字符串，而不是一个正则表达式。仅仅是第一个匹配会被替换。
newSubStr : 用于替换掉第一个参数在原字符串中的匹配部分的字符串。该字符串中可以内插一些特殊的变量名。
function : 一个用来创建新子字符串的函数，该函数的返回值将替换掉第一个参数匹配到的结果。

出参：

newStr : 替换后的新字符串

：都支持

console.log("---------  replace  ----------")
var str = 'abcabef';

console.log(str.replace("a","A"));    // Abcabef  只替换了第一个
console.log(str.replace(/a/g,'A'))    // AbcAbef  所有的a都替换成了A
console.log(str.replace(/a/i,'A'))    // Abcabef  只替换了第一个
console.log(str.replace(/a/g,function(match, index , sourceStr){
    // match  匹配的字符串
    // index  匹配的字符串的下标
    // sourceStr : 源字符串
    console.log(arguments)
    return match.toUpperCase()
}))    // AbcAbef  所有的a都替换成了A
//  $1 $$这个
//  TODO : 正则表达式

6.1 trim()

会从一个字符串的两端删除空白字符。。

var newStr = str.trim();

出参：

newStr : 删除前后空格的新字符串

：IE9+ ，Chrome , FF(3.5) , Opera(10.5) , Safari(5)

console.log("---------  trim  ----------")

var str = "     name is ";
console.log(str.trim())   //name is
console.log(str.replace(" ",''))   //    name is 没有去除中文空格 tab等

if (!String.prototype.trim) {
  String.prototype.trim = function () {
    return this.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, '');
  };
}

String类型 ​

创建方式 ​

1.1 字面量 ​

1.2 构造函数 ​

转换方法 ​

2.1 toString()、valueOf() ​

2.1 toLowerCase()、toUpperCase() ​

截取方法 ​

3.1 slice() ​

入参： ​

出参： ​

1、 包含开始的索引位置字符，不包含结束的索引位置字符。 ​

2、 如果 beginIndex > endIndex 结果为空 ''; ​

3、 如果是负数只会加一次字符串的长度，不会多次相加; ​

： IE 都支持 ​

3.2 substr() ​

入参： ​

出参： ​

1、 包含开始索引位置的字符。 ​

2、 如果开始位置的索引大于字符串的长度则 结果肯定为 ''； ​

3、 如果开始位置的索引为负数，则不断相加length直到其为正数。 ​

： IE 都支持 ​

3.3 substring() ​

入参： ​

出参： ​

1、 如果 indexStart 等于 indexEnd，substring 返回一个空字符串。 ​

2、 如果省略 indexEnd，substring 提取字符一直到字符串末尾。 ​

3、 如果任一参数小于 0 或为 NaN，则被当作 0。 ​

4、 如果任一参数大于 stringName.length，则被当作 stringName.length。 ​

5、 如果 indexStart 大于 indexEnd，则 substring 的执行效果就像两个参数调换了一样。 ​

： IE 都支持 ​

1、 substr(begin,length)与 slice()、substring()第二个参数 前面是截取字符串的长度，后面两个是结束位置的索引。 ​

2、 substr(begin,length)、slice()的索引都是如果小于0 则按照index+length的方式，如果大于length 则按照length计算substring(begin,end)则是按照小于0则为0，大于length就为length。 ​

3、 slice()、substr()、substring()第二个参数都可以省略，此时就按照从开始到结尾截取计算。 ​

3.4 split() ​

入参： ​

出参： ​

： IE 都支持 ​

字符串的拼接 ​

4.1 concat() ​

入参： ​

出参： ​

： IE 都支持 ​

1、 我们字符串拼接可以使用 + 但是 + 会进行类型隐式转换 1+ 1 + '12' 结果为 212。 ​

2、 字符串的拼接请使用concat不要使用 +。 ​

字符串查询 ​

5.1 charAt(index) ​

入参： ​

出参： ​

1、 如果不在这个返回返回一个空字符串 ''。 ​

2、 如果没有传入索引。则默认索引为 0。 ​

： 都支持 ​

5.2 str.indexOf(searchValue[,fromIndex]) ​

入参： ​

出参： ​

1、 如果不在这个返回返回一个空字符串 ''。 ​

2、 如果没有传入索引。则默认索引为 0。 ​

： 都支持 ​

5.3 str.lastIndexOf(searchValue[,fromIndex]) ​

入参： ​

出参： ​

： 都支持 ​

相同点： ​

1、 其都是获取第一次查询到的字符串的下标。 ​

2、 没有都返回-1。 ​

不同点： ​

3、 indexOf()的查询是从左至右进行查询，lastIndexOf()是从右至左进行查询。 ​

5.4 var boolean = str.includes(searchValue[,fromIndex]) ​

入参： ​

出参： ​

： 都支持 ​

5.5 search() ​

入参： ​

出参： ​

： 都支持 ​

5.5 match() ​

入参： ​

出参： ​

： 都支持 ​

相同点： ​

String类型

创建方式

1.1 字面量

1.2 构造函数

转换方法

2.1 toString()、valueOf()

2.1 toLowerCase()、toUpperCase()

截取方法

3.1 slice()

入参：

出参：

1、包含开始的索引位置字符，不包含结束的索引位置字符。

2、如果 beginIndex > endIndex 结果为空 '';

3、如果是负数只会加一次字符串的长度，不会多次相加;

： IE 都支持

3.2 substr()

入参：

出参：

1、包含开始索引位置的字符。

2、如果开始位置的索引大于字符串的长度则结果肯定为 ''；

3、如果开始位置的索引为负数，则不断相加length直到其为正数。

： IE 都支持

3.3 substring()

入参：

出参：

1、如果 indexStart 等于 indexEnd，substring 返回一个空字符串。

2、如果省略 indexEnd，substring 提取字符一直到字符串末尾。

3、如果任一参数小于 0 或为 NaN，则被当作 0。

4、如果任一参数大于 stringName.length，则被当作 stringName.length。

5、如果 indexStart 大于 indexEnd，则 substring 的执行效果就像两个参数调换了一样。

： IE 都支持

1、 substr(begin,length)与 slice()、substring()第二个参数前面是截取字符串的长度，后面两个是结束位置的索引。

2、 substr(begin,length)、slice()的索引都是如果小于0 则按照index+length的方式，如果大于length 则按照length计算substring(begin,end)则是按照小于0则为0，大于length就为length。

3、 slice()、substr()、substring()第二个参数都可以省略，此时就按照从开始到结尾截取计算。

3.4 split()

入参：

出参：

： IE 都支持

字符串的拼接

4.1 concat()

入参：

出参：

： IE 都支持

1、我们字符串拼接可以使用 + 但是 + 会进行类型隐式转换 1+ 1 + '12' 结果为 212。

2、字符串的拼接请使用concat不要使用 +。

字符串查询

5.1 charAt(index)

入参：

出参：

1、如果不在这个返回返回一个空字符串 ''。

2、如果没有传入索引。则默认索引为 0。

：都支持

5.2 str.indexOf(searchValue[,fromIndex])

入参：

出参：

1、如果不在这个返回返回一个空字符串 ''。

2、如果没有传入索引。则默认索引为 0。

：都支持

5.3 str.lastIndexOf(searchValue[,fromIndex])

入参：

出参：

：都支持

相同点：

1、其都是获取第一次查询到的字符串的下标。

2、没有都返回-1。

不同点：

3、 indexOf()的查询是从左至右进行查询，lastIndexOf()是从右至左进行查询。

5.4 var boolean = str.includes(searchValue[,fromIndex])

入参：

出参：

：都支持

5.5 search()

入参：

出参：

：都支持

5.5 match()

入参：

出参：

：都支持

相同点：