2021-07-30 es6 -第4章和String复习

// An highlighted block
        const a = 'abc';
        console.log(a + a.length);
        // 1.获取某一指点索引值位置上的字符 string.charAt(默认索引0) 
        console.log(a.charAt(0));
        // 1.1 识别存储大于2个字节的字符 string.at()这个的使用还要学习
        // const b = new String('𠮷');
        // console.log(b.charAt(0));
        // console.log('𠮷'.at(0));
        // console.log(a.at(0));

        // 2.查询某个位置上的字符的unicode的值（但不超出0xFFFF) string.charCodeAt(所有超出范围的都默认0)  
        console.log(a.charCodeAt(0));
        // 2.1 若想查询超出0xFFFF的字符 使用string.codePointAt()，但是返回值是十进制;
        const s = '𠮷a';//𠮷 需要4个字节储存，即2个字符，所以length=3
        console.log(s.length);//因为javascript是utf-16格式储存，放下2个字节，把𠮷 成第1-2个字符，把s当成第3个字符
        console.log(s.charAt(0));//‘’
        //正确识别 𠮷 ，返回十进制码点
        console.log(s.codePointAt(0));//134071
        //第二个字符是 𠮷 的后2个字节
        console.log(s.codePointAt(1));//57271
        //第三个字符就是 a ，常规的2位字节的字符，结果与charCodeAt()一样。
        console.log(s.codePointAt(2) === s.charCodeAt(2));//true
        // 2.2 返回值是十进制，就要使用toString(16)转换
        s.codePointAt(0).toString(16);//20bb7
        // 发现，a的位置理论是 1 而不是2 ，因此可以通过for...of 循环来，正确识别32位的utf-16字符
        s.codePointAt(2).toString(16);

        // 3.通过unicode编码来输出字符串
        // 3.1 常规字符 String.fromCharCode()
        console.log(String.fromCharCode(65, 66, 67));
        // 3.2 32位utf-16字符 String.fromCodePoint()
        console.log(String.fromCodePoint(0x20BB7));

        // 4.字符串的链接 string.concat() 或者使用 +、+=(推荐使用)
        const greenList = ['hello', ' ', 'world', '!'];
        console.log(''.concat(...greenList));
        console.log(''.concat({}));//[object Object]
        console.log(''.concat(null));//null
        console.log(''.concat([]));//''

        // 5.判断一个字符串 是否 以某个给定的子字符串 开头或包含、结尾
        // 5.1 开头 string.startsWith()
        // 5.2 结尾 string.endsWith()
        // 5.3 包含 string.inludes() 区分大小写

        const ss = 'Hello World!';
        console.log(ss.startsWith('Hello '));//true
        console.log(ss.endsWith('!'));//true
        console.log(ss.includes(' W'));//true
        // 5.4 支持第二个参数 代表开始搜索的位置
        console.log(ss.startsWith('Hello ', 0));//true
        // endWith不同之处，在位置之前 查找
        console.log(ss.endsWith('Hello', 5));//true
        console.log(ss.includes(' W', 6));//false
        // 5.5 通过正则来查找，返回首次匹配的首位的索引
        var str = "hey JudE";
        var re = /[A-Z]/g;
        var re2 = /[.]/g;
        console.log(str.search(re)); // returns 4, which is the index of the first capital letter "J"
        console.log(str.search(re2)); // returns -1 cannot find '.' dot punctuation


        // 6.查找某子字符串在原字符串的位置
        //  没有找到返回-1，找到返回子字符串首个字符的所在的索引值
        // 6.1 顺着从左到右找 string.indexOf(stringvlue,[fromindex=0])
        const k = 'Brave new world';
        // (1)fromindex默认为0, 0-string.length之间，超出或未达的都是就近取整原则
        console.log(k.indexOf('new'));//6
        console.log(k.indexOf('new', 3));//6
        // (2)如查询值为空，要注意，开始位置小于查询字符串的长度，则输出fromindex，否则输出字符串长度
        console.log(k.indexOf(''));//0
        console.log(k.indexOf('', 3));//3
        console.log(k.indexOf('', 13));//13
        // (3)区分大小写
        console.log(k.indexOf('New'));//-1
        // 6.2 从右往左找 string.lastIndexOf(stringvalue[,fromindex=string.length-1])
        // (1)fromindex默认为string.length-1,  0-string.length之间，超出或未达的都是就近取整原则
        // (2)如查询值为空，要注意，返回fromindex
        console.log(k.lastIndexOf(''));//15
        console.log(k.lastIndexOf('', 3));//3
        // (3)区分大小写
        // (4)注意，返回的是子字符串首字符所在的位置的索引值
        console.log("The index of the first w from the beginning is " + k.indexOf("w"));
        // Displays 8
        console.log("The index of the first w from the end is " + k.lastIndexOf("w"));
        // Displays 10

        console.log("The index of 'new' from the beginning is " + k.indexOf("new"));
        // Displays 6
        console.log("The index of 'new' from the end is " + k.lastIndexOf("new"));
        // Displays 6

        // 7.以正则表达式为标准去检索匹配的字符 不详细学习
        const newstr = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
        const regexp = /[A-E]/gi;
        console.log(newstr.match(regexp));// ['A', 'B', 'C', 'D', 'E', 'a', 'b', 'c', 'd', 'e']

        // 8.填充字符串
        // 8.1 往右填充 string.padEnd(targetLength[,string=''])
        // targetlength是最后的字符串的长度
        console.log('x'.padEnd(5, 'ab'));//xabab
        // 8.2 往左填充 string.padStart(targetLength[,string=''])
        console.log('x'.padStart(5, 'ab'));//ababx
        console.log('x'.padStart(5));//    x
        //8.3 targetLength =< 原字符串长度，则返回原字符串
        console.log('xxx'.padStart(2, 'ab'));//xxx
        // 如果结合后的字符串长度大于tarfetL,则截取一部分的补全字符串
        console.log('09'.padStart(10, 'YYYY-MM-DD'));//YYYY-MM-09

        // 9.重复字符串
        // str.repeat(count) count会取整，只有负数或Indefined会报错，其余 0~-1=0；NaN=0（即其余都为0）
        console.log('x'.repeat(3));//xxx
        console.log('x'.repeat(2.6));//xx
        console.log('x'.repeat(-0.9));//''
        console.log('x'.repeat(NaN));//''
        // 如果参数是字符串会先转成数字
        console.log('x'.repeat('3'));//xxx
        console.log('x'.repeat('na'));//''

        // 10.代替字符串中的某些内容
        // 10.1 string.repalce(regexp|substr, newSubStr|function) function功能比较强大
        const p = 'The quick brown fox jumps over the lazy dog. If the dog reacted, was it really lazy?';
        // 注意： 如果第一个参数是字符串，只能替换第一个
        console.log(p.replace('dog', 'monkey'));
        // expected output: "The quick brown fox jumps over the lazy monkey. If the dog reacted, was it really lazy?"
        const regex = /Dog/i;
        console.log(p.replace(regex, 'ferret'));
        // expected output: "The quick brown fox jumps over the lazy ferret. If the dog reacted, was it really lazy?"
        console.log(p.replace(/Dog/ig, 'ferret'));
        // expected output: "The quick brown fox jumps over the lazy ferret. If the ferret reacted, was it really lazy?"
        // 10.2 string.replaceAll(regexp|substr, newSubstr|function)  可以替换所有符合条件的值
        // 注意：使用正则时，必须只能使用全局修饰符
        console.log(p.replaceAll(/Dog/g, 'ferret'));

        // 11.截取字符串的一部分
        // 11.1 依据索引号拆分 string.slice(startIndex[,endIndex])
        // 截取部分，不包含endIndex上的字符[包前不包后]
        const str1 = 'wo shi shei who am i.';
        console.log(str1.slice());//wo shi shei who am i.
        console.log(str1.slice(1));///o shi shei who am i.
        console.log(str1.slice(1, -1));//o shi shei who am i
        console.log(str1.slice(-1));//.
        console.log(str1.slice(-4, -1));//m i
        // 11.2 索引切片，但是这个更加多规则 str.substring(indexStart[, indexEnd])[包前不包后]
        // 如果 indexStart 大于 indexEnd，则 substring 的执行效果就像两个参数调换了一样。
        // 任意参数小于0或NaN 当作 0；大于 字符串长度 当作 字符串的长度

        const 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));


        // 11.3 依据一定的分割符将字符串分割成字符串数组 split([separator[, limit]])
        const str2 = 'The quick brown 1 fox jumps over 2 the lazy dog.';
        console.log(str2.split());//["The quick brown fox jumps over the lazy dog."]
        console.log(str2.split(''));//(44) ["T", "h", "e", " ", "q", "u", "i", "c", "k".....]
        console.log(str2.split(' '));//(9) ["The", "quick", "brown", "fox", "jumps", "over", "the", "lazy", "dog."]
        console.log(str2.split(' ', 3));//(3) ["The", "quick", "brown"]
        console.log(str2.split(/(\d)/, 3));//(3) ["The quick brown ", "1", " fox jumps over "]

        // 12. 大小写的转换
        // 12.1 转化为小写 
        // (1)str.toLocaleLowerCase([locale]) 根据语言环境更换适合的小写，返回根据任意区域语言大小写映射集而转换成小写格式的字符串，不会改变原来的字符串
        // (2)str.toLowerCase() 返回新字符串
        console.log("ALPHABET".toLowerCase());// "alphabet"
        // 12.2 转化为大写
        // (1)str.toLocaleUpperCase() 方法根据本地主机语言环境把字符串转换为大写格式，并返回转换后的字符串。
        const city = 'istanbul';
        console.log(city.toLocaleUpperCase('en-US')); // expected output: "ISTANBUL"
        console.log(city.toLocaleUpperCase('TR'));// expected output: "İSTANBUL"
        // (2)str.toUpperCase() 返回新字符串

        // 13. 字符串消除空格
        // (1)str.trim()从一个字符串的两端删除空白字符(space, tab, no -break space 等 )
        // (2)str.trimRight()|| str.trimEnd() 从一个字符串的末端移除空白字符
        // (3)str.trimLeft() || str.trimStart() 从一个字符串的开头端移除空白字符

        // 14.返回原始值或字符串形式
        // (1)str.toString() 方法返回指定对象的字符串形式。 针对字符串对象
        // (2)str.valueOf() 方法返回  String  对象的原始值
        const stringObj = new String('foo');

        console.log(stringObj);
        // expected output: String { "foo" }
        console.log(stringObj.valueOf() === stringObj.toString());//true