JavaScript中的数组是一种非常有用的数据结构，它可以存储多个值，并且可以通过索

引来访问和修改这些值。在本文中，我们将讨论如何使用JavaScript数组分配来有效地
管理数据。
首先，让我们来了解一下如何创建一个JavaScript数组。您可以使用以下语法来创建一
个空数组：
var myArray = [];

您也可以在创建数组的同时为其赋值：
var myArray = [1, 2, 3];

接下来，让我们来看一下如何使用索引来访问和修改数组中的值。数组的第一个元
素的索引为0，第二个元素的索引为1，依此类推。例如，要访问数组中的第一个元素，
您可以使用以下语法：
var firstElement = myArray[0];

要修改数组中的值，您可以使用相同的语法：
myArray[0] = \"new value\";

除了使用索引，您还可以使用数组的length属性来访问最后一个元素。例如，要访问数
组中的最后一个元素，您可以使用以下语法：
var lastElement = myArray[myArray.length - 1];

现在让我们来看一下如何使用数组分配来有效地管理数据。假设您有一个名为students
的数组，其中包含学生的姓名。您可以使用以下语法来向该数组中添加新的学生：
students.push(\"John\");

这将在数组的末尾添加一个新元素。您还可以使用unshift()方法在数组的开头添加新
元素，使用splice()方法在指定位置添加新元素。
另外，您也可以使用pop()方法从数组的末尾删除一个元素，使用shift() 方法从数组的开
头删除一个元素，使用splice()方法从指定位置删除一个元素。
通过有效地使用数组分配，您可以轻松地管理和操作数据，使您的代码更加简洁和
高效。如果您想要更深入地学习JavaScript数组分配的知识，我强烈推荐您访问
HelpWriting.net网站。那里有大量的教程和资源，可以帮助您更好地掌握JavaScript编程。

谢谢您阅读本文，希望您能够在使用JavaScript数组时更加得心应手！
const result = []; keys()浏览器兼容性(MDN):Chrome 38, Firefox 28,Opera 25,Safari 8, ["1", "2",
"3"].map(parseInt); // [1, NaN, NaN] { name: 'Jane', age: 20 } } var unboundSlice =
Array.prototype.slice; return x.charCodeAt(0); // {copyWithin: true, entries: true,fill: true, find: true,
findIndex: true, flat: true, flatMap: true, includes: true, keys: true, values: true} let item = a.splice(-1,
3); // [7] this.count = 0; JavaScript数组中堆栈和队列的示例分析 广州亿速云计算有限公
司粤ICP备17096448号-1 粤公网安备 44010402001142号增值电信业务经营许可证编
号：B1-20181529 idx = array.indexOf(element, idx + 1); 定义：fill() 方法 将数组中指定区间的
所有元素的值，都替换成某个固定的值。从起始索引到终止索引内的全部元素。不包
括终止索引。并返回 这个 数组 // 注意索引 2 被跳过了，因为在数组的这个位置没有
项 return slice(arguments); } [1, 2, 3, 4, 5].copyWithin(0, -2, -1) ES6: a.fill() / a.copyWithin() // 这
两个为实验性API ​ 系统监测到您的网络环境存在异常风险，为保证您的正常访问，请
输入验证码进行验证。 { name: 'Max', age: 20 },
items.forEach(function(item){ console.log(years.0); // 语法错误 Uncaught SyntaxError:
Unexpected number ​ const promiseArr = [p1, p2, f3, p4]; // [4, 2, 3, 4, 5] // promise function 4 return
arr.reduce( let result = [12, 54, 18, 130, 44].every(isBigEnough); // true const obj = new Counter(); }
every 方法为数组中的每个元素执行一次 callback 函数，直到它找到一个会使callback 返
回 falsy 的元素。如果发现了一个这样的元素，every 方法将会立即返回false ，剩余的元
素不会再进行检测。否则，callback 为每一个元素返回 true，every 就会返回 true。callback
只会为那些已经被赋值的索引调用。不会为那些被删除或从未被赋值的索引调用。 }
}); var numbers = [1, 4, 9]; console.log(years[0]); // √ let a= ['hello','world']; }; ​
Counter.prototype.add = function(array) { let a = [1, 2, 3] }
return slice(arguments); console.log(fruits.length); // 2 console.log(b,a); // [{"name":"OBKoro1"}]
[{"name":"OBKoro1"}] ES6: while (idx != -1) { allNames[name]++; 语
法：arr.reduce(callback(accumulator, currentValue[, index[, array]])[, initialValue]) arr.values()
function f3(a) { return new Promise((resolve, reject) => { ECMAScript为数组专门提供了 push()
和 pop()方法，以便实现类似栈的行为。 push() 方法可以接收任意数量的参数，把它们
逐个添加到数组末尾，并返回修改后数组的长度。而 pop() 方法则从数组末尾移除最后
一项，减少数组的length值，然后返回移除的项。 console.log(s); // '1,a,true'
console.log(Object.keys(fruits)); // ['0', '1', '2', '5'] return (element >= 10); //数组中是否有一个元
素大于 10 b[0].name='改变拷贝数组',b[0].koro='改变拷贝数组'; ​ JavaScript 数组的索引是
从0开始的，第一个元素的索引为0，最后一个元素的索引等于该数组的长度减1。如
果指定的索引是一个无效值，JavaScript 数组并不会报错，而是会返回 undefined。
(promiseChain, currentFunction) => promiseChain.then(currentFunction), shift()方法和unshift()方
法恰恰相反。该方法用于把数组的第一个元素从其中删除，并返回被删除的值。如果
数组是空的，shift()方法将不进行任何操作，返回undefined的值。 ​ // a[1] = 5 const map =
new Map([[1, 2], [2, 4], [4, 8]]);
指定一个字符串来分隔数组的每个元素。如果需要，将分隔符转换为字符串。如果缺
省该值，数组元素用逗号（,）分隔。如果separator是空字符串("")，则所有元素之间都没
有任何字符。 // 'b' var a = ["Banana", "Orange", "Apple", "Mango"]; 下例使用 lastIndexOf 查找
到一个元素在数组中所有的索引（下标），并使用 push 将所有添加到另一个数组中。 定
义：reverse() 方法 颠倒数组中元素的排列顺序，即原先的第一个变为最后一个，原先的
最后一个变为第一个，并返回这个 数组 idx = (idx > 0 ? array.lastIndexOf(element, idx - 1) :
-1); [] // let b=a.lastIndexOf('Koro1',4); // 从下标4开始往前找 返回下标2 } // 从数组下标0
开始，删除3个元素，并添加元素'添加' } // 从数组最后第二个元素开始，删除3个元素，
并添加两个元素'添加1'、'添加2' ​ 定义：返回在数组中可以找到一个给定元素的第一个
索引，如果不存在，则返回-1 。 indices.push(idx); b[0].name=' 改变拷贝数组',b[0].koro='改变
拷贝数组'; ['1', '2', '3'].map(returnInt); // [1, 2, 3] array.indexOf(2); // 0 { name: 'Alice', age: 21 }, }
} ['1.1', '2.2e2', '3e300'].map(Number); // [1.1, 220, 3e+300] let a= ['调用toString','连接在我后
面']+'啦啦啦'; // 调用toString,连接在我后面啦啦啦
这段代码分别执行了100000次push()和unshift()操作，在chrome浏览器运行一次，得到的
结果如下图所示： 下例创造了一个类数组对象 a, 包含3个元素和一个 length 属性, 然后
颠倒这个类数组对象。 reverse() 的调用返回一个颠倒后的类数组对象 a的引用。 find() :
找到第一个满足测试函数的元素并返回那个元素的值，如果找不到，则返回 undefined。
[1, 2, 3].fill(4, 3, 3); // [1, 2, 3] } return parseInt(element, 10); ['1', '2', '3'].map( str => parseInt(str) );
要了解JavaScript数组的堆栈和队列方法的操作，需要先对堆栈和队列基础知识有所
了解。在继续后面的内容之前，我们先简单的了解一下堆栈和队列的概念。 a.reverse();
console.log(word); ]; let a= [{name:'OBKoro1'}]; // 接受箭头函数写法 console.log(b); /
/ [1,2,3,4,5,'添加1','添加2'] ​ words.shift(); console.log(a); // [3, 2, 1] 如果不使用for...of循环，可
以手动调用遍历器对象的next方法，进行遍历: 虽然数组元素可以看做是数组对象的属
性，就像 toString 一样，但是下面的中间一行写法是错误的，运行时会抛出 SyntaxError
异常，而原因则是使用了非法的属性名；并不是JavaScript 数组有什么特殊之处，而是
因为在 JavaScript 中，以数字开头的属性不能用点号引用，必须用方括号。 let item =
a.pop() a.join('字符串')：将数组内各元素通过参数连接，返回一个字符串// {copyWithin:
true, entries: true,fill: true, find: true, findIndex: true, flat: true, flatMap: true, includes: true, keys:
true, values: true} Array的push()与unshift()方法都能给当前数组添加元素，不同
的是，push()是在末尾添加，而unshift()则是在开头添加，从原理就可以知道，unshift()的
效率是较低的。原因是，它每添加一个元素，都要把现有元素往下移一个位置。但到
底效率差异有多大呢? 下面来简单测试一下。 var indices = []; push()方法可以接收任意数
量的参数，把它们逐个添加到数组的末尾，并返回修改后数组的长度。如： 如果 start 是
个负数, 则开始索引会被自动计算成为 length+start, 其中 length 是 this 对象的 length属
性值。如果 end 是个负数, 则结束索引会被自动计算成为 length+end 。 // 3 === (1 + 1 + 1)
var array = ['a', 'b', 'a', 'c', 'a', 'd']; var indices = [];
} // 0 "a" let item = a.push('末尾1', '末尾2') ​ console.log(a, item) // ["开头1", "开头2", 1, 2, 3] 5
console.log(index, elem); console.log(entries.next().value); // [2, 'c'] 顾名思义， unshift() 与 shift()
的用途相反：它能在数组前端添加任意个数组项并返回新数组的长度。因此，同时使
用 unshift() 和 pop() 方法，可以从相反的方向来模拟队列，即在数组的前端添加数
组项，从数组末端移除数组项。 var people = [ Array.from([1, 2, 3], x => x + x); // [2, 4, 6] 定
义：reverse() 方法 颠倒数组中元素的排列顺序，即原先的第一个变为最后一个，原先的
最后一个变为第一个，并返回这个 数组 // {copyWithin: true, entries: true,fill: true, find: true,
findIndex: true, flat: true, flatMap: true, includes: true, keys: true, values: true} ]; splice有3个
参数，它也可以用来替换/删除/ 添加数组内某一个或者几个值 idx = (idx > 0 ?
array.lastIndexOf(element, idx - 1) : -1); }else{ // 如果不是的话，a排在b的后面 let b=a.slice();
shift()方法和unshift()方法恰恰相反。该方法用于把数组的第一个元素从其中删除，并返
回被删除的值。如果数组是空的，shift()方法将不进行任何操作，返回undefined的值。 除
此之外，还可以同时使用unshift()和pop()方法，从相反的方向来模拟队列，即在数组的
前端添加项，从数组的后端移除项。如下面的示例所示：语法：var newArray =
arr.filter(callback(element[, index[, array]])[, thisArg]) }; // 但是浮点数 或 使用科学计数法的
数 使用 Number 不能转化成对应的整数 ['1.1', '2.2e2', '3e300'].map( str => parseInt(str) ); // [1,
2, 3] fruits.push('banana', 'apple', 'peach'); 浏览器兼容(MDN):Chrome 45,Firefox 25,Opera 32,
Safari 8, Edge yes, concat方法不会改变this或任何作为参数提供的数组，而是返回一个浅
拷贝，它包含与原始数组相结合的相同元素的副本。原始数组的元素将复制到新数
组中，如下所示： }
// a[1] = 5 ​ console.log(b,a); // [{"name":"改变拷贝数组","koro":"改变拷贝数组"}] [{"name":"
改变拷贝数组","koro":"改变拷贝数组"}] let a = [1, 4, -5, 10].findIndex((n) => n < 0); // 返回
索引2 参数：item1, item2, ... , itemX, 要添加到数组末尾的元素 // 字符串排列 看起来很正
常 // 从数组最后第二个元素开始，删除3个元素，并添加两个元素'添加1'、'添加2' 将数
组和/ 或值连接成新数组。如果省略了valueN参数参数，则concat会返回一个它所调用的
已存在的数组的浅拷贝。 some() 为数组中的每一个元素执行一次 callback 函数，直到找
到一个使得 callback 返回一个“真值”（即可转换为布尔值 true 的值）。如果找到了这样一
个值，some() 将会立即返回 true。否则，some() 返回 false。callback 只会在那些”有值“的索
引上被调用，不会在那些被删除或从来未被赋值的索引上调用。 // { return
x.charCodeAt(0); 因为 thisArg 参数（this）传给了 forEach()，每次调用时，它都被传
给 callback 函数，作为它的 this 值。 在开发中，数组的使用非常多，会涉及很多的api
的使用，但是除了几个最常用的api 之外，其他的 api 用完之后经常就会忘掉了，再用
的时候还要查一下。所以就希望系统的总结梳理一下这块内容，写下这篇文章，如果
喜欢的话，可以 点赞/收藏，支持一下，希望看完会对大家有帮助。 slice 方法可以用来
将一个类数组（Array-like）对象/ 集合转换成一个新数组。你只需将该方法绑定到这个对
象上。 一个函数中的 arguments就是一个类数组对象的例子。 } index:数组开始下标
len: 替换/ 删除的长度 item:替换的值，删除操作的话 item 为空 指定一个字符串来分
隔数组的每个元素。如果需要，将分隔符转换为字符串。如果缺省该值，数组元素用
逗号（,）分隔。如果separator是空字符串("")，则所有元素之间都没有任何字符。 JavaScript
数组中堆栈和队列的示例分析 复制代码 f(1, 'a', true); var doubles =
numbers.map(function(num) { var m = [1, 2, 2], n = [2,3,3]; let a=['啦啦',2,4,24,NaN]