字符串的常用方法

字符串的常用方法

1. charAt() [不常用]
=> 语法: 字符串.charAt(索引)
=> 返回值: 获取该索引位置的字符

charsAt()方法使用
// var str = ‘hello world’;
// var res = str.charAt(1);
// console.log(res); //e

    // var res2 = str.charAt(100);
    // console.log(res2); //空

2. charCodeAt() [不常用]
=> 语法: 字符串.charCodeAt(索引)
=> 返回值: 获取该索引位置的字符的字符编码(UTF-8编码)
charCodeAt()方法使用
// var str = ‘hello world’;
// var res = str.charCodeAt(4);
// console.log(res);

3. substr()
=> 语法: 字符串.substr(开始索引, 截取多少个)
=> 作用: 截取字符串
=> 返回值: 截取出来的字符串
substr()方法使用
// var str = ‘hello world’;
// // 表示从索引[2]开始 向后数五个字符位置
// var res = str.substr(2, 5);
// console.log(res); //llo w
4. substring()
=> 语法: 字符串.substring(开始索引, 结束索引) - 包前不包后
=> 作用: 截取字符串
=> 返回值: 截取出来的字符串
substring()方法使用
// var str = ‘hello world’;
// // 从索引[2] 开始 截取到索引[5]位置 但是不包含索引[5]
// var res = str.substring(2, 5);
// console.log(res); // llo
5. toLowerCase()
=> 语法: 字符串.toLowerCase()
=> 作用: 把字符串里面的大写字母转成小写字母
=> 返回值: 转换好以后的字符串
toLowerCase() 方法使用
// var str = ‘hello WORLD’; //将大写字母转化为小写字母 它只能够转字母 转不了的就原样输出
// var res = str.toLowerCase();
// console.log(res);
6. toUpperCase()
=> 语法: 字符串.toUpperCase()
=> 作用: 把字符串里面的小写字母转换成大写字母
=> 返回值: 转换好以后的字符串

toUpperCase()方法使用
// var str = ‘helLO wolrd’; //将小写字母转换为大写字母 转换了的就转换 转换不了的就原样输出
// var res = str.toUpperCase();
// console.log(res);
7. replace()
=> 语法: 字符串.replace(‘要被替换的字符’, ‘替换成的字符’)
=> 作用: 替换字符串内的某些字符
-> 只能替换查找到的第一个 如果找不到要被替换的字符 他就什么也不替换 原样输出就可以了
=> 返回值: 替换好的字符串
replace()方法使用 只能够替换查找到得第一个内容
// var str = ‘你好 世界 H H abc HH 你好’;
// console.log(str);
// var res = str.replace(‘a’, ‘***’);
// console.log(res);
8. concat()
这个方法和数组同名 字符串也有 这个方法也不常用 因为我用他不如用加号 加号拼接更加好用
=> 语法: 字符串.concat(字符串)
=> 作用: 拼接字符串
=> 返回值: 拼接好的字符串

    concat()方法使用    这个方法基本不使用   因为我们完全可以使用加号拼接更加的方便
    // var str = 'hello';
    // // var str = 'hello' + 'world';
    // // console.log(str);
    // var res = str.concat('world');
    // console.log(res);

9. slice()
=> 语法: 字符串.slice(开始索引, 结束索引) - 包前不包后
-> 和 substring 的区别就是可以写 负整数
-> 当你写负整数的时候, 表示 length + 负整数
=> 作用: 截取字符串
=> 返回值: 截取好的字符串

slice()方法使用
// var str = ‘hello world’;
// var res = str.slice(2, 8);
// console.log(res); // llo wo 但是r取不到 因为包前不包后 他和substring的区别是参数可以写成负整数

    // var res2 = str.slice(2, -3);
    // console.log(res2); //这里的   -3   其实就是str的长度  11-3 还是8    跟上面的res输出是一样的

