本文详细介绍了JavaScript中数组的基本概念、创建方式、数组的操作，包括索引、长度、增删改查等原生操作以及push、pop、shift、unshift、sort、join、concat等方法。此外，还讲解了ES5和ES6中新增的数组方法，如forEach、map、filter、reduce等，并探讨了数组的排序算法和去重策略。最后，文章提供了几个关于数组操作的示例和编程作业，帮助读者巩固所学知识。
大家好，今天给大家分享一下我最近学习的一些有关JavaScript中数组的知识。如果你觉得这些知识也很有用，那就请点个赞并收藏本文吧，让更多的朋友也能受益于这些知识。如果有任何错误，请告知我。谢谢大家的支持!
一、数组的概念和特点
- 数组是对象的一种，数组内的数据会按照顺序进行排列，是一种有序集合
-
- 数据按照顺序被标记，序号，也叫索引，从0开始
-
-
arr[0]
-
-
- 数组拥有length属性，用来表示自身有多少个数据
-
-
arr.length
-
-
- 因为索引的规律为从0开始递增，通过length属性标记数据总数，所以可以通过循环语句遍历数组
for(var i=0; i<arr.length; i++){
console.log( arr[i] );
}
二、数组的创建
- 字面量：
var arr1 = [数据1, 数据2, 数据3, ...]; - 创建函数：
var arr2 = new Array(数据1, 数据2, 数据3, ...); - 区别：当有且只有一个数值型数据时，字面量创建就是作为一个数据，构造函数创建会作为数组的长度，每个位置为
undefined
三、数组的操作
- 索引+长度操作
-
- 原生操作，底层操作，所有数组操作功能的基础
- 查：
arr[索引] - 改：
arr[索引] = "新值" - 增：默认只能在数组的最后增加
-
-
- 需要配合数组数据位置的移动，完成所需的指定位置的增加
-
-
- 删：默认只能从数组的最后开始删除
-
-
- 删除数据的原理：减少长度
- 需要配合数组数据位置的移动，完成所需的指定位置的删除
-
-
- 数组长度可修改
-
-
- 比原始长度大时，多出来的位置，用
empty补齐，读取时为undefined - 原始长度小时，从数组最后开始删除
- 比原始长度大时，多出来的位置，用
-
- 方法操作：将数组作为对象，其自身的函数，叫数组的方法
-
arr.push()：最后一位新增arr.pop()：删除最后一位arr.shift()：删除第一位arr.unshift()：第一位新增arr.reverse()：翻转数组中的数据arr.join()：根据指定字符连接数组中所有数据arr.concat()：合并数组arr.slice()：截取arr.splice()：删除并替换arr.sort()：排序
-
2.数据详解
-
// - push // 功能：末尾新增 // 参数：要新增的数据 // 返回值：新增后的长度 // 是否修改原数组：是 // var arr = ["hello", 5,6,7, "world"]; // console.log(arr); // var result = arr.push("abc", 123); // console.log("返回值为：", result); // console.log(arr); // - pop // 功能：删除末尾 // 参数：无 // 返回值：删除了的数据 // 是否修改原数组：是 // var arr = ["hello", 5,6,7, "world"]; // console.log(arr); // var result = arr.pop(); // console.log("返回值为：", result); // console.log(arr); // - shift // 功能：删除首位 // 参数：无 // 返回值：删除了的数据 // 是否修改原数组：是 // var arr = ["hello", 5,6,7, "world"]; // console.log(arr); // var result = arr.shift(); // console.log("返回值为：", result); // console.log(arr); // - unshift // 功能：首位新增 // 参数：要新增的数据 // 返回值：新增之后数组的长度 // 是否修改原数组：是 // var arr = ["hello", 5,6,7, "world"]; // console.log(arr); // var result = arr.unshift("abc",456); // console.log("返回值为：", result); // console.log(arr); // - slice // 功能：截取 // 参数：a1开始截取的位置，a2截取到的位置（不含） // 返回值：截取到的新数组 // 是否修改原数组：否 // var arr = ["hello", 5,6,7, "world"]; // console.log(arr); // var result = arr.slice(); // var result = arr.slice(2); // var result = arr.slice(2, 4); // console.log("返回值为：", result); // console.log(arr); // console.log(arr === result); // - splice // 功能：删除并替换 // 参数：a1开始删除的索引，a2删除的个数，a3~要插入到删除位置的数据 // 返回值：删除了的数据，数组形式 // 是否修改原数组：是 // var arr = ["hello", 5,6,7, "world"]; // console.log(arr); // var result = arr.splice(); // var result = arr.splice(2); // var result = arr.splice(2, 2); // var result = arr.splice(2, 2, 2, 2, 2, "abc"); // console.log("返回值为：", result); // console.log(arr); // console.log(arr === result); // - sort // 功能：排序。默认排序规则为字符的比较规则。可以通过参数修改为数值的比较规则 // 参数：函数，这个函数自带了两个形参，这个函数必须返回两个形参之差。 // 返回值：排序之后的老数组 // 是否修改原数组：是 // var arr = [67, 108, 2, 9, 365]; // console.log(arr); // var result = arr.sort( function(a,b){ return b-a } ); // console.log("返回值为：", result); // console.log(arr); // console.log(arr === result); // - join // 功能：按照指定连接符将数组中所有数据连接成字符 // 参数：连接符 // 返回值：连接之后的字符 // 是否修改原数组：否 // var arr = [2023, 5, 23]; // console.log(arr); // var result = arr.join(); // var result = arr.join("-"); // console.log("返回值为：", result); // console.log(arr); // console.log(arr === result); // - reverse // 功能：翻转数组 // 参数：无 // 返回值：翻转之后的老数组 // 是否修改原数组：是 // var arr = [2023, 5, 23]; // console.log(arr); // var result = arr.reverse(); // console.log("返回值为：", result); // console.log(arr); // console.log(arr === result); // - concat // 功能：合并数据（如果要合并的数据是数组，可以解析一层数组后，再做合并） // 参数：要合并的数据 // 返回值：合并之后的新数组 // 是否修改原数组：否 // var arr = [2023, 5, 23]; // console.log(arr); // var result = arr.concat(); // var result = arr.concat("abc", 365, [4, [5, 6]]); // console.log("返回值为：", result); // console.log(arr); // console.log(arr === result); // console.log("=====") // push的区别 // var arr2 = ["hello", 5,6,7, "world"]; // console.log(arr2); // var result2 = arr2.push("abc", 365, [4, 5, 6]); // console.log("返回值为：", result2); // console.log(arr2); // - indexOf // 功能：根据数据查索引 // 参数：a1要查询的数据，a2开始查询的位置 // 返回值：查询到的索引，查不到为-1 // 是否修改原数组：否 // var arr = [7,8,4,5,6,7,3,4,5,6,7,8,9]; // console.log(arr); // var result = arr.indexOf(5); // var result = arr.indexOf(5, 4); // var result = arr.indexOf(5, 9); // var result = arr.indexOf(2); // console.log("返回值为：", result); // console.log(arr); // console.log(arr === result); -
// 功能，参数，返回值，是否改变原数组：否 // - forEach // 功能：遍历数组 // 参数： // 函数，这个函数有三个形参。会被执行数组的length次，每次执行会获取数组的一个数据（从左向右依次获取） // a1：表示当前函数本次执行时拿到的数组的数据 // a2：表示a1数据对应的索引 // a3：表示原数组 // 返回值：undefined // var arr = [45,63,27,81,94]; // var result = arr.forEach( function(val, idx, self){ // console.log(val, idx, self, self===arr); // return "hello" // } ); // console.log( result ); // console.log( arr ); // console.log( arr === result ); // - map // 功能：遍历数组 // 参数： // 函数，这个函数有三个形参。会被执行数组的length次，每次执行会获取数组的一个数据（从左向右依次获取） // a1：表示当前函数本次执行时拿到的数组的数据 // a2：表示a1数据对应的索引 // a3：表示原数组 // 返回值：新数组，数组内保存了，作为参数的函数每次执行结束后的返回值 // var arr = [45,63,27,81,94]; // var result = arr.map( function(val, idx, self){ // console.log(val, idx, self, self===arr); // return val * 1.3; // } ); // console.log( result ); // console.log( arr ); // console.log( arr === result ); // - filter // 功能：遍历数组 // 参数： // 函数，这个函数有三个形参。会被执行数组的length次，每次执行会获取数组的一个数据（从左向右依次获取） // a1：表示当前函数本次执行时拿到的数组的数据 // a2：表示a1数据对应的索引 // a3：表示原数组 // 返回值：新数组，数组内保存了，作为参数的函数返回值为true时遍历到的数据 // var arr = [45,62,27,81,94]; // var result = arr.filter( function(val, idx, self){ // console.log(val, idx, self, self===arr); // return val % 2 === 1; // } ); // console.log( result ); // console.log( arr ); // console.log( arr === result ); // - some // 功能：遍历数组，并从数组中查询是否存在符合要求的数据，只要查到一个符合要求的数据，返回true，一个都没查到，返回false // 参数： // 函数，这个函数有三个形参。会被执行数组的length次，每次执行会获取数组的一个数据（从左向右依次获取） // a1：表示当前函数本次执行时拿到的数组的数据 // a2：表示a1数据对应的索引 // a3：表示原数组 // 返回值：布尔值。作为参数的函数在多次执行过程中 // 只要有一次返回true，some的返回值就是true // 全部返回false，some的返回值才为false // var arr = [45,62,27,81,94]; // var result = arr.some( function(val, idx, self){ // console.log(val, idx, self, self===arr); // return true; // } ); // console.log( result ); // console.log( arr ); // console.log( arr === result ); // 场景：查询是否包含，即可使用some // - every // 功能：遍历数组，并从数组中查询是否存在符合要求的数据，必须全部都是符合要求的数据，才返回true，只要有一个不符合要求，返回false // 参数： // 函数，这个函数有三个形参。会被执行数组的length次，每次执行会获取数组的一个数据（从左向右依次获取） // a1：表示当前函数本次执行时拿到的数组的数据 // a2：表示a1数据对应的索引 // a3：表示原数组 // 返回值：布尔值。作为参数的函数在多次执行过程中 // 只要有一次返回false，some的返回值就是false // 全部返回true，some的返回值才为true // var arr = [45,62,27,81,94]; // var result = arr.every( function(val, idx, self){ // console.log(val, idx, self, self===arr); // return false; // } ); // console.log( result ); // console.log( arr ); // console.log( arr === result ); // 场景：必须全部符合，可以使用every -
// - reduce // 功能：归并 // 参数： // 实参1：函数，这个函数有四个形参，这个函数会执行原数组的length次 // 形参1： // 存在实参2：函数第一次执行时，表示实参2；函数之后执行时，表示上一次函数的返回值 // 不存在实参2：函数第一次执行时，表示数组的第一个数据；函数之后执行时，表示上一次函数的返回值 // 形参2： // 存在实参2：函数执行时，从第一个开始，依次表示数组的每个数据 // 不存在实参2：函数执行时，从第二个开始，依次表示数组的每个数据 // 形参3：表示形参2拿到的数据对应的索引 // 形参4：表示原数组 // 实参2：任意数据，可选 // 返回值：最后一次函数执行的返回值 // var arr = [7, 8, 5, 9, 4]; // var result = arr.reduce( function(prev, val, idx, self){ // console.log(prev, val, idx, self); // return "hello"; // } ); // console.log(result); // var arr = [7, 8, 5, 9, 4]; // var result = arr.reduce( function(prev, val, idx, self){ // console.log(prev, val, idx, self); // return "hello"; // } , 300); // console.log(result); // 应用 // var arr = [3, 5, 8, 2, 6]; // var sum = arr.reduce(function(prev, val){ // return prev + val; // }); // console.log(sum); // 第一次：prev3，val5，返回了3+5=8 // 第二次：prev8，val8，返回了8+8=16 // 第三次：prev16，val2，返回了16+2=18 // 第四次：prev18，val6，返回了18+6=24 // reduce的返回值为24 // var arr = [3, 5, 8, 2, 6]; // var sum = arr.reduce(function(prev, val){ // return prev + val; // }, 0); // console.log(sum); // 第一次：prev0，val3，返回了0+3=3 // 第二次：prev3，val5，返回了3+5=8 // 第三次：prev8，val8，返回了8+8=16 // 第四次：prev16，val2，返回了16+2=18 // 第五次：prev18，val6，返回了18+6=24 // reduce的返回值为24 var arr = [{price:3},{price:5},{price:8},{price:2},{price:6}]; var sum = arr.reduce(function(prev, val){ return prev + val.price }, 0); console.log(sum); // reduceRight
四、数组排序
- 冒泡排序：依次对数组中相邻数字进行比较(两两比较)，大的放后面
var arr = [5,99,2,9,1,5,67,7,10,23]; // 定义一个杂乱的数组
for(var i=0; i<arr.length-1; i++){ // 外层循环，用于遍历数组每个元素
for(var j=0; j<arr.length-i-1; j++){ // 内层循环，用于将数组中的某个元素与其它所有元素相比较
var x; // 声明一个变量，当作第三个空瓶子
if(arr[j] > arr[j+1]){ // 判断当前元素和后一个元素的大小，如果当前元素比后一个元素大
x = arr[j+1]; // 将后一个元素（小元素）放在空瓶子里
arr[j+1] = arr[j]; // 将当前元素（大元素）放在后一个元素的位置
arr[j] = sum; // 将小元素从空瓶子中拿出来，放在当前元素的位置
}
}
}
console.log(arr); // 完成循环之后，初始数组的顺序已经发生改变
- 选择排序：从左向右依次，取数组中的一个数据和后面所有数据做比较，拿到最小的之后，再和当前位置交换
var arr = [5,99,2,9,1,5,67,7,10,23]; // 定义一个杂乱的数组
for(var i=0; i<arr.length-1; i++){ // 外层循环，需要比对的次数
var min = arr[i]; // 假定一个最小值
var minIndex = i; // 假定最小值的索引
for(var j=i+1; j<arr.length; j++){ // 内层循环，每次需要比对的次数
if(min > arr[j]){ // 判断最小值是否为真的最小值
min = arr[j]; // 获取真正的最小值
minIndex = j; // 获取真正最小值的索引
}
}
arr[minIndex] = arr[i]; // 将当前元素放在最小值的位置
arr[i] = min; // 将最小值放在当前元素的位置
}
console.log(arr); // 打印排序好的数组
五、ES5新增和ES6的数组方法
ES5新增的数组方法有：Array.prototype.forEach()：对数组中的每个元素执行一个函数。Array.prototype.map()：对数组中的每个元素执行一个函数，并返回一个新的数组。Array.prototype.filter()：对数组中的每个元素执行一个函数，并返回一个包含符合条件的元素的新数组。Array.prototype.reduce()：对数组中的每个元素执行一个函数，并返回一个累积值。Array.prototype.reduceRight()：对数组中的每个元素执行一个函数，并返回一个从右向左累积的值。Array.prototype.every()：对数组中的每个元素执行一个函数，并返回一个布尔值，表示是否所有元素都符合条件。Array.prototype.some()：对数组中的每个元素执行一个函数，并返回一个布尔值，表示是否存在符合条件的元素。Array.prototype.indexOf()：返回指定元素在数组中的索引。Array.prototype.lastIndexOf()：返回指定元素在数组中从后往前的索引。Array.prototype.join()：将数组中的所有元素转换为一个字符串。Array.prototype.concat()：将多个数组合并为一个新数组。Array.prototype.slice()：返回一个新数组，包含从开始位置到结束位置之间的元素。Array.prototype.splice()：从数组中添加或删除元素。Array.isArray()：判断一个对象是否为数组类型。
2.ES6新增的数组方法有：
-
Array.from()：将类数组对象或可迭代对象转换为数组。 -
Array.of()：创建一个包含任意数量参数的新数组。 -
Array.prototype.find()：返回数组中第一个符合条件的元素。 -
Array.prototype.findIndex()：返回数组中第一个符合条件的元素的索引。 -
Array.prototype.fill()：用一个固定值填充数组中的所有元素。 -
Array.prototype.copyWithin()：将数组中指定位置的元素复制到其他位置。 -
Array.prototype.entries()：返回一个包含数组键值对的迭代器对象。 -
Array.prototype.keys()：返回一个包含数组键的迭代器对象。 -
Array.prototype.values()：返回一个包含数组值的迭代器对象。 -
Array.prototype.includes()：判断数组中是否包含指定的元素。 -
Array.prototype.flat()：将嵌套的数组扁平化为一维数组。 -
Array.prototype.flatMap()：对数组中的每个元素执行一个函数，并将结果扁平化为一维数组。 -
Array.prototype.at()：返回指定位置的元素。 -
Array.prototype.sort()：排序数组中的元素。 -
Array.prototype.reverse()：反转数组中的元素。
六、数组去重
数组去重的方法有以下几种：
-
使用 Set 数据结构：Set 是 ES6 中新增的数据结构，它可以去重。将数组转换为 Set，然后再将 Set 转换为数组即可去重。
const arr = [1, 2, 3, 2, 1]; const uniqueArr = [...new Set(arr)]; console.log(uniqueArr); // [1, 2, 3] -
使用 filter() 方法：遍历数组，使用 indexOf() 方法判断元素在数组中第一次出现的位置是否等于当前位置，如果相等则说明是第一次出现，保留该元素。
const arr = [1, 2, 3, 2, 1]; const uniqueArr = arr.filter((item, index) => { return arr.indexOf(item) === index; }); console.log(uniqueArr); // [1, 2, 3] -
使用 reduce() 方法：遍历数组，将数组中的每个元素作为 key 存储在一个空对象中，如果该元素已经存在，则不再存储。
const arr = [1, 2, 3, 2, 1]; const uniqueArr = arr.reduce((prev, cur) => { if (!prev.includes(cur)) { prev.push(cur); } return prev; }, []); console.log(uniqueArr); // [1, 2, 3] -
使用 for 循环嵌套遍历：遍历数组，使用一个空数组存储已经出现过的元素，如果该元素已经存在，则不再存储。
const arr = [1, 2, 3, 2, 1]; const uniqueArr = []; for (let i = 0; i < arr.length; i++) { if (uniqueArr.indexOf(arr[i]) === -1) { uniqueArr.push(arr[i]); } } console.log(uniqueArr); // [1, 2, 3]
七、作业
- 封装 计算任意两个个位数之间所有数字，两两组合，能组合成哪些奇数，放在数组中，返回出来 函数 push
-
- 1，3
- 1，2，3
- 11,12,13,21,22,23,31,32,33
- xxx(1, 3);
- [11, 13, 21, 23, 31, 33]
-
function fn(m, n){ if(m > n){ var x = m; m = n; n = x; } var arr = []; for(var i=m; i<=n; i++){ for(var j=m; j<=n; j++){ if( (""+i+j) % 2 ){ arr[arr.length] = (""+i+j); } } } return arr; } // console.log( fn(1, 3) );
- 封装 将数组内所有数据增加30%的 函数 map
-
- [1, 2, 3, 4]
- map(arr);
- [1.3, 2.6, 3.9, 5.2]
-
function map(myarr){ // 遍历数组拿到所有数据 for(var i=0;i<myarr.length;i++){ // 将原数据增加30%（注意计算机对浮点数的精度问题）后，再设置回原数组 myarr[i] = Number((myarr[i] * 1.3).toFixed(5)); } } // var arr = [1, 2, 3, 4] // console.log(arr) // map( arr ); // console.log(arr)
-
有一个全是数值的数组，封装函数，计算总和 reduce
function sum(myarr){ var s = 0; // 遍历数组 for(var i=0;i<myarr.length;i++){ // 将所有数据，累加 s += myarr[i]; } // 返回结果 return s; } // var arr = [3,4,5,3,2,1,6]; // console.log( sum(arr) ); -
有一个全是数值的数组，封装函数，计算平均值 reduce
function avg(myarr){ var s = 0; for(var i=0;i<myarr.length;i++){ s += myarr[i]; } return s / myarr.length; } // var arr = [3,4,5,3,2,1,6]; // console.log( avg(arr) ); -
封装函数：从100~999中取出所有的水仙花数，并返回到函数外部 push
function flower(){ // 准备数组，用于存放数据 var arr = []; // 计算水仙花数 for(var i=100;i<1000;i++){ var a = parseInt(i/100) var b = parseInt(i/10)%10; var c = i % 10; if(i === a**3 + b**3 + c**3){ // 每遇到一个水仙花数，存入数组最后一位 arr[arr.length] = i; } } // 所有的数字判断完毕，返回最终结果 return arr; } // console.log( flower() ); -
封装函数：判断一个数组是不是回文数组（对称）
-
- [1,2,3,2,1]
- [1,2,3,3,2,1]
-
// 长度为6 // 0 ~ 5 // 1 ~ 4 // 2 ~ 3 // 0 ~ length-1-0 // 1 ~ length-1-1 // 2 ~ length-1-2 // 长度 / 2 === 3 // i的范围：0~3(不含) // 要比较的数组的索引 // i ~ arr.length-1-i function symmetry(myarr){ // 取中间值 var x = parseInt(myarr.length / 2); // 从开头遍历到中间值（获取数组一半数据的索引） for(var i=0;i<x;i++){ // 对称位置比较：i ~ arr.length-1-i if(myarr[i] !== myarr[myarr.length-1-i]){ // 只要有一次不相等，就是false return false; } } // 没有比较不相等，表示全部相等，才为true return true; } // console.log( symmetry( [1,2,3,2,1] ) ); // console.log( symmetry( [1,2,3,3,2,1] ) ); // console.log( symmetry( [1,2,3,4,2,1] ) ); // console.log( symmetry( [1,2,3,3,2,2] ) );
- 封装函数：将一个杂乱的数据，从大到小排序 sort
- 封装函数，根据指定数据，查询数组中是否存在该数据，如果存在，返回出现次数，如果不存在，返回false
-
- [3, 4, 5, 6, 5, 4, 6, 5, 3, 2]
- count(arr, 5); // 3
- count(arr, 7); // false
-
function indexOf(arr, data){ var n = 0; // 初始准备开始查询前的位置 var i = -1; // 利用不确定次数的循环 while( true ){ // 利用indexOf查询数组中是否存在指定数据，每次从上次查询到的位置的后一个开始查询 i = arr.indexOf( data, i+1 ); // 查询到数据 if( i !== -1 ){ // 记录 n++; }else{ // 结束循环 break; } } // 如果从未记录，说明未发现重复 if(n === 0){ // 返回false return false } // 否则，返回记录结果 return n; } var arr = [3,5,7,6,4,5,7,5,4,3,2,3,4,5,6,7,8]; console.log(indexOf(arr, 1)); console.log(indexOf(arr, 5)); console.log(indexOf(arr, 6)); console.log(indexOf(arr, 3)); console.log(indexOf(arr, 2)); console.log(indexOf(arr, 8)); console.log(indexOf(arr, 7)); console.log(indexOf(arr, 9)); // function indexOf(arr, data){ // var n = 0; // // 遍历数组所有数据 // for(var i=0;i<arr.length;i++){ // // 逐个比较 // if(arr[i] === data){ // // 发现重复，记录 // n++; // } // } // // 如果从未记录，说明未发现重复 // if(n === 0){ // // 返回false // return false; // } // // 否则，返回记录结果 // return n; // }
- 封装 数组去重的 函数 splice
-
- 不允许修改原数组
- [3, 5, 2, 3, 4, 5, 6, 5, 4, 3, 2, 1]
- noRepeat(arr);
- [3, 5, 2, 4, 6, 1]
-
// 封装函数，根据指定数据，查询数组中是否存在该数据，如果存在，返回存在true，如果不存在，返回false function includes(myarr, data){ // 遍历数组 for(var i=0;i<myarr.length;i++){ // 将遍历出的数据，和传入的数据，比较 if( myarr[i] === data ){ // 只要有一个相同，就返回true return true; } } // 没有一个数据是相同的，返回false return false; } // var arr = ["hello", 5, 6, 7, "world"]; // console.log( includes(arr, 6) ); // console.log( includes(arr, "hahha") ); // console.log( includes(arr, "6") ); // console.log( includes(arr, "") ); // console.log( includes(arr, 0) ); // console.log( includes(arr, "hello") ); // 封装 数组去重的 函数 function noRepeat(myarr){ // 准备一个空数组 var a = []; // 从老数组中依次取出所有数据 for(var i=0;i<myarr.length;i++){ // 查看新数组中是否存在 if(!includes(a, myarr[i])){ // 不存在就放进去 a[a.length] = myarr[i]; } } // 循环结束后，这个新数组，就是去重之后的数组 return a; } var arr = [5,4,6,4,5,3,4,5,6,6,6]; console.log( noRepeat(arr) ); // [5, 4, 6, 3]; // 思路1：类似于选择排序，依次取出每一个数据，和之后的所有数据比较，遇到重复的，删除 // 思路2：再准备一个空数组，从老数组中依次取出所有数据，查看新数组中是否存在，不存在就放进去，存在就略过
- 现有一个排好序的都是数值的数组，插入一个新数据，要求不影响原排序，封装函数实现
-
- [1, 3, 4, 6, 9]
- insert(arr, 5);
- [1, 3, 4, 5, 6, 9]
-
// 在指定数组的指定位置插入指定数据 function insert(arr, n, data){ for(var i=arr.length; i>n; i--){ arr[i] = arr[i-1]; } arr[n] = data; } // insert(arr, 1, 100); // insert(arr, 3, 666); // insert(arr, 10, 777); console.log(arr); -
// 数组的长度减少时，从数组的末尾开始删除 // arr.length = arr.length - 1; // 需求：删除索引为 1 的数据 // 将索引1后的数据，依次向前覆盖 // arr[1] = arr[2]; // arr[2] = arr[3]; // arr[3] = arr[4]; // 减少数组的长度 // arr.length--; // 删除指定数组的指定位置的数据 function remove( arr, n ){ for(var i=n;i<arr.length-1; i++ ){ arr[i] = arr[i+1]; } arr.length--; } // remove(arr, 2) // remove(arr, 2) // console.log(arr)
扫一扫
1925
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
