内置对象String

5. 字符串对象

5.1 基本包装类型

<script>
        // 基本包装类型
        var str = 'andy';
        console.log(str.length);
        // 对象 才有 属性和方法   复杂数据类型才有 属性和方法 
        // 简单数据类型为什么会有length 属性呢？ 
        // 基本包装类型：  就是把简单数据类型 包装成为了 复杂数据类型 
        // (1) 把简单数据类型包装为复杂数据类型 
        var temp = new String('andy');
        // (2) 把临时变量的值 给 str
        str = temp;
        // (3) 销毁这个临时变量
        temp = null;
</script>

5.2 字符串的不可变

<script>
        // 字符串的不可变性
        var str = 'andy';
        console.log(str);
        str = 'red';
        console.log(str);
        // 因为我们字符串的不可变所以不要大量的拼接字符串
        var str = '';
        for (var i = 1; i <= 1000000000; i++) {
            str += i;
        }
        console.log(str);
</script>

5.3 字符串方法

5.31 根据字符串返回位置

• indexOf(‘char’,index)

• lastIndexOf()

<script>
        // 查找字符串"abcoefoxyozzopp"中所有o出现的位置以及次数
        // 核心算法：先查找第一个o出现的位置
        // 然后 只要indexOf 返回的结果不是 -1 就继续往后查找
        // 因为indexOf 只能查找到第一个，所以后面的查找，一定是当前索引加1，从而继续查找
        var str = "oabcoefoxyozzopp";
        var index = str.indexOf('o');
        var num = 0;
        // console.log(index);
        while (index !== -1) {
            console.log(index);
            num++;
            index = str.indexOf('o', index + 1);
        }
        console.log('o出现的次数是: ' + num);
        // 课后作业 ['red', 'blue', 'red', 'green', 'pink','red'], 求 red 出现的位置和次数
        var colors = ['red', 'blue', 'red', 'green', 'pink', 'red']
        var sum = 0
        var tag = colors.indexOf('red')
        while (tag !== -1) {
            sum++
            console.log('red出现的位置是' + tag);
            tag = colors.indexOf('red', tag + 1)
        }

        console.log('red出现的次数是: ' + sum);

</script>

5.32 根据位置返回字符

• charAt()

• charCodeAt()

• str[]

<script>
        // 根据位置返回字符
        // 1. charAt(index) 根据位置返回字符
        var str = 'andy';
        console.log(str.charAt(3));
        // 遍历所有的字符
        for (var i = 0; i < str.length; i++) {
            console.log(str.charAt(i));
        }
        // 2. charCodeAt(index)  返回相应索引号的字符ASCII值 目的： 判断用户按下了那个键 
        console.log(str.charCodeAt(0)); // 97
        // 3. str[index] H5 新增的
        console.log(str[0]); // a
</script>

5.33 基本方法

<script>
        // 字符串操作方法
        // 1. concat('字符串1','字符串2'....)
        var str = 'andy';
        console.log(str.concat('red'));

        // 2. substr('截取的起始位置', '截取几个字符');
        var str1 = '改革春风吹满地';
        console.log(str1.substr(2, 2)); // 第一个2 是索引号的2 从第几个开始  第二个2 是取几个字符
</script>

5.34 replace()替换

<script>
        // 1. 替换字符 replace('被替换的字符', '替换为的字符')  它只会替换第一个字符
        var str = 'andyandy';
        console.log(str.replace('a', 'b'));
        // 有一个字符串 'abcoefoxyozzopp'  要求把里面所有的 o 替换为 *
        var str1 = 'abcoefoxyozzopp';
        while (str1.indexOf('o') !== -1) {
            str1 = str1.replace('o', '*');
        }
        console.log(str1);
</script>

5.35 split()切分字符转数组

<script>
		// 2. 字符转换为数组 split('分隔符')    前面我们学过 join 把数组转换为字符串
        var str2 = 'red, pink, blue';
        console.log(str2.split(','));
        var str3 = 'red&pink&blue';
        console.log(str3.split('&'));
</script>

5.4 案例

5.41 判断一个字符串 ‘abcoefoxyozzopp’ 中出现次数最多的字符，并统计其次数