10. split()
=> 语法: 字符串.split(‘切割符号’, 多少个)
-> 切割符号, 按照你写的符号把字符串切割开 就是分割开
+ 如果不写, 那么就直接切割一个完整的
+ 如果写一个空字符串(’’), 按照一位一位的切割
-> 多少个, 选填, 默认是全部, 表示你切割完以后保留多少个
=> 返回值: 一个数组的形式保存每一段内容
-> 不管按照什么切割, 返回值一定是一个数组
split()方法使用
// var str = ‘2021-12-12’;
// var res = str.split(); //什么也不写 那就直接切割成一个完整的
// var res = str.split(’’); //按照一位一位的切割
// var res = str.split(’-’); //用中划线将这个字符串切割成3段
// var res = str.split(’-’, 1); //用中划线将这个字符串切割分段 如果我这里写一个1 就表示只保留第一段
// var res = str.split(’-’, 2); //用中划线将这个字符串切割分段 如果我这里写一个1 就表示只保留前两段
// console.log(res);
11. indexOf()
=> 语法:
1. 字符串.indexOf(字符串片段)
2. 字符串.indexOf(字符串片段, 开始索引)
=> 作用: 在字符串里面查找指定字符串片段
=> 返回值:
-> 如果查询到了, 就是指定索引
-> 如果没有, 就是 -1
跟数组的使用方法差不多 只不过我们数组是查询一个数据 每一个位置就放一个数据 但是字符串你可以查询一个片段

  indexOf()方法使用
    var str = 'abcaabbccddeeff';
    var res = str.indexOf('a');
    console.log(res); //查找到第一个满足条件的字符串的索引  就是0
    var res2 = str.indexOf('a', 2);
    console.log(res2); //从索引位置为2的地方 开始往后查找第一个满足条件的字符串的索引   就是3
    var res3 = str.indexOf('aa');
    // 去找str里面完全匹配的 'aa'
    // 找到匹配的片段以后   返回当前字符串aa所在的索引
    console.log(res3);

12. lastIndexOf()
=> 语法:
1. 字符串.lastIndexOf(字符串片段)
2. 字符串.lastIndexOf(字符串片段, 开始索引)
=> 作用: 从后向前查找对应的字符串片段
=> 返回值
-> 如果查询到了, 就是指定索引
-> 如果没有, 就是 -1
lastIndexOf()方法使用
// var str = ‘abcaabbccddee’;
// var res = str.lastIndexOf(‘a’);
// console.log(res); //从后往前找 找到第一个满足条件的字符串a 返回他的索引就可以了
// var res2 = str.lastIndexOf(‘a’, 2);
// console.log(res2); //从索引为2的位置往前找 找到第一个满足条件的字符串a 返回他的索引就可以了
// var res3 = str.lastIndexOf(‘aa’);
// console.log(res3); //从后往前找 找到第一个满足条件的字符串aa 返回他的索引就可以了
// var res4 = str.lastIndexOf(‘z’);
// console.log(res4);

13. includes()
=> 语法: 字符串.includes(‘字符串片段’)
=> 作用: 判断字符串里面是否包含该字符串片段
=> 返回值: 布尔值
-> 有就是 true
-> 没有就是 false
includes()方法使用
// var str = ‘hello world’;
// var res = str.includes(‘a’);
// console.log(res);
// var res2 = str.includes(‘l’);
// console.log(res2);

14. search()
=> 语法: 字符串.search(‘字符串片段’)
=> 作用: 查找字符串里面有没有匹配的字符串片段
=> 返回值:
-> 如果有, 就是指定索引
-> 如果没有, 就是 -1
=> 和 indexOf 的区别
1. 没有第二个参数 只能欧股从左往右开始查找
2. search 参数可以写正则
search()方法使用
// var str = ‘hello world’;
// var res = str.search(‘e’);
// console.log(res); //返回是索引 不是true
// var res2 = str.search(‘z’);
// console.log(res2);
15. match()
我们现在学习有点早 基本上用不到这个方法
=> 语法: 字符串.match(‘字符串片段’)
=> 作用: 找到字符串里面的字符串片段
=> 返回值: 是一个数组
-> 里面是找到的字符串片段
=> 实际应用:
-> 不是传递字符串
-> 传递正则
match()方法使用
// var str = ‘hello world’;
// var res = str.match(‘w’);
// console.log(res);
// 返回值是一个数组 索引第0项就是你想要找到的这个字符串 index是他所在的坐标索引 input是指原始字符串
// 这个咱们先了解一下 之后咱们学习正则的时候 咱们在深入学习match()

