数组方法和字符串方法

最新推荐文章于 2024-08-16 21:49:16 发布

薛定谔的猫451

最新推荐文章于 2024-08-16 21:49:16 发布

阅读量53

点赞数

文章标签：数据结构

本文链接：https://blog.csdn.net/qq_59628915/article/details/130376394

版权

数组对象

数组类型检测

数组类型检测有两种方法：instanceof运算符和使用Array.isArray()方法。

var arr = [];
var obj = {};
/第一种方式
console.1og (arr instanceof Array);//输出结果：true
console.1og (obj instanceof Array);//输出结果：false
//第二种方式
console.1og (Array.isArray (arr));//输出结果：true
console.1og (Array.isArray (obj));//输出结果：false

添加或删除数组元素

方法名	功能描述	返回值
push(参数 1...)	数组未尾添加一个或多个元素，会修改原数组	返回新数组长度
unshift(参数 1...)	数组开头添加一个或多个元素(把数组长度-1，无参数)，会修改原数组	返回新数组长度
pop()	删除数组最后一个元素，若为空数组则返回undefined,会修改原数组	返回删除的元素值
shift()	删除数组第一个元素，若为空数组则返回undefined,会修改原数组	返回第一个元素的值

        console.log('======push====');
        // push在末尾添加一个或多个元素，返回元素个数
        var arr1 = ['pink','black','white','yellow']
        console.log(arr1.push('red'));//输出结果：5
        console.log(arr1);//输出结果：['pink', 'black', 'white', 'yellow', 'red']
        
        // push删除第一个元素，返回删除值
        var arr3 = ['pink','black','white','yellow']
        console.log(arr3.shift());//输出结果：pink
        console.log(arr3);//输出结果：['black', 'white', 'yellow']

        console.log('======unshift====');

        // unshift在首位添加一个或多个元素，返回元素个数
        var arr2 = ['pink','black','white','yellow']
        console.log(arr2.unshift('green'));//输出结果：5
        console.log(arr2);//输出结果：['green', 'pink', 'black', 'white', 'yellow']

        console.log('=====pop=====');

        // pop删除末尾的元素，返回删除值
        var arr4 = ['pink','black','white','yellow']
        console.log(arr4.pop());//输出结果：yellow
        console.log(arr4);//输出结果：['pink', 'black', 'white']

案列：筛选数组

 var arr5 = [1500,1200,200,2100,1800]
        var newArr = [];
        for(var i =0;i<arr5.length;i++){
            if(arr5[i]<2000){
                newArr.push(arr5[i]);
            }
        }
        console.log(newArr);//输出：[1500, 1200, 200, 1800]

数组排序

方法	功能描述
reverse()	颠倒数组元素位置，该方法会改变原数组，返回新数组
sort()	对数组的元素进行排序，该方法会改变原数组，返回新数组

sort()有两种情况

不传参数

传参数：参数是用来指定某种顺序进行排列的函数

        // sort：如果调用该方法时没有使用参数，按照字符编码的顺序进行排序。
        var arr = [1,5,3,2,7,42,45,677];
        //不传参数的情况
        console.log(arr.sort());//输出：[1, 2, 3, 42, 45, 5, 677, 7]
        // 传参数：参数是用来指定按某种顺序进行排列的函数
        /*
        即a和b是两个将要被比较的元素：
        */
        arr.sort(function(a,b){
            return a- b;  //升序// [1, 2, 3, 5, 7, 42, 45, 677]
            // return b -a;//降序 // [677, 45, 42, 7, 5, 3, 2, 1]
        })
        console.log(arr);//输出：[1, 2, 3, 5, 7, 42, 45, 677]

数组索引

查找元素在数组中的位置，可使用Array对象提供的检索方法。

方法	功能描述
indeOf()	返回指定元素的第一索引，若不存在返回-1
lastindexOf()	返回指定元素在数组中的最后一个索引，若不存在返回-1

indenOf()

参数1：要查找的元素

参数2：开始查找的位置

注意：如果第二个参数的值-1则从最后一个元素开始查找，-2则从倒数第二开始查找，以此类推。

lastindexOf()
如果该值大于或等于数组的长度，则整个数组会被查找。
如果该值为负值，将其视为从数组未尾向前的偏移。即使该值为负，数组仍然会被从后向前查找。
如果该值为负时，其绝对值大于数组长度，则方法返回-1，即数组不会被查找。

var arr = ['red','pink','black','white','yellow','black','red']
        console.log(arr.indexOf('red'));//0

        console.log(arr.lastIndexOf('black'));//5

案例：数组去重（利用indexOf()的功能特性实现）

function unique(arr){
            var newArr = [];
            for(var i = 0;i<arr.length;i++){
                if(newArr.indexOf(arr[i]) === -1){
                    newArr.push(arr[i])
                }
            }
            return newArr;
        }
        var res = unique([1,2,3,4,3,4]);
        console.log(res);//输出：[1, 2, 3, 4]

方法	功能描述
toString()	把数组转换为字符串，逗号分隔
join('分隔符')	将数组所有元素连接到一个字符串中

其他方法

