js string方法与数组[ ]方法

string方法

字符串查询

// 待检测的字符串.indexOf(检测字符)；返回结果-1，在这个字符串中没有这个子字符，非-1有
        // indexOf() 作用：检测某个字符是否在另一个字符串中出现
        
         var str = 'kkgkkkkjhhnghg';
         str = new String(str);
         console.log(str);
         var strChild = 'j';
         var res = str.indexOf(strChild);
         console.log(res);
		
        // lastIndexOf() 作用:检索某一个字符，在一个字符串中最后一次出现的位置；返回：出现的位置      -1 没有该字符
        // 语法： 字符串.lastIndexOf(查询的字符)
		var res1 = str.lastIndexOf('g');

        if(str.indexOf('') !== -1){
            // 表示在str中检索到''  业务。。。
        }
        // 如果一个业务中没有这个字符 则...
        if(str.indexOf('ddd') === -1) {
            // 这里处理没有'ddd' 字符串的业务
        }

        // match()
        var str1 = 'jfoweuro';
        var res3 = str1.match('kk');
        // match(正则)根据正则表达式匹配字符串并返回匹配结果，无 null  有 返回匹配结果【组成的数组】
        var res2 = str1.match(/\d/g);// /\d/g  \d 表示查找数字    g表示 全局查找
        console.log(res2);
        // match()正则校验 验证字符
        
  

字符串截取

// slice(startindex,endindex) 截取字符片段 从第几个索引值开始，到第一个索引值结束，返回截取字符的片段
        var str = 'jfwjffllldjjdlk2896354';
        str = new String(str);
        console.log(str);
        var res = str.slice(3,6);// 包含3，不包含6
        console.log(res);
        // 参数只有一个，表示从第几个开始，截取到最后一个
        var res1 = str.slice(5);
        console.log(res1);


        // substr(startindex,length);作用：截取字符片段，返回字符片段
        //  startindex 表示第几个字符开始
        // length 表示截取字符长度
        var str1 = 'jkskrjblslbnxd';
        str1 = new String(str1);
        var res2 = str1.substr(3,5);
        console.log(res2);

        // substring(startindex,endindex);作用：截取字符长度，返回一个子字符
        // startindex 从第几个索引值开始
        // endindex 到第几个索引值结束（不包含endindex）
        var str2 = 'djgknnkkkrtask';
        var res3 = str.substring(3,5);
        console.log(res3);

字符串变数组

// 字符串变数组的方式
        // split(reg,len);切割字符，并返回切割后的【数组】
        // reg 表示配置字符，从匹配的字符开始切割
        // len 切割后返回数组的长度，没有：返回最大长度
        var className = 'icon,color,box,icon1';
        var calssArr = className.split(/,/g);//最长
        var calssArr1 = className.split(/,/g,2);//长度为2
        console.log(className);
        console.log(calssArr);
        console.log(calssArr1);

        // split 完成 , 替换 ''
        var str = '';
        for(x in calssArr){
            str += calssArr[x];
        }
        console.log(str,'完成将,替换\'\'');

替换

var str = '聪明人傻子人笨人';
        // replace(reg,newStr) reg正则匹配  用newStr 替换匹配的结果
        // 匹配 str 中 人 字符 替换为狗
        // res 接收 replace 替换后结果
        var res = str.replace(/人/g,'狗');
        console.log(str);// 字符串自身没变化
        console.log(res);// 返回替换结果 日本狗美国狗韩国狗

        var str1 = 'a,b，c';
        var str2 = str1.replace(/c/g,'r');
        console.log(str2);
        // 要想匹配某个字符 简单正则  /[待匹配字符]/g

数组[ ]方法

删除

 // delete 删除数据：数组长度不变 for...in... 不会遍历删除的元素
        var arr = new Array(1,3,4,5,'dd','dee',[]);
        delete arr[3];
        console.log(arr);
        console.log(arr.length);
        for(var i=0;i<arr.length;i++){
            console.log(arr[i]);
        }
        console.log(arr.constructor);//Array()

		var arr = [1,3,'hhh'];
        
        // pop() 删除数组最后一个元素，返回被删除的元素
        // 注意：改变的是数组本身
        var res = arr.pop();
        console.log(res,arr);
        // shift() 从头部删除 返回被删除的元素
        // 注意：改变的是数组本身
        var res1 = arr.shift();
        console.log(arr,res1);