16. trim()
=> 语法: 字符串.trim()
=> 作用: 去除首尾空格
=> 返回值: 去除空格以后的字符串
trim() 只能够去除首尾空格 中间空格他不管
// var str = ’ 你好 世界 ';
// var res = str.trim();
// console.log(res);
// console.log(str);
17. trimStart()
=> 语法: 字符串.trimStart()
=> 作用: 去除开始的空格
=> 返回值: 去除空格以后的字符串
=> 别名: trimLeft()

    trimStart()方法使用    去除字符串头部空格
    // var str = '     你好     世界     ';
    // var res = str.trimStart();
    // var res = str.trimLeft();
    // console.log(res);
    // console.log(str);

18. trimEnd()
=> 语法: 字符串.trimEnd()
=> 作用: 去除尾部空格
=> 返回值: 去除空格以后的字符串
=> 别名: trimRight()

trimEnd() 去除字符串尾部空格
// var str = ’ 你好 世界 ';
// var res = str.trimEnd();
// var res = str.trimRight();
// console.log(res);
// console.log(str);
19. padStart()
=> 语法: 字符串.padStart(目标长度, ‘填充字符串’)
-> 目标长度: 你想把字符串补充到多长
+ 如果你写的长度小于字符串本身长度, 那么这个函数没有意义
比如说这个字符串长度是10 你想要把这个字符串长度补充到5 这是没意义的 只会给你原样输出
+ 超过长度以后, 用填充字符串补齐
-> 填充字符串: 可以是一个字符, 也可以是多个
+ 多个的时候, 如果超长后面的就不要了
=> 作用: 从前面字符串补齐
=> 返回值: 补齐以后的字符串

     padStart()方法使用
    // var str = '1234';
    // var res = str.padStart(3, 'a'); //本来是4位  你给他补成3位  没有意义  原样输出 1234
    // console.log(res);
    // var res = str.padStart(10, 'a'); //本来4位  想要补成10位  前面多了6个a
    // console.log(res);
    // var res = str.padStart(6, 'abcd'); //本来4位   想要补成6位  前面多了两个ab   剩下的cd不要了
    // console.log(res);

20. padEnd()
=> 语法: 字符串.padEnd(目标长度, ‘填充字符串’)
-> 目标长度: 你想把字符串补充到多长
+ 如果你写的长度小于字符串本身长度, 那么这个函数没有意义
+ 超过长度以后, 用填充字符串补齐
-> 填充字符串: 可以是一个字符, 也可以是多个
+ 多个的时候, 如果超长后面的就不要了
=> 作用: 从后面字符串补齐
=> 返回值: 补齐以后的字符串

 padEnd()方法使用
    // var str = '1234';
    // var res = str.padEnd(3, 'a'); //本来是4位  你给他补成3位  没有意义  原样输出 1234
    // console.log(res);
    // var res = str.padEnd(10, 'a'); //本来4位  想要补成10位   后面多了6个a
    // console.log(res);
    // var res = str.padEnd(6, 'abcd'); //本来4位   想要补成6位  后面多了两个ab   剩下的cd不要了
    // console.log(res);

21. startsWith()
因为我们这个字符串片段可以是一个字母 也可以是两个字母 所以我们写成 starts
=> 语法: 字符串.startsWith(‘字符串片段’)
=> 作用: 判断该字符串是不是以这个字符串片段开始
=> 返回值: 一个布尔值
-> 如果是, 就是 true
-> 如果不是, 就是 false
startsWith() 以什么开始
// var str = ‘hello world 你好 世界’;
// var res = str.startsWith(‘hello’);
// console.log(res);
// var res = str.startsWith(‘world’);
// console.log(res);

22. endsWith()
=> 语法: 字符串.endsWith(‘字符串片段’)
=> 作用: 判断该字符串是不是以这个字符串片段结尾
=> 返回值: 一个布尔值
-> 如果是, 就是 true
-> 如果不是, 就是 false

 endsWith()   以什么结尾
    // var str = 'hello  world  你好   世界';
    // var res = str.endsWith('世界');
    // console.log(res);
    // var res = str.endsWith('hello');
    // console.log(res);

// 所有的字符串方法我们都可以找到的 我们可以在 控制台输入命令 new String() 回车 展开String里面的_proto_:string