js重装第九天字符串对象方法大全-CSDN博客

本文链接：https://blog.csdn.net/qq_42507764/article/details/127911924

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    


    <script>
        // 封装一个函数，传入数组为实参，数组中都是数字
            // 将 实参数组中大于50的值 返回  返回的是一个数组
            // 就是实现一个类似 数组的filter()方法 --- 不能使用 filter方法

        function fn1(narr,num){

            var arr = [];
            
            narr.forEach(function(item){
                if(item>num){
                    arr.push(item);
                }
            });

            return arr;
        }

        var arr1 = fn1([23,66,82,34,17,90,33,66,81],50);
        console.log(arr1);  // [66, 82, 90, 66, 81]

        var arr2 = fn1([23,66,82,34,17,90,33,66,81],20);
        console.log(arr2);  // [23, 66, 82, 34, 90, 33, 66, 81]



        // 编写函数 has(arr,60)  判断数组中是否存在 60这个元素，
        // 返回值为布尔类型，存在返回true，不存在返回false

        function has(narr,n){

            for(var i in narr){
                if(narr[i] === n){
                    return true;
                }
            }

            return false;
        }

        var f1 = has([22,66,99,false,true,'hello','hehe'],99);
        console.log(f1);  // true

        var f2 = has([22,66,99,false,true,'hello','hehe'],666);
        console.log(f2);  // false
        



        // 编写函数 map(arr) 把数组中的每一位数字都增加 30%，返回值为 新的数组
            // 增加 30%后，保留2位小数
            // 传入的数组中每个元素都是数值

        function map(narr){

            for(var i=0;i<narr.length;i++){
                narr[i] *= 1.3;   // narr[i] = narr[i]*1.3
            }

            return narr;
        }

        var arr4 = map([5,11,22,33,27,44,34,55,66]);
        console.log(arr4);  // 


        // 把 数组去重  冒泡排序  搞懂
        
        // 有事就预习一下选择排序 



        
        // var num = 12.347456
        // console.log(num);
        // num = num.toFixed(3);
        // console.log(num);
        // num =  +num;
        // console.log(num);
    </script>
</body>
</html>

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    


    <script>

        var numarr = [88,34,76,25,69,12,5];
        console.log(numarr);    // [88,34,76,25,69,12,5]
                                //   i
                                //      i
                                //            i
                                //                  i
                                //                    i
                                // [5,34,76,25,69,12,88]
                                //     i
                                //           i
                                //                 i
                                // [5,12,76,25,69,34,88]
                                //        i
                                //           i
                                // [5,12,25,76,69,34,88]
                                //           i
                                //              i
                                //                 i
                                // [5,12,25,34,69,76,88]
                                //              i
                                // [5,12,25,34,69,76,88]
                                //                 i
                                // [5,12,25,34,69,76,88]

        debugger;;
        for(var i=0;i<numarr.length-1;i++){
            // 假设 当前这一个索引的值就是最小值，用 索引假设
            var minIndex = i;
            
            for(var j=i+1;j<numarr.length;j++){
                if(numarr[minIndex]>numarr[j]){
                    minIndex = j;
                }
            }

            var x = numarr[minIndex];
            numarr[minIndex] = numarr[i];
            numarr[i] = x;
        }




    </script>