方法	功能描述
fill()	用固定值填充数组指定下标范围内的全部元素
splice()	通过删除或替换现有元素或者原地添加新的元素来修改数组，返回被删除项目的新数组
slice()	数组截取，slice(begin，end)包含begin，不包含end，返回被截取项目的新数组
concat()	连接两个或者多个数组，不影响原数组，返回一个新数组

fill()

参数： values start end

value:用来填充数组元素的值

start:基于零的索引1，从此开始填充，转换为整数。

end基于零的素引1，在此结束填充，转换为整数。fill0 填充到但不包含 end 索引。

// fill
var array = [1, 2, 3, 4];
//填充0，从数组索引12（包舍)开始到4（不包含)结束
console.log (array.fill (0, 2, 4))//输出結果：Array [1, 2, 0, 0]
//填充5,从数組索引1（包合）开始
console. log(array. fill (5, 1));// 输出结果为： Array [1, 5, 5,5]
//填充6
console. log (array. fill (6));//输出結果： Array ［6, 6,6,6]

splice

参数start deleteCount itemi..

start执行修改的开始位置（从0计数）

deletecount整数,表示要移除的数组元素的个数

item:要添加进去数组的元素

        console.log("=========");
        var myFish = ['小米','小明','小张','小李'];
        var removed = myFish.splice(2,0,'小红');
        console.log(myFish);//['小米', '小明', '小红', '小张', '小李']
        console.log(removed);//[],没有元素被删除

        console.log("=========");
        var myFish = ['小米','小明','小张','小李'];
        var removed = myFish.splice(2,1);//从索引2开始删除一个元素
        console.log(myFish);//['小米', '小明', '小李']
        console.log(removed);//['小张']

        console.log("=========");
        var myFish = ['小米','小明','小张','小李'];
        var removed = myFish.splice(2,1,'小红');//从索引2开始删除一个元素，并且插入“小红”
        console.log(myFish);//['小米', '小明', '小红', '小李']
        console.log(removed);//['小张']

        console.log("=========");
        var myFish = ['小米','小明','小张','小李'];
        var removed = myFish.splice(0,2,'小红','小刚','小熊');//从索引0开始删除两个元素，插入'小红','小刚','小熊'
        console.log(myFish);//['小红', '小刚', '小熊', '小张', '小李']
        console.log(removed);//['小米', '小明']

        console.log("=========");
        var myFish = ['小米','小明','小张','小李'];
        var removed = myFish.splice(2);//从索引2开始删除所有元素
        console.log(myFish);//['小米', '小明']
        console.log(removed)//['小张', '小李']

        console.log("=========");
        var myFish = ['小米','小明','小张','小李'];
        var removed = myFish.splice(myFish.length-2,2);
        console.log(myFish);//['小米', '小明']
        console.log(removed);//['小张', '小李']

slice

参数:begin end

begin：从该索引开始提取原数组元素(包含）

end：在该素引处结束提取原数组元素（不包含）

        //从素引 2的位置开始 截取到 数组的倒数第一个元素(不包含var array了=[’小兰”，小蔡"，‘小刚”，“小张”，“小李”；
        var array3=['小兰','小蔡','小刚','小张','小李'];
        var getArr = array3.slice (2, -1);
        console. log (array3);//运算后的 array3：[’小兰'，小蔡"，‘小刚’，‘小张”，‘小李’]；
        console. log (getArr);// 被截取的元素：['小刚’，‘小张"〕

        var array3=['小兰','小蔡','小刚','小张','小李'];
        //截取后两个元素
        var getArr = array3.slice (-2);
        console. log (array3);// 运算后的array3：[“小兰”，“小蔡’，“小刚’，"小张”，小李"]；
         console.log(getArr); // 被截取的元素：[’小张"，，小李’]

concat

        //连接两个数组
        const letters = ['a','b','c'];
        const numbers = [1,2,3];

        const concatArr = letters.concat(numbers);
        console.log(letters);//['a', 'b', 'c']
        console.log(concatArr);//['a', 'b', 'c', 1, 2, 3]

        //连接三个数组
        const num1 = [1,2,3]
        const num2 = [4,5,6]
        const num3 = [7,8,9]

        const numArr = num1.concat(num2,num3)
        console.log(numArr);// [1, 2, 3, 4, 5, 6, 7, 8, 9]

        //将值连接到数组
        const arr1 = ['a','b','c']
        const newArr1 = letters.concat(1,[2,3])
        console.log(newArr1);//['a', 'b', 'c', 1, 2, 3]

字符串方法

方法

功能描述

indeOf(要查找的值，开始的位置)

返回指定元素在字符串中的位置，若不存在返回-1

参数2省略，从首字符开始检索

lastindexOf(要查找的值，开始的位置)

从后往前找，只找第一个匹配的，如果没有找到返回-1；参数2省略从字符串最后一个字符开始检索

        var str = new String("小友道阻且长")
        var res = str.indexOf('道')
        var res2 = str.indexOf('道',3)
        console.log(res);//2
        console.log(res2);//-1

        var res3 = str.lastIndexOf('道')
        var res4 = str.lastIndexOf('道',1)
        console.log(res3);//2
        console.log(res4);//-1