<script>
        // 有一个对象 来判断是否有该属性 对象['属性名']
        var o = {
            age: 18
        }
        if (o['sex']) {
            console.log('里面有该属性');

        } else {
            console.log('没有该属性');
            console.log(o['age']);
        }

        //  判断一个字符串 'abcoefoxyozzopp' 中出现次数最多的字符，并统计其次数。
        // o.a = 1
        // o.b = 1
        // o.c = 1
        // o.o = 4
        // 核心算法：利用 charAt(） 遍历这个字符串
        // 把每个字符都存储给对象， 如果对象没有该属性，就为1，如果存在了就 +1
        // 遍历对象，得到最大值和该字符
        var str = 'abcoefoxyozzopp';
        var o = {};
        for (var i = 0; i < str.length; i++) {
            var chars = str.charAt(i); // chars 是 字符串的每一个字符
            if (o[chars]) { // o[chars] 得到的是属性值
                o[chars]++;
            } else {
                o[chars] = 1;
            }
        }
        console.log(o);
        // 2. 遍历对象
        var max = 0;
        var ch = '';
        for (var k in o) {
            // k 得到是 属性名  
            // o[k] 得到的是属性值
            if (o[k] > max) {
                max = o[k];
                ch = k;
            }
        }
        console.log(max);
        console.log('最多的字符是' + ch);
</script>

5.42 字符串练习题

<script>
        // 字符串：“abaasdffggghhjjkkgfddsssss3444343”，问题如下： 
        // 1、 字符串的长度 
        // 2、 取出指定位置的字符，如：0,3,5,9等 
        // 3、 查找指定字符是否在以上字符串中存在，如：i，c ，b等 
        // 4、 替换指定的字符，如：g替换为22,ss替换为b等操作方法 
        // 5、 截取指定开始位置到结束位置的字符串，如：取得1-5的字符串
        // 6、 找出以上字符串中出现次数最多的字符和出现的次数 
        // 7、 遍历字符串，并将遍历出的字符两头添加符号“@”

        var zf = 'abaasdffggghhjjkkgfddsssss3444343'

        // 1、 字符串的长度 
        console.log(zf.length);

        // 2、 取出指定位置的字符，如：0,3,5,9等 
        // console.log(zf[0] + zf[3] + zf[5] + zf[9]);
        console.log(zf.charAt(0) + zf.charAt(3) + zf.charAt(5) + zf.charAt(9));

        // 3、 查找指定字符是否在以上字符串中存在，如：i，c ，b等 
        function check(data, arr) {
            for (var i = 0; i < arr.length; i++) {
                if (data == arr[i]) {
                    return true
                }
            }
            return false
        }
        console.log(check('i', zf))
        console.log(check('c', zf))
        console.log(check('b', zf))

        // 4、 替换指定的字符，如：g替换为22,ss替换为b等操作方法 
        var regex = /g/ig;
        console.log(zf.replaceAll(regex, '22'));
        var regexx = /ss/ig;
        console.log(zf.replaceAll(regexx, 'b'));

        // while(zf.indexOf('aa') !== -1) {
        //     zf=zf.replace('a', '1')
        // }
        // console.log(zf);

        // 5、 截取指定开始位置到结束位置的字符串，如：取得1-5的字符串
        console.log(zf.substr(1, 5))

        // 6、 找出以上字符串中出现次数最多的字符和出现的次数 
        var newZf = {}
        for (var k = 0; k < zf.length; k++) {
            var chars = zf.charAt(k)
            if (newZf[chars]) {
                newZf[chars]++
            } else {
                newZf[chars] = 1
            }
        }
        console.log(newZf);
        var max = 0
        var char
        for (var key in newZf) {
            if (max < newZf[key]) {
                max = newZf[key]
                char = key
            }
        }
        console.log('以上字符串中出现次数最多的字符是' + char + ',出现的次数是' + max);
        
        // 7、 遍历字符串，并将遍历出的字符两头添加符号“@”
        var str = '@'
        for (var j = 0; j < zf.length; j++) {
            console.log(str + zf[j] + str)
        }

</script>

5.43 6翻了

<script>
        // 从左到右扫描输入的句子：
        // 如果句子中有超过 3 个连续的 6，则将这串连续的 6 替换成 9；
        // 但如果有超过 9 个连续的 6，则将这串连续的 6 替换成 27。其他内容不受影响，原样输出。
        var str='it is so 666 really 6666 what else can I say 6666666666'
        console.log(str);
        
        var sixBegin=str.indexOf('6')
        var sixStr=str.charAt(sixBegin)
        while(sixStr.length<3){
            sixBegin=str.indexOf('6',sixBegin+1)
            sixStr+=str.charAt(sixBegin)
        }

        var sixBegin1=str.indexOf('6')
        var sixStr1=str.charAt(sixBegin1)
        while(sixStr1.length!=4){
            sixBegin1=str.indexOf('6',sixBegin1+1)
            sixStr1+=str.charAt(sixBegin1)
        }

        var sixBegin2=str.indexOf('6')
        var sixStr2=str.charAt(sixBegin2)
        while(sixStr2.length!=10){
            sixBegin2=str.indexOf('6',sixBegin2+1)
            sixStr2+=str.charAt(sixBegin2)
        }
        str=str.replace(sixStr,'9')
        str=str.replace(sixStr1,'9')
        str=str.replace(sixStr2,'27')
        console.log(str);
</script>