</body>
</html>

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    

    <script>
        // 对象 Object
            // 对象是 一个 无序 数据的集合
            // 在对象中 可以 存储多个值，可以使任意类型的值
            // 对象中的成员 是以 key:value 的形式存在 键:值   属性:属性值

        // 对象的创建
            // 构造函数方式创建
                // 在js中内置了一个构造函数 Object,，在调用这个函数前 加上 new关键字
                // 空对象
                var obj1 = new Object();
                console.log(obj1);  // {}
                // 
                var obj2 = new Object({aaa:111,bbb:222,ccc:[1,2,3,4],ddd:true});
                console.log(obj2);  // {aaa: 111, bbb: 222, ccc: Array(4), ddd: true}

            // 字面量方式创建
                var oobbjj11 = {}
                console.log(oobbjj11);  // {}

                var oobbjj22 = {
                    name: '闪电五连鞭',
                    age: 55,
                    sex: '男'
                }
                console.log(oobbjj22);  // {name: '闪电五连鞭', age: 55, sex: '男'}
            

            // 对象的数据类型  属于 引用数据类型(复杂数据类型、对象数据类型)
                console.log(typeof obj2);  // 'objece'
                console.log(typeof oobbjj22);  // 'object'

            // 引用数据类型(复杂数据类型、对象数据类型)
                // function
                // Array
                // Object

            
            // 操作对象是通过对象的 键 实现
                // 语法：对象.键
                // 可以实现 对于 对象的 查(查看访问) 增(增加) 改(改变) 删(删除)

                // 查(查看访问)
                var a = oobbjj22.name
                console.log(a);  // '闪电五连鞭'
                console.log(oobbjj22.age);  // 55

                // 增(增加) --- 对于 原本不存在的键 赋值就是 增加
                oobbjj22.hello = '大意了没有闪';
                oobbjj22.fn = function(){
                    alert('你们好啊')
                }
                console.log(oobbjj22);   // {name: '闪电五连鞭', age: 55, sex: '男', hello: '大意了没有闪'}

                // 改(改变) --- 对于 原本存在的键 赋值就是 改变
                oobbjj22.sex = '女';
                console.log(oobbjj22);  // {name: '闪电五连鞭', age: 55, sex: '女', hello: '大意了没有闪'}

                // 删(删除) --- 在 操作前 加上 delete关键字即可
                delete oobbjj22.age;
                console.log(oobbjj22);  // {name: '闪电五连鞭', sex: '女', hello: '大意了没有闪'}


        // 如果 操作对象时 对象的键以变量的形式存在，不能使用点的语法，应当把点换成中括号
        var abc = 'uiuiui';

        oobbjj22[abc] = 999;
        console.log(oobbjj22);  // {name: '闪电五连鞭', sex: '女', hello: '大意了没有闪', uiuiui: 999}
    
    
        // 对象的遍历 --- for...in循环
        for(var item in oobbjj22){
            // console.log(item);  // 对象的键

            console.log(oobbjj22[item]);  // 
        }



        console.log(oobbjj22.fn);  //   
        oobbjj22.fn();
    </script>
</body>
</html>

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    


    <script>
        // arguments 对象
            // 在函数调用时 会 在函数内部自动产生 arguments 对象
            // arguments 对象 会 把 函数的所有实参 以 数组的形式接收 ---- 类数组(伪数组)
                // 每一个实参 就是 arguments对象 的 一项元素
            // 类数组(伪数组) --- 类似数组，但是不是真的数组
            // 使用场景：当定义一个函数，又不确定需要传入实参的数量，就可以使用 arguments对象


        // 封装一个函数，用来计算 传入参数的数字 相加之和
            // 但是 传入实参的数量不确定
        function fn1(){
            // console.log(arguments);

            var sum = 0;

            for(var i=0;i<arguments.length;i++){
                // console.log(arguments[i]);
                sum += arguments[i];
            }
            
            return sum;
        }

        var num1 = fn1(1,2,3,4);
        console.log(num1);  // 10

        var num2 = fn1(11,22,33,44,55);
        console.log(num2);  // 165


        // console.log([1,2,3,4,5,6,7])
    </script>
