以下js操作array的方法中,js中array.from
javascript中数组的几种高效操作方法
Array.from()
方法从类似的数组或可迭代对象创建新的数组实例。
console . log(array . from( foo ))；
//预期输出：数组[f ， o ， o]
console.log(Array.from([1，2，3]，(x)=x x))；
//expectedoutput: Array [2，4，6]:
Array.isArray()
用于判断传递的值是否为数组。
Array.isArray([1，2，3])；
//真
array . isarray({ foo:123 })；
//假
array . is array(“foobar”)；
//假
Array.isArray(未定义)；
//false
Array.obsolete()
用于异步监控数组的变化
Array.of()
方法使用可变数量的参数创建新的数组实例，而不考虑参数的数量或类型。
(7)的数组；//[7]
Array.of(1，2，3)；//[1, 2, 3]
数组(7)；//[ , ]
Array(1，2，3)；//[1, 2, 3]
//es5
如果(！数组. of) {
Array.of=function () {
返回Array.prototype.slice.call(参数)；
};
}
Array.concat()
方法用于合并两个或多个数组。此方法不会更改现有数组，但会返回一个新数组。
var array1=[a ， b ， c ]；
var array2=[d ， e ， f ]；
console . log(array 1 . concat(array 2))；
//expectedoutput: array [a ， b ， c ， d ， e ， f]:
Array.copyWithin()
方法将数组的一部分浅显地复制到同一数组中的另一个位置，并在不修改其大小的情况下返回。
var array1=[1，2，3，4，5]；
//将位置3和4之间的元素放在位置0
console . log(array 1 . copy within(0，3，4))；
//预期输出：Array [4，2，3，4，5]
//将位置3之后的元素放在位置1
console . log(array 1 . copy within(1，3))；
//expectedoutput: array [4，4，5，4，5]:
Array.entries()
方法返回新的数组迭代器对象，该对象包含数组中每个索引的键/值对。
var array1=[a ， b ， c ]；
var iterator 1=array 1 . entries()；
console.log(iterator1.next()。值)；
//预期的输出：Array [0， a]
console.log(iterator1.next()。值)；
//expectedoutput: array [1， b]:
Array.every()
方法测试数组的所有元素是否都通过了指定函数的测试。
var array1=[1，30，39，29，10，13]；
console . log(array 1 . every((x)=x 40))；
//out true
Array.fill()
方法用固定值填充数组中从起始索引到结束索引的所有元素。包括没有终止。
var array1=[1，2，3，4]；
//从位置2到位置4用0填充
console.log(array1.fill(0，2，4))；
//预期输出：[1，2，0，0]
//从位置1用5填充
console.log(array1.fill(5，1))；
//预期输出：[1，5，5，5]
console . log(array 1 . fill(6))；
//expectedoutput: [6，6，6]:
Array.filter()
方法创建一个新数组，该数组包含由提供的函数实现的测试的所有元素。
var words=[喷，限，精英，旺盛，破坏，现在]；
const result=words . filter((word)=word . length 6)；
console.log(结果)；
//expected output:array[ excellent ， destruction ， present]:
Array.find()
方法返回满足所提供测试函数的数组中第一个元素的值。否则，返回undefined。
var array1=[5，12，8，130，44]；
var found=array 1 . find((x)=x 10)；
console.log(找到)；
//预期输出：12
Array.findIndex()
方法返回满足提供的测试函数的数组中第一个元素的索引。否则，返回-1。
var array1=[5，12，8，130，44]；
var index=array 1 . find index((x)=x 10)；
console.log(索引)；
//预期输出：1
Array.flat()
方法将所有子数组递归连接到指定深度，并返回一个新数组。
var arr1=[1，2，[3，4]]；
arr 1 . flat()；
//[1, 2, 3, 4]
var arr2=[1，2，[3，4，[5，6]]；
arr 2 . flat()；
//[1, 2, 3, 4, [5, 6]]
var arr3=[1，2，[3，4，[5，6]]；
arr 3 . flat(2)；
//[1, 2, 3, 4, 5, 6]
var arr4=[1，2，4，5]；
arr 4 . flat()；
//[1，2，4，5]
Array.flatMap()
方法首先使用映射函数映射每个元素，然后将结果压缩到一个新数组中。它与深度值为1的map和flat几乎相同，但flatMap通常在合并到一个方法中时效率稍高。
var arr1=[1，2，3，4]；
arr 1 . map((x)=[x * 2])；
//[[2], [4], [6], [8]]
arr 1。平面映射((x)=[x * 2])；
//[2, 4, 6, 8]
//只有一个级别被展平
arr 1。平面映射((x)=[[x * 2]])；
//[[2], [4], [6], [8]]
Array.forEach()
方法对数组的每个元素执行一次提供的函数。
var array1=[a ， b ， c ]；
array1.forEach((值，索引，数组)=console.log(值));
//输出" a "
//输出" b "
//输出【c】
Array.includes(value,index)
方法用来判断一个数组是否包含一个指定的值，根据情况，如果包含则返回没错，否则返回错误。
var array1=[1，2，3]；
控制台。日志(数组1。包括(2))；
//预期输出：正确
var pets=[猫,狗,蝙蝠];
控制台。日志(宠物。包括( cat )；
//预期输出：正确
控制台。日志(宠物。包括( at ))；
//预期输出：假
Array.indexOf()
方法返回在数组中可以找到一个给定元素的第一个索引，如果不存在，则返回-1。
/var beasts=[蚂蚁,野牛,骆驼,鸭子,野牛];
控制台。原木(野兽。(野牛)的索引；
//预期输出：1
//从索引2开始
控制台。原木(野兽。的索引( bison ，2))；
//预期输出：4
console.log(beasts.indexOf(长颈鹿));
//预期输出：-1
Array.join()
方法将一个数组（或一个类数组对象)的所有元素连接成一个字符串并返回这个字符
var元素=[火,风,雨];
控制台。日志(元素。join())；
//预期输出：火、风、雨
控制台。日志(元素。join())；
//预期输出：火风雨
控制台。日志(元素。join(-)；
//预期输出：火-风-雨
//数组[1,2,3,3,4,5]求和
eval([1，2，3，3，4，5]).join()=18；
Array.keys()
方法返回一个新的排列迭代器，它包含数组中每个索引的键。
var array1=[a ， b ， c ]；
变量迭代器=数组1。keys()；
对于(迭代器的字母键){
控制台。日志(关键)；//预期输出：0 1 2
}
Array.lastIndexOf(item，index)
方法返回指定元素（也即有效的Java脚本语言值或变量)在数组中的最后一个的索引，如果不存在则返回-1。从数组的后面向前查找，从起始下标处开始。
var animals=[Dodo ，老虎,企鹅，‘多多’]；
控制台。日志(动物。lastindexof( Dodo )；
//预期输出：3
控制台。日志(动物。lastindexof( Tiger )；
//预期输出：1
Array.map()
方法创建一个新数组，其结果是该数组中的每个元素都调用一个提供的函数后返回的结果。
var array1=[1，4，9，16]；
//将函数传递给地图
const map 1=数组1。map((x)=x * 2)；
控制台。日志(地图1)；
//预期输出：Array [2，8，18，32]
Array.pop()
方法从数组中删除最后一个元素，并返回该元素的值。此方法更改数组的长度。
var plants=[西兰花,花椰菜,卷心菜,羽衣甘蓝,番茄];
控制台。原木(植物。pop())；
//预期输出："番茄"
console.log(植物);
//预期输出：数组[花椰菜,花椰菜,卷心菜,甘蓝]
植物。pop()；
console.log(植物);
//预期输出：数组[花椰菜,花椰菜,卷心菜]
Array.push()
方法将一个或多个元素添加到数组的末尾，并返回新数组的长度。
var animals=[猪,山羊,绵羊];
console.log(animals.push(奶牛));
//预期输出：4
console.log(动物);
//预期输出：数组[猪,山羊,绵羊,牛]
动物.推(小鸡);
console.log(动物);
//预期输出：数组[猪,山羊,绵羊,牛,鸡]
Array.reduce()
方法对累加器和数组中的每个元素（从左到右)应用一个函数，将其减少为单个值。
常量数组1=[1,2,3,4];
常数变径=(累加器，当前值)=累加器当前值；
//1 2 3 4
控制台。日志(数组1。reduce(减速器))；
//预期输出：10
//5 1 2 3 4
控制台。日志(数组1。reduce(reducer，5))；
//预期输出：15
Array.reduceRight()
方法接受一个函数作为累加器（累加器)和数组的每个值（从右到左)将其减少为单个值。
const array1=[
[0, 1],
[2, 3],
[4, 5],
].reduceRight((累加器，当前值)=累加器。concat(当前值))；
控制台。log(数组1)；
//预期输出：Array [4，5，2，3，0，1]
Array.reverse()
方法将数组中元素的位置颠倒。
var array1=[一,二,三];
console.log(array1:，array 1)；
//预期输出：数组[一,二,三]
var reversed=数组1。反向()；
console.log(reversed:，reversed)；
//预期输出：数组[三,二,一]
/*小心：反向是破坏性的。它也会改变
原始数组*/
console.log(array1:，array 1)；
//预期输出：数组[三,二,一]
Array.shift()
方法从数组中删除第一个元素，并返回该元素的值。此方法更改数组的长度。
var array1=[1，2，3]；
变量第一个元素=数组1。shift()；
控制台。log(数组1)；
//预期输出：数组[2，3]
控制台。日志(第一个元素)；
//预期输出：1
Array.slice()
方法返回一个从开始到结束（不包括结束)选择的数组的一部分浅拷贝到一个新数组对象。且原始数组不会被修改。
var animals=[蚂蚁,野牛,骆驼,鸭子,大象];
控制台。日志(动物。切片(2))；
//预期输出：数组[骆驼,鸭子,大象]
console.log(animals.slice(2，4))；
//预期输出：数组[骆驼，鸭子]
console.log(animals.slice(1，5))；
//预期输出：Array [野牛，骆驼，鸭子，大象]
Array.some()
方法测试数组中的某些元素是否通过由提供的函数实现的测试。
var array=[1，2，3，4，5]；
var偶数=函数（元素){
//检查元素是否是偶数
返回元素% 2===0;
};
控制台。日志(数组。有的(甚至))；
//预期输出：真
Array.sort()
方法用原地算法对数组的元素进行排序，并返回数组。排序不一定是稳定的。默认排序顺序是根据字符串统一码码点。
var months=[三月,一月,二月,十二月];
几个月。sort()；
console.log(月);
//预期输出：数组[十二月，二月，一月，三月]
var array1=[1，30，4，21]；
数组1。sort()；
控制台。log(数组1)；
//预期输出：Array [1，21，30，4]
Array.splice()
方法通过删除现有元素和/或添加新元素来更改一个数组的内容。
var months=[Jan ， March ， April ， June ]；
months.splice(1，0，“Feb”)；
//增
console.log(月);
//预期输出：Array [一月，二月，三月，四月，六月]
months.splice(4，1， May )；
//改
console.log(月);
//预期输出：Array [一月，二月，三月，四月，五月]
//删
months.splice(4，1)；
console.log(月);
//输出：[一月,二月,三月,四月]
Array.toLocaleString()
返回一个字符串表示数组中的元素。数组中的元素将使用各自的方法方法转成字符串，这些字符串将使用一个特定语言环境的字符串（例如一个逗号,)隔开。
var array1=[1， a ，新日期( 1997年12月21日14:12:00 UTC )]；
var localeString=array 1。tolocalestring( en ，{时区： UTC })；
控制台。日志(localeString)；
//预期输出* " 1，a，1997年12月21日，下午2:12:00",
//这假定了“恩”区域设置和协调世界时。亦称COORDINATED UNIVERSAL TIME时区-您的结果可能会有所不同
定义变量价格=[7 ,500,8123,12];
prices.toLocaleString(ja-JP ，{ style: currency ，currency: JPY })；
//7,500,8,123,12
Array.toSource()
返回一个字符串，代表该数组的源代码。
var alpha=新数组( a ， b ， c )；
到source()；//返回[a ， b ， c]
Array.toString()
返回一个字符串，表示指定的数组及其元素。
var array1=[1，2， a ， 1a ]；
控制台。日志(数组1。tostring())；
//预期输出：“1，2，a，1a”
Array.unshift()
方法将一个或多个元素添加到数组的开头，并返回新数组的长度。
var array1=[1，2，3]；
console.log(array1.unshift(4，5))；
//预期输出：5
控制台。log(数组1)；
//预期输出：Array [4，5，1，2，3]
Array.values()
方法返回一个新的数组迭代器对象，该对象包含数组每个索引的值。
const array1=[a ， b ， c ]；
常量迭代器=数组1。values()；
对于(迭代器的常数值){
console.log(值);
//预期输出："甲" "乙" "丙"
}推荐学习：JavaScript视频教程以上是JS中数组对象的一些操作方法(带代码)的详细内容。请多关注我们的其他相关文章！
郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。