标签：至少1个，最多5个
一直以来想写一篇关于es5中新增数组的使用方法与源码实现的文章，拖了挺久了，趁着这夜深人静，大脑清醒，又困意不在的时刻写下来。也许有人会问，现如今es6都大行其道了，还学es5是不是有些过时了，?，温故而知新，可以从中多学点嘛，而且我们是要自己实现这些方法，知其然还要知其所以然，不光要会用，还要知道为什么是这样用哒。
新增方法预览
es5中给js的数组增添了许多实用的方法，利用这些方法可以帮助我们更加快速方便的写js代码，然后蛋疼的是低版本ie肯定是不支持的，所以..................自己动手丰衣足食。让我们一步步看下如何使用与实现这些方法。
lastIndexOf
reduceRight
这个方法作用是啥咧，就是循环，遍历。比如一般我们在for循环做这样的事的时候如下。
var arr = [1, 2, 3, 4, 5, 6];
for (var i = 0, len = arr. i & i++) {
console.log(arr[i], i, arr);
如果用forEach我们应该如何做呢？
var arr = [1, 2, 3, 4, 5, 6];
arr.forEach(function (e, i, array) {
console.log(e, i, array)
是不是觉得不用写for循环了，瞬间逼格都高了
forEach函数中的回调函数支持三个参数，1、数组的值，2、值的索引，3、数组本身。这样的调用方式是不是和jQuery中的$.each很像？ 其实不然，jQuery和forEach回调函数的第一个和第二个参数正好是反着来的。
var arr = [1, 2, 3, 4, 5];
// forEach
arr.forEach(function (e, i, array) {
console.log(e, i, array);
1 0 [1, 2, 3, 4, 5]
2 1 [1, 2, 3, 4, 5]
3 2 [1, 2, 3, 4, 5]
4 3 [1, 2, 3, 4, 5]
5 4 [1, 2, 3, 4, 5]
$.each(arr, function (i, e, array) { // 测试的时候发现array是undefined,查了文档也发现没有第三个参数
console.log(i, e, array);
0 1 undefined
1 2 undefined
2 3 undefined
3 4 undefined
4 5 undefined
接着我们来看一下forEach的第二个参数，这个参数决定第一个回调函数的内部this指向
var arr = [1, 2, 3, 4, 5];
默认情况下，第二个参数不传入时
arr.forEach(function (e, i, array) {
console.log(e, i, array, this);
1 0 [1, 2, 3, 4, 5] window
2 1 [1, 2, 3, 4, 5] window
3 2 [1, 2, 3, 4, 5] window
4 3 [1, 2, 3, 4, 5] window
5 4 [1, 2, 3, 4, 5] window
// 传入参数
arr.forEach(function (e, i, array) {
console.log(e, i, array, this);
}, {name: 'qianlong'})
1 0 [1, 2, 3, 4, 5] {name: 'qianlong'}
2 1 [1, 2, 3, 4, 5] {name: 'qianlong'}
3 2 [1, 2, 3, 4, 5] {name: 'qianlong'}
4 3 [1, 2, 3, 4, 5] {name: 'qianlong'}
5 4 [1, 2, 3, 4, 5] {name: 'qianlong'}
最后接下来我们自己实现一下这个方法
var ObjPro = Object.prototype,
hasOwn = ObjPro.hasOwnProperty,
nativeArray = ObjPro.forE
Array.prototype.forEach = nativeArray || function (callBack, ctx) {
if (typeof callBack != 'function')
for (var i =0, len = this. i & i++) {
if (hasOwn.call(this, i)) {
callBack.call(ctx, this[i], i, this);
map是干嘛的！ 其最主要的作用就是将原数组按照一定的规则映射成一个新的数组。再将其返回，注意是返回一个新的数组，而不是将原数组直接改变使用方式和forEach类似,也是接受一个回调函数，一个改变内部this指向的对象。
array.map(callback,[ thisObject])
var arr = [1, 2, 3, 4, 5];
arr.map(function(value, index, array) {
var arr = [1, 2, 3, 4, 5];
var newArr = arr.map(function (e, i, array) {
return 'hello ' +
["hello 1", "hello 2", "hello 3", "hello 4", "hello 5"] // newArr
[1, 2, 3, 4, 5] // arr
注意上面的return，如果我们不写return会怎样呢？
var arr = [1, 2, 3, 4, 5];
var newArr = arr.map(function (e, i, array) {
'hello ' +
[undefined, undefined, undefined, undefined, undefined] // newArr
[1, 2, 3, 4, 5] // arr
这一堆的undefined是啥情况，还记得一个函数执行完，如果没有显示的返回值，会返回什么吗？ 没错 就是undefined，这就是原因所在，等会通过源码，你就会更加明白。
最后我们自己实现一下map这个方法
var ObjPro = Object.prototype,
hasOwn = ObjPro.hasOwnProperty,
nativeMap = ObjPro.
Array.prototype.map = nativeMap || function (callBack, ctx) {
if (typeof callBack != 'function')
var returnArr = [];
for(var i = 0, len = this. i & i++) {
returnArr.push(callBack.call(ctx, this[i], i, this)); // 这就是为什么回调函数没有返回值的情况下会得到一堆的undefined值，他将回调函数的返回值push到了一个数组里面，当你没有显示的返回值的时候，自然push进去的就是undefined了
接下来是filter,筛选，过滤的意思，给你一个数组，用一些你制定的条件，对其中的值进行过滤，最后得到你想要的新的数组。基本用法和map差不多
array.filter(callback,[ thisObject]);
但是和map也有差别的地方，filter需要你在callback处返回弱等于true 的值,才会将原数组中筛选出的值返回给你。
var arr = [0, 1, 2, 3, 4, 5];
var newArr = arr.filter(function (e, i, array) {
[1, 2, 3, 4, 5] // newArr
var newArr2 = arr.filter(function (e, i, array) {
if (e &= 2)
[2, 3, 4, 5] // newArr2
当然最后还有第二个参数改变内部this指向的参数可选，默认是window对象，你也可以传一个对象进去, 最后我们自己来实现一下这个api
var ObjPro = Object.prototype,
hasOwn = ObjPro.hasOwnProperty,
nativeFilter = ObjPro.
Array.prototype.filter = nativeFilter || function (callBack, ctx) {
if (typeof callBack != 'function')
var returnArr = [];
for(var i = 0, len = this. i & i++) {
if (callBack.call(ctx, this[i], i, this)) {
returnArr.push(this[i]);
return returnA
some vs every
some与接下里的every正好相对，some是只要数组中的某个值，符合你给定的判断条件就返回true，而every则是数组中的所有值都符合你给定的判断条件的时候才会返回true，否则就返回false,也就是说两个方法最后得到的都是true or false
var arr = [0, 1, 2, 3, 4, 5];
var result = arr.some(function (e, i, array) {
if (e === 3) {return true};
var arr = [0, 1, 2, 3, 4, 5];
var result2 = arr.every(function (e, i, array) {
if (e & 3) {return true};
some 和 every使用起来非常简单，接下来我们自己实现一把
var ObjPro = Object.prototype,
hasOwn = ObjPro.hasOwnProperty,
nativeSome = ObjPro.some,
nativeEvery = ObjPro.
Array.prototype.some = nativeSome || function (callBack, ctx) {
if (typeof callBack != 'function')
var resultValue =
for(var i = 0, len = this. i & i++) {
if (resultValue) {
resultValue = !!callBack.call(ctx, this[i], i, this);
Array.prototype.every = nativeEvery || function (callBack, ctx) {
if (typeof callBack != 'function')
var resultValue =
for (var i = 0, len = this. i & i++) {
if (!resultValue) {
resultValue = !!callBack.call(ctx, this[i], i, this);
return resultV
数组的indexOf方法和字符串的indexOf用法非常类似，array.indexOf(searchElement[, fromIndex]),针对给定的要查找的值，和开始查找的位置(可选)，返回整数索引值。
var arr = [0, 1, 2, 3, 4, 5];
arr.indexOf(1) // 1
arr.indexOf(3, 'qianlong') // 3 因为给定的开始索引值不能转化成数字，所以还是从0位置开始搜索
arr.indexOf(3, 4) // -1
arr.indexOf(3, '4') // -1
arr.indexOf('3') // -1 // 判断条件是强 3 !== '3' =& -1
var ObjPro = Object.prototype,
hasOwn = ObjPro.hasOwnProperty,
nativeIndexOf = ObjPro.indexOf;
Array.prototype.indexOf = nativeIndexOf || function (searchElement, fromIndex) {
var returnIndex = -1,
fromIndex = fromIndex * 1 || 0;
for (var i = fromIndex, len = this. i & i++) {
if (searchElement === this[i]) {
returnIndex =
return returnI
lastIndexOf
数组的lastIndexOf方法和字符串的lastIndexOf用法非常类似，array. lastIndexOf(searchElement[, fromIndex]),针对给定的要查找的值，和开始查找的位置(可选)，返回整数索引值。与indexOf不同的地方在于，它是从后往前查找。默认开始查找的位置是 array.length - 1
var arr = [0, 1, 2, 3, 4, 5, 4, 3, 2, 1, 0];
arr.lastIndexOf(1) // 9
arr.lastIndexOf(3, 'qianlong') // -1 这里和indexOf不一样，传入的值不能转化为数字将得到-1
arr.lastIndexOf(3, 4) // 3
arr.lastIndexOf(3, '4') // 3
arr.lastIndexOf('3') // -1 // 判断条件是强 3 !== '3' =& -1
var ObjPro = Object.prototype,
hasOwn = ObjPro.hasOwnProperty,
nativeLastIndexOf = ObjPro.lastIndexOf;
Array.prototype.lastIndexOf = nativeLastIndexOf || function (searchElement, fromIndex) {
var len = this.length,
returnIndex = -1,
fromIndex = fromIndex * 1 || len - 1;
for (var i = fromI i & -1; i -= 1) {
if (this[i] === searchElement){
returnIndex =
return returnI
reduce 相对es5中数添加的其他方法都复杂一些，我们可以通过栗子来看一下这个api怎么使用。首先基本参数如下
array.reduce(callback[, initialValue]),接收一个回调函数，一个初始化的值initialValue 。其中callback参数分别是初始化的值initialValue ,如果没有传入initialValue,则默认是数组的第一项。第二个及其后面的参数分别是当前值,索引,数组本身
var arr = [0, 1, 2, 3, 4, 5],
sum = arr.reduce(function (init, cur, i, array) {
return init +
我们来看一下上面的执行过程是怎样的。
// 因为initialValue没有传入所以回调函数的第一个参数为数组的第一项
=& init + cur = 1;
=& init + cur = 3;
=& init + cur = 6;
=& init + cur = 10;
init = 10;
=& init + cur = 15;
最后得到结果15
那么我们如何自己实现一个reduce呢？
var ObjPro = Object.prototype,
hasOwn = ObjPro.hasOwnProperty,
nativeReduce = ObjPro.
Array.prototype.reduce = nativeReduce || function (callBack, initialVal) {
if (typeof callBack != 'function')
var init = initialVal,
if (init === void (0)) {
init = this[0];
for (i, len = this. i & i++) {
if (hasOwn.call(this, i)) {
init = callBack(init, this[i], i, this);
reduceRight
reduceRight基本用法与reduce类似，好比indexOf与lastIndexOf，不同之处在于它是从最右边的值开始计算的。我们直接去看源码怎么实现吧
var ObjPro = Object.prototype,
hasOwn = ObjPro.hasOwnProperty,
nativeReduceRight = ObjPro.reduceR
Array.prototype.reduceRight = nativeReduceRight || function (callBack, initialVal) {
if (typeof callBack != 'function')
var init = initialVal,
len = this.length,
i = len - 1;
if (init === void(0)) {
init = this[len - 1];
for (i; i & -1; i -=1) {
if (hasOwn.call(this, i)) {
init = callBack(init, this[i], i, this);
终于写完了，断断续续快写了两天，欢迎大家看了以后提一些意见，函数实现的不一定都对，肯定有一些问题的地方，欢迎大家指正。
最后把代码放到github上面了
各位大大，请让我打个小广告。???
0 收藏&&|&&7
你可能感兴趣的文章
你可能感兴趣的文章
分享到微博？
我要该，理由是：
在 SegmentFault，学习技能、解决问题
每个月，我们帮助 1000 万的开发者解决各种各样的技术问题。并助力他们在技术能力、职业生涯、影响力上获得提升。es5数组方法用法 - 简书
es5数组方法用法
indexof .lastIndexOf
顾名思义，这两个方法用于查找数组内指定元素位置，查找到第一个后返回其索引，没有查找到返回-1，indexOf从头至尾搜索，lastIndexOf反向搜索。
var a = [1,2,3,3,2,1];
console.log(a.indexOf(2)); //1
console.log(a.lastIndexOf(2)); //4
2 ##.forEach(element, index, array)
遍历数组，参数为一个回调函数，回调函数有三个参数：
当前元素索引值
var a = new Array(1,2,3,4,5,6);
a.forEach(function(e,i,array){
array[i]= e + 1;
console.log(a); //[2, 3, 4, 5, 6, 7]
3 ##.every、some、
这两个函数类似于离散数学中的逻辑判定，回调函数返回一个布尔值
every是所有函数的每个回调函数都返回true的时候才会返回true，当遇到false的时候终止执行，返回false
some函数是“存在”有一个回调函数返回true的时候终止执行并返回true，否则返回false
在空数组上调用every返回true，some返回false
var a=new Array(1,2,3,4,5,6);
console.log(a.every(function(e, i, arr){
return e & 5;
console.log(a.some(function(e,i,arr){
return e & 4;
4 ##map(function(element))
与forEach类似，遍历数组，回调函数返回值组成一个新数组返回，新数组索引结构和原数组一致，原数组不变
var a = new Array(1,2,3,4,5,6);
console.log(a.map(function(e){
return e *
// [1, 4, 9, 16, 25, 36]
console.log(a); //[1, 2, 3, 4, 5, 6]
5##.filter(function(element))
返回数组的一个子集，回调函数用于逻辑判断是否返回，返回true则把当前元素加入到返回数组中，false则不加
新数组只包含返回true的值，索引缺失的不包括，原数组保持不变
var a = new Array(1,2,3,4,5,6);
console.log(a.filter(function(e){
return e % 2 == 0;
})); // [2, 4, 6]
console.log(a); //[1, 2, 3, 4, 5, 6]
6##.reduce(function(v1, v2), value) / .reduceRight(function(v1, v2), value)
遍历数组，调用回调函数，将数组元素组合成一个值，reduce从索引最小值开始，reduceRight反向，方法有两个参数
回调函数：把两个值合为一个，返回结果
value，一个初始值,可选
var a = new Array(1,2,3,4,5,6);
console.log(a.reduce(function(v1, v2){
return v1 + v2;
})); // 21
console.log(a.reduceRight(function(v1, v2){
return v1 - v2;
}, 100)); // 79
pdf下载地址：Java面试宝典 第一章内容介绍 20 第二章JavaSE基础 21 一、Java面向对象 21 1. 面向对象都有哪些特性以及你对这些特性的理解 21 2. 访问权限修饰符public、private、protected, 以及不写（默认）时的区别(201...
第2章 基本语法 2.1 概述 基本句法和变量 语句 JavaScript程序的执行单位为行（line），也就是一行一行地执行。一般情况下，每一行就是一个语句。 语句（statement）是为了完成某种任务而进行的操作，比如下面就是一行赋值语句： vara =1+3; 这条...
Javascript有很多数组的方法，有的人有W3C的API，还可以去MDN上去找，但是我觉得API上说的不全，MDN上又太多。。其实常用的就那几个，很多都可以用那几个方法解出来。 很多方法中有兼容性的，在使用的时候，把兼容代码复制粘贴即可。 先贴上来数组和字符串的方法的比...
Lua 5.1 参考手册 by Roberto Ierusalimschy, Luiz Henrique de Figueiredo, Waldemar Celes 云风译www.codingnow.com Copyright (C) 2006 Lua.org, PUC-Rio...
盘点分为 1.盘点前 2.盘点中 3.盘点后 4.注意事项 盘点流程：盘点前三天盘点员发布应该盘点的店铺（防舞弊）――店铺安排盘点人员数量――店铺进行无条码及后台账务处理――店铺货品整理（仓库，卖场）――每个货架貼地点标号（左上为始，右下为末）――店长发地点标号给盘点人员进...
我们是有缺陷的人类。 我们最常见的一个共同缺陷是——我们讨厌不舒服。 仔细想想，我们至今为止花费多少时间和精力来避免超出我们自己严格界定的舒适区域？ 我们不减肥，即使我们知道我们必须做些什么——管住嘴，迈开腿。只是因为不吃我们喜欢的食物和多加的锻炼听起来就会使我们不舒服。 ...
天降辅助系统
一场不平凡的排位，让我这一个在班里人人都看不起的三年级的小学生瞬间变成了人人都想交朋友的人。
那天，我带着被同学们嘲笑、被野狗咬、被老师骂、被别人推到臭水沟里的心情打了一局排位。 “妈的，刚开局...
幸福很简单，需要一双眼睛，一颗体会的心便可，当孩子或父母需要你，你又能满足他们的时刻，找到了自己的存在感，原来辛福很简单！
这些黑料新闻很快也惊动了尹飘笙本人。 第二天一大早，仓王大厦顶层，尹飘笙360度环形视野的办公室里。 他大屏幕电脑上，满屏都是各论坛里他的黑料文界面。 他看着这些内容，微微皱着眉头，这个发文的人想象力不错。 突然身穿性感套装、身材火辣高挑的阿May敲门进来。 “尹总，已经查...ES5中新增的一些处理数组（Array）的方法， 对于用JavaScript处理数据非常有用。我总结了一下，给这些方法分了类，大体如下：
2个索引方法：indexOf() 和 lastIndexOf()；
5个迭代方法：forEach()、map()、filter()、some()、every()；
2个归并方法：reduce()、reduceRight()；
下面我们来具体看一看这些方法怎么用吧！
二、索引方法
索引方法包含indexOf()和lastIndexOf()两个方法，这两个方法都接收两个参数，第一个参数是要查找的项，第二个参数是查找起点位置的索引，该参数可选，如果缺省或是格式不正确，那么默认为0。两个方法都返回查找项在数组中的位置，如果没有找到，那么返回-1。区别就是一个从前往后找，一个从后往前找。
让我们来看一个具体列子吧，首先定义一个数组：
var dataArray = [1, 7, 5, 7, 1, 3];
indexOf()：该方法从数组的开头开始向后查找。
console.log(dataArray.indexOf(7));
缺省, 从第一项开始查找
console.log(dataArray.indexOf(7, 's'));
格式不正确, 从第一项开始查找
console.log(dataArray.indexOf(7, 2));
// 3　　　从第三个项之后开始查找
console.log(dataArray.indexOf (2));
未找到, 返回-1
lastIndexOf()： 该方法从数组的末尾开始向前查找。
console.log(dataArray.lastIndexOf (7));
缺省, 从末尾第一项开始查找
console.log(dataArray.lastIndexOf (7, 's'));
格式不正确, 从末尾第一项开始查找
console.log(dataArray.lastIndexOf (7, 2));
// 1 　　从末尾第三项往前查找
console.log(dataArray.lastIndexOf ('4'));
未找到, 返回-1
值得注意的是，在比较第一个参数与数组中的每一项时，会使用全等操作符， 要求必须完全相等,否则返回-1。
console.log(dataArray .lastIndexOf ('7'));
// -1，因为这里是字符串，并不是数值类型
三、迭代方法
迭代方法包含some()、every()、filter()、map()和forEach()五个方法，这些方法都接收两个参数，第一个参数是一个函数，他接收三个参数，数组当前项的值、当前项在数组中的索引、数组对象本身。第二个参数是执行第一个函数参数的作用域对象，也就是上面说的函数中this所指向的值。注意，这几种方法都不会改变原数组。
every()和some()方法有些类似，我们放在一起比较。
every()：该方法对数组中的每一项运行给定函数，如果该函数对每一项都返回&true，则返回true。
some()： 该方法对数组中的每一项运行给定函数，如果该函数对任何一项返回&true，则返回true。
感觉有点绕，我们来对着例子讲一讲。& &
首先我们来看一下every方法，数组中的每一项都会执行给定的函数，如果数组中每一项执行该函数都返回true，那么我们结果返回true，否则返回false。
下面例子中，当我们设置item & 1时，第一项和第五项不符合，所以最终结果返回false。
下面例子中，当我们设置item & 0时，所有项都符合，那么我们最终结果为true。
接下来我们来看some方法，数组中的每一项都会执行给定的函数，只要有一项为true，那么结果结果为true。
下面这个例子，当我们设置item & 5时，第二项就符合，我们直接返回true。
而且值得注意的是，some方法会在数组中任一项执行函数返回true之后，不在进行循环。
下面例子中，我们设置item & 5,当数组中第二项7大于5时，停止循环，直接返回结果。
filter() ：该方法对数组中的每一项运行给定函数，返回该函数会返回 true 的项组成的数组。利用这个方法可对数组元素进行过滤筛选。
我们来看下面的例子，当我们设置item & 3时，数组中2、3、4像返回组成了一个新数组。
而且我们可以看出，当我们分别设置item & 3和item & '3'时, 返回的结果是一样的，由此我们可以看出函数支持弱等于（==），不是必须全等于（===）。
和filter() 方法类似，jquery中有个grep()方法也用于数组元素过滤筛选。
下面例子中，当我们设置item & 3时，返回的数组和我们用filter方法是一样的。
grep(array, function[, invert])方法，还有一个特性，当invert缺省或是为false，和filter方法一样，正常过滤出符合条件的数组元素，当invert值为true， 正好相反，他会过滤出函数返回值为false的数组元素。
我们来看下面的例子，当设置了invert参数为true之后，函数返回如下过滤后的数组。
map(): 该方法对数组中的每一项运行给定函数，返回每次函数调用的结果组成的数组。
我们来看下面的例子，我们为数组中的每一项乘以3，返回每一项相乘之后的数组。
&我们接下来定义一个航班数组，每次返回该数组元素的航空公司，组成新数组。
&forEach(): 该方法对数组中的每一项运行给定函数。这个方法没有返回值。这个方法其实就是遍历循环，和for循环没有太大差别。jquery()也提供了相应的方法each()方法。
下面的例子我们依次进行for循环、forEach方法、each方法的调用，最终执行结果相同。
四、归并方法
归并方法包含reduce()和reduceRight()两个方法，这两个方法都会迭代数组中的所有项，然后生成一个最终返回值。他们都接收两个参数，第一个参数是每一项调用的函数，函数接受是个参数分别是初始值，当前值，索引值，和当前数组，函数需要返回一个值，这个值会在下一次迭代中作为初始值。第二个参数是迭代初始值，参数可选，如果缺省，初始值为数组第一项，从数组第一个项开始叠加，缺省参数要比正常传值少一次运算。
reduce()：该方法从数组的第一项开始，逐个遍历到最后一项。
这个方法比较复杂，我们来看一个例子&
代码如下：
具体看这个代码，首先我们在传入reduce的函数中打印了prev值，可以看到prev就是数组每两项的和。比如第一个是1，第二个就是1+7 = 8，以此类推。
最后，我们把结果返回给了sum，那sum自然就是数组的每一项之和。这是没设置第二个参数的情况。
下面我们来看看设置了第二个参数为2的例子。
我们可以看出，当设置了第二个参数。我们第一个prev输出的结果就是第二个参数的值。设置了这个参数，会多执行一次。
利用这种方法，我们可以快速的把二维数组转化为一维数组。
顾名思义，reduceRight()就是从右到左，就不详细说了。
五、兼容性问题
ES5里这些处理数组的新方法，在IE6-IE8浏览器还未得到支持，所以我们需要在IE这些低版本浏览器中引入这个es5-shim补丁，这样我们就可以使用它了。
补丁地址：
本博客文章皆为原创，未尽许可，请勿转载 （）
阅读(...) 评论()为了账号安全，请及时绑定邮箱和手机
es5新增了哪些数组方法
写下你的评论...
Copyright (C) 2018 imooc.com All Rights Reserved | 京ICP备 号-11JavaScript ES5标准中新增了一些Array方法，如every()、some()、filter()、map()。它们的出现使我们能够更加便利地操作数组，但对IE9以下浏览器的兼容性比较差。下面来看一下它们的用法。
//数组中的元素全部满足指定条件返回true
//运行结果为false
var checknum = [15,3,2,6,7,1,9,10];
var checkresult = checknum.every(function(item,index,array){
return item & 1 ;
alert(checkresult);
//数组中的元素部分满足指定条件返回true
//运行结果为false
var checknum = [15,3,2,6,7,1,9,10];
var checkresult = checknum.some(function(item,index,array){
return item & 15;
alert(checkresult);
//把符合条件的项目组成一个新的数组
var checknum = [15,3,2,6,7,1,9,10];
var checkresult = checknum.filter(function(item,index,array){
return item & 3;
checkresult.forEach(function(value, index, array){
console.log(value);
//对数组元素进行运算并将运算结果
var checknum = [15,3,2,6,7,1,9,10];
var checkresult = checknum.map(function(value, index, array){
return '新值：' + parseInt(value + 1);
checkresult.forEach(function(value, index, array){
console.log(value);
阅读(...) 评论()