</body>
</html>

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    

    <script>
        // 字符串对象   String
            // String对象是 JavaScript 原生提供的三个包装对象之一，用来生成字符串对象。
            // String对象也是JS内置对象中使用频率最高的之一。
            // 字符串对象 其实也是 以 数组形式存在的，是一个类数组(伪数组)

        // 创建字符串
            // 字面量方式创建 --- 通过 单引号 或 双引号
                var str1 = 'hello world!!!';
                console.log(str1);  // 'hello world!!!'
                console.log(typeof str1);  // 'string'

                var str2 = "你好 世界！！！";
                console.log(str2);  // "你好 世界！！！"
                console.log(typeof str2);  // 'string'

            
            // 构造函数方式创建 --- js内置了一个 String构造函数，调用前加 new关键字
                var ostr1 = new String('我们每天都要快乐哦');
                console.log(ostr1);  // '我们每天都要快乐哦'
                console.log(typeof ostr1);  // 'object'

                var ostr2 = new String('my name is dashuaige');
                console.log(ostr2);  // 'my name is dashuaige'
                console.log(typeof ostr2);  // 'object'

        // 通过 字面量方式 和 构造函数方式 创建的字符串使用是没有区别，
        // 只不过检测到的数据类型不一样，但不影响使用，使用时是一样的
            // console.log(1+str1);  // '1hello world!!!'
            // console.log(2+str2);  // '2你好 世界！！！'
            // console.log(3+ostr1);  // '3我们每天都要快乐哦'


        // 索引 --- 字符串的索引可以实现对字符串中字符的访问，但不能增加和改变
            var a = ostr1[3];
            console.log(a);  // '天'
            var b = str1[7];
            console.log(b);  // 'o'

        // 长度 --- 表示 字符串中字符的个数
            console.log(ostr2.length);  // 20
            console.log(str2.length);  // 8

        
        // 遍历
            for(var i=0;i<ostr2.length;i++){
                console.log(ostr2[i]);
            }

            for(var j in str2){
                // console.log(j);
                console.log(str2[j]);
            }
    </script>
</body>
</html>

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    

    <script>
        // 在 参与比较的双方中 只有 一方是字符串，就会将 这个字符串 隐式转换成number 比较
        console.log(33>'5');  // true       33>5
        console.log('3'>true);  // true      3>1

        // 但是如果 比较双方都是 字符串，就不会进行隐式类型转换，
        // 而是按照 字符 在 ascii字符集编码表中的 编码号 来 进行比较了
        console.log('33'>'5');  // false


    // 在 ASCII编码表中
        // 48～57为0到9十个阿拉伯数字
        // 65～90为26个大写英文字母，
        // 97～122号为26个小写英文字母

    // 字符串比较规则
        // 使用双方的 第一个字符 进行比较，得到结果
        // 如果 第一个字符是一样的，就比较 第二个字符 得到结果
        // 如果 第二个字符也是一样的，就比较 第三个字符 得到结果
        // 一次类推
            console.log('33'>'5');  // false

            console.log('496'>'abc');  // false
            
            console.log('abc'>'496');  // true

            console.log('abc'>'ABC');  // true
            
    </script>