添加

		var arr = [1];
        // push() 改变数组本身，在数组尾部添加元素，并返回数组长度
        // 参数：增加的数据,可以传递无数个
        var res = arr.push('我是新增内容',3,4,5);
        console.log(res,arr);//5 [1, "我是新增内容", 3, 4, 5]
        // unshift() 从数组头部添加数据，返回数组长度
        // 参数：添加的数据
        var res1 = arr.unshift('头部添加');
        console.log(res1,arr);//6   ["头部添加", 1, "我是新增内容", 3, 4, 5]
        // concat() 合并数组 返回合并后数组，数组本身无变化
        // 参数：被合并的数组
        var arr1 = [1,2,3,4,5];
        var arr2 = ['dd','dddd'];
        // 将arr2 与 arr1进行合并，返回合并后数组，res接收
        var res = arr1.concat(arr2);
        console.log(res,arr1);

删替插

		var arr = [1,'333',true,'333',44,55,66,44,6];
        // splice() 删除 替换 插入
        // 1.一个参数：删除，从索引值元素开始，一直删除到最后，返回删除元素组成的数组
        // 注意：原来数组发生改变
        // 2.splice(index,len) 从索引值index开始 删除len个元素，返回len个元素组成的数组
        // 注意：原来数组发生改变
        // 3.3个以上参数：作用：替换或插入；表示：从索引值元素开始，删除len个元素，从删除位置开始插入【参三】后面的参数
        // var res = arr.splice(3);//删除索引值为3以后的数据
        // var res = arr.splice(3,2);//从第3个索引值开始，删除2个，'333'，44  返回['333',44 ]
        // var res = arr.splice(3,2,'替换1','替换2');//从索引值为3开始删除2个元素，将'cc','dd' 替换删除元素'333'，44
        // 插入 不删除只新增
        var res = arr.splice(2,0,'ddd','aa');// 从第二个索引值开始 删除0个 插入2个元素
        console.log(res,arr);

其他方法

		var arr = [1,2,3,4,5,6,7,'ddd','ddd','aa'];
        // slice(startindex,endindex) 截取数组中片段，返回截取内容的数组
        // startindex 从第几个索引值开始，包含本数
        // endindex 到第几个索引值结束，不包含本数
        // 截取内容 startindex，小于endindex
        var res = arr.slice(2,5);
        console.log(res,arr);

        // reverse()颠倒数组：例如原来升序，颠倒后降序
        var arr1 = [['ddd'],1,2,43,5,6];
        var res1 = arr1.reverse();
        console.log(res1,arr1);

模拟数组方法

// splice模拟push
        var arr = [1,2,4];
        arr.splice(arr.length,0,'ddd');
        console.log(arr);//[1, 2, 4, "ddd"]
        // splice模拟unshift
        arr.splice(0,0,'ccc');
        console.log(arr);//["ccc", 1, 2, 4, "ddd"]
        // splice模拟pop()
        arr.splice(arr.length-1,1);
        console.log(arr);//["ccc", 1, 2, 4]
        // splice模拟shift()
        arr.splice(0,1);
        console.log(arr);//[1, 2, 4]
        // splice模拟concat 方法
        var arr4 = [1,2,3];
        var arr5 = [3,4,4,6,8,9];
        var res;
        for(x in arr5){
            arr4.splice(arr4.length,0,arr5[x]);
        }
        res = arr4;
        console.log(res);


        // push模拟concat
        var arr1 = [1,2,6];
        var arr2 = ['1'];
        for(x in arr2){
            arr1.push(arr2[x]);
        }
        console.log(arr1);




// 模拟reverse
        // 方式一
        var res = [];
        for(var i=0;i<arr.length;i++){
            res.unshift(arr[i]);//将后面数据添加到前面
        }  
        console.log(res);

        // 方式二
        var arr1 = [1,2,3,4,5,6];
        var arr2 = [];
        for(var i=arr1.length-1;i>=0;i--){
            arr2.push(arr1[i]);
        }
        console.log(arr2);

        // 方式三
        var arr3 = [1,2,3,4,5,6];
        var len = arr3.length;
        for(var i = 0;i<arr3.length;i += 2){
            arr3.unshift(arr3[i]);
        }
        arr3.splice(len);
        console.log(arr3);