</body>
</html>

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    

    <script>

        var str1 = 'hello world!!!';
        console.log(str1);

        // charAt(index)    返回在指定索引位置的字符
            // 参数：索引(下标)
        var a = str1.charAt(3);
        console.log(a);  // 'l'

        var b = str1.charAt(7);
        console.log(b);  // 'o'

        
        // charCodeAt(index)    返回在指定索引位置的字符的 Unicode 编码
        var c = str1.charCodeAt(4);
        console.log(c);  // 111

        var d = str1.charCodeAt(5);
        console.log(d);  // 32


        // indexOf(字符串,index)    返回某个指定的字符串值在字符串中首次出现的位置
            // 参数1：指定的字符串字符
            // 参数2：开始查找的索引位置 --- 可以忽略不提供，默认就从0开始查找
            // 注：如果字符串中存在这个字符返回对应的索引，如果不存在返回-1
        var e = str1.indexOf('o');
        console.log(e);  // 4
        
        var f = str1.indexOf('s');
        console.log(f);  // -1

        var g = str1.indexOf('o',5);
        console.log(g);  // 7


        // lastIndexOf(字符串,index)    返回某个指定的字符串值在字符串中最后出现的位置
            // 参数1：指定的字符串字符
            // 参数2：结束查找的索引位置 --- 可以忽略不提供，默认是查找到字符成的最后
            // 注：如果字符串中存在这个字符返回对应的索引，如果不存在返回-1
        var h = str1.lastIndexOf('o');
        console.log(h);  // 7

        var i = str1.lastIndexOf('s');
        console.log(i);  // -1

        var j = str1.lastIndexOf('l');
        console.log(j);  // 9

        var k = str1.lastIndexOf('l',6);
        console.log(k);  // 3


        var str2 = 'TaogEzuijInKeNengbuHuitAnGtoULe';
        console.log(str2);


        // toLowerCase()        把字符串转化为小写
        var l = str2.toLowerCase();
        console.log(l);  // 'taogezuijinkenengbuhuitangtoule'


        // toUpperCase()        把字符串转化为大写
        var m = str2.toUpperCase();
        console.log(m);  // 'TAOGEZUIJINKENENGBUHUITANGTOULE'


        // substr(start,length)     截取指定个数的字符：从起始索引号提取字符串中指定个数的字符
            // 参数1: 开始截取字符串的 索引位置，包含此索引位置
            // 参数2：截取字符的个数 --- 可以忽略不提供，就会截取到字符串结束
        var n = str2.substr(4);
        console.log(n);  // 'EzuijInKeNengbuHuitAnGtoULe'
        
        var o = str2.substr(8,6);
        console.log(o);  // 'jInKeN'


        // substring(start,stop)    截取指定区间的字符:提取字符串中两个指定的索引之间的字符
            // 参数1: 开始截取字符串的 索引位置，包含此索引位置
            // 参数2：结束截取字符串的 索引位置，不包含此索引位置 --- 可以忽略不提供，就会截取到字符串结束
        var p = str2.substring(4);
        console.log(p);  // 'EzuijInKeNengbuHuitAnGtoULe'
        
        var q = str2.substring(8,11);
        console.log(q);  // 'jIn'
        

        // slice(start,stop)    截取指定区间的字符:提取字符串中两个指定的索引之间的字符
            // 参数1: 开始截取字符串的 索引位置，包含此索引位置
            // 参数2：结束截取字符串的 索引位置，不包含此索引位置
                // 可以忽略不提供，就会截取到字符串结束
                // 可以指定负值
        var r = str2.slice(4);
        console.log(r);  // 'EzuijInKeNengbuHuitAnGtoULe'
        
        var s = str2.slice(8,11);
        console.log(s);  // 'jIn'

        var t = str2.slice(8,-5);
        console.log(t);  // 'jInKeNengbuHuitAnG'
        

        var str3 = 'zhebiandehuawomenjiusuibianxiedianba';
        console.log(str3);


        // split()      通过指定字符 将字符串分割成数组，返回分割好的数组
            // 参数：一个字符 
                // 如果不传参，整个字符串就是数组的一项元素
                // 如果传入空字符串，字符串的每个字符就会是 数组的一项元素
                // 如果传入一个字符，就是使用这个字符将数组分割成数组，字符串中的这个传入的字符就是分割的节点
        var u = str3.split();
        console.log(u);  // ['zhebiandehuawomenjiusuibianxiedianba']

        var v = str3.split('');
        console.log(v);  // ['z', 'h', 'e', 'b', 'i', 'a', 'n', 'd', 'e', 'h', 'u', 'a', 'w', 'o', 'm', 'e', 'n', 'j', 'i', 'u', 's', 'u', 'i', 'b', 'i', 'a', 'n', 'x', 'i', 'e', 'd', 'i', 'a', 'n', 'b', 'a']

        var w = str3.split('a');
        console.log(w);  // ['zhebi', 'ndehu', 'womenjiusuibi', 'nxiedi', 'nb', '']
        
        var x = str3.split('an');
        console.log(x);  // ['zhebi', 'dehuawomenjiusuibi', 'xiedi', 'ba']


        // replace('xx','yy')  替换字符串
            // 参数1：被替换的字符
            // 参数2：用来替换的字符
        var y = str3.replace('a','A');
        console.log(y);  // 'zhebiAndehuawomenjiusuibianxiedianba'

            // for(var abc=0;abc<str3.length;abc++){
            //     if(str3[abc] === 'a'){
            //         str3 = str3.replace('a','A');
            //     }
            // }
            // console.log(str3);  // 'zhebiAndehuAwomenjiusuibiAnxiediAnbA'

                
        var str4 = 'abcdefg';
        console.log(str4);


        // repeat(num)   复制字符串指定次数，并将它们连接在一起返回
            // 参数 是 数字
        var z = str4.repeat(4);
        console.log(z);  // 'abcdefgabcdefgabcdefgabcdefg'
                

        var str5 = '    jfkasa fsajkfasjdf  fjaskdfsja       '
        console.log(str5);  
    
        
        // trim()   会从一个字符串的两端删除空白字符。
        var a1 = str5.trim();
        console.log(a1);  // 'jfkasa fsajkfasjdf  fjaskdfsja'

    </script>
</body>
</html>