# V8源码浅析JS数组常见方法|博客系列

> 本文深入分析了V8引擎中JavaScript数组常用方法的实现原理，包括Array的创建方式、构造函数方法（如Array.of、Array.isArray）等，帮助开发者理解底层机制并提升手写数组方法的能力。

- 原文：https://feinterview.poetries.top/docs/fe-blog-docs/blog-docs/javascript/-V8%E6%BA%90%E7%A0%81%E6%B5%85%E6%9E%90JS%E6%95%B0%E7%BB%84%E5%B8%B8%E8%A7%81%E6%96%B9%E6%B3%95
- 来源：前端进阶之旅（feinterview.poetries.top）
- 更新：2025.10.25
- 可见范围：免费部分

---

## Array基础

要想手写数组方法，先补一补基础，得先会使用它们api

### 创建一个数组

```javascript
			//字面量
            let demo = [1, 2, 3]
            // 构造器
            let demo1 = Array(),
                demo2 = Array(3),
                demo3 = Array(1,2,3),
                demo4 = new Array(1,2,3);
```

### 构造函数上的方法

#### Array.of()

简单理解就是创建一个新数组的实例,可以看看与Array构造函数区别

语法:

```javascript
Array.of(element0[, element1[, ...[, elementN]]])
```

用法：

```js
Array.of(7);       // [7] 
Array.of(1, 2, 3); // [1, 2, 3]

Array(7);          // [ , , , , , , ]
Array(1, 2, 3);    // [1, 2, 3]
```

两者区别：`Array.of(7)` 创建一个具有单个元素 **7** 的数组，而 **Array(7)** 创建一个长度为7的空数组（**注意：**这是指一个有7个空位(empty)的数组，而不是由7个`undefined`组成的数组）。

-----

#### Array.isArray()

**Array.isArray()** 用于确定传递的值是否是一个 [`Array`](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Array)。

```js
Array.isArray([1, 2, 3]);  
// true
Array.isArray({foo: 123}); 
// false
Array.isArray("foobar");   
// false
Array.isArray(undefined);  
// false
```

**手动实现**

```js
			// Array.isArray
            if(!Array.isArray){
                Array.isArray = obj => Object.prototype.toString.call(obj) === '[object Array]'
            }
```

判断JS数据类型，可以看看我之前写的博客 [聊一聊typeof instanceof 实现原理](https://juejin.im/post/5ef575706fb9a07eb86922a7)

----

#### Array.from()

`Array.from()` 方法从一个类似数组或可迭代对象创建一个新的，浅拷贝的数组实例。

```js
Array.from(arrayLike[, mapFn[, thisArg]])
```

##### 参数

- arrayLike:  必选，可以传入 1、类数组(argumentg) 2、可迭代对象(set,map)。
- mapFn: 可选，相当于Array.from(arrayLike).map(mapFn, thisArg)。
- thisArg: 可选，执行回调函数mapFn时候的this对象。非常有用，利于解耦。可以把被处理的数据和对象分离，thisArg中定义处理函数handle，用来在mapFn中返回调用handle之后的结果。

##### 用法

**String**

```js
			// Array.from()
            const demo = Array.from('123')
            console.log(demo) //[ 'a', 'b', 'c' ]
```

**new Set()**

```js
			const Array_demo = Array.from(new Set([1,2,3,4,1,2,3]))
            console.log(Array_demo)  // [1,2,3,4]
```

**new Map()**

```js
const map = new Map([[1, 2], [2, 4], [4, 8]]);
Array.from(map);
// [[1, 2], [2, 4], [4, 8]]
```

**类数组**

```js
const fn = (function() {
    const demo = Array.from(arguments);
    console.log(demo);
})(1,2,3); // [ 1, 2, 3 ]
```

**数组去重合并**

```js
			let fn = function () {
                console.log(arguments)
                const Arr_new = [].concat.apply([],arguments)
                return Array.from(new Set(Arr_new))
            }
            const   demo1 = [1, 2, 3, 4],
                    demo2 = [4,5,6,2,2,2],
                    demo3 = [1,2,3,4,2,2,3,4];
            console.log(fn(demo1,demo2,demo3))
            // [1,2,3,4,5,6]
```

**充分利用第三个参数thisArg**

```js
		const obj = {
            handle: x => x * 4 
        }
        console.log(Array.from([11, 22, 33], function (x) {
            return this.handle(x)
        }, obj))
        // [44, 88, 132]
```

##### **思路**

- 判断arrayLike是否为空
- 根据mapFn判断是否为构造函数，为构造函数，每次遍历时，让arr[i] = mapFn(iValue,i), 不是构造函数时，arr[i] = iValue
- 判断thisArg是否存在,存在的话 arr[i] = mapFn.call(thisArg, iValue,i)

**参考源码在V8中**[array.js第1763行开启Array.from之旅](https://github.com/v8/v8/blob/4.9-lkgr/src/js/array.js#L1763)

```js
		/**
         * 实现Array.from
         * toInteger方法:返回一个整数
         * toLength方法: 保证len数字合法[0~Number.MAX_SAFE_INTEGER]
         * Number.MAX_SAFE_INTEGER = Math.pow(2,53) - 1
         * 判断arrayLike 为 空 抛出错误
         * mapFn非空并且不是构造函数抛出错误
         * 每次遍历arrayLike,如果mapFn存在, arr[i] = mapFn(iValue,i) 不存在的话 arr[i] = iValue
         * 判断thisArg是否存在,存在的话 arr[i] = mapFn.call(thisArg, iValue,i)
         * */
        Array.myfrom = (function () {
            const toStr = Object.prototype.toString
            const isCallable = fn => typeof fn === 'function' || toStr.call(fn) === '[object Function]'
            
            const toInteger = value => {
                const v = Number(value)
                if(isNaN(v))    return 0
                // 无穷大或者0 直接返回
                if(v === 0 || !isFinite(v)) return v
                return (v > 0 ? 1 : -1) * Math.floor(Math.abs(v))
            }
            // 最大的范围Number.MAX_SAFE_INTEGER
            const maxSafeInteger = Number.MAX_SAFE_INTEGER
            
            const toLength = value => {
                const len = toInteger(value)
                return Math.min(maxSafeInteger, Math.max(0, len))
            }
            return function myfrom (arrayLike/*, mapFn, thisArg*/) {
                const that = this
                if(arrayLike === null) throw new TypeError("Array.from requires an array-like object - not null or undefined")
                
                const items = Object(arrayLike)
                let thisArg = ''
                // 判断mapFn是否undefined, 这里最好不要直接使用undefined,因为undefined不是保留字,
                // 很有可能undefined是个值  最好用 void 0 或者 void undefined 
                const mapFn = arguments.length > 1 ? arguments[1] : void 0
                if( typeof mapFn !== 'undefined') {
                    // 接下来判断第二个参数是不是构造函数
                    if( !isCallable(mapFn) ) throw new TypeError("Array.from when provided mapFn must be a function")
                    if( arguments.length > 2) thisArg = arguments[2]
                }
                const len = toLength(items.length)
                const arr = isCallable(that) ? Object(new that(len)) : new Array(len)

                let i = 0,
                    iValue;
                while ( i < len) {
                    iValue = items[i]
                    if(mapFn) arr[i] = typeof thisArg === 'undefined' ? mapFn(iValue,i) : mapFn.call(thisArg, iValue, i)
                    else 
                        arr[i] = iValue
                    i++
                }
                arr.length = len
                return arr
            }
        })()
```

👍不得不说，把Array.from()实现出来后，其实收获很多东西的。

----------------

## 常见方法

为了简单记忆，方便查找，将主要方法分为三类 : 数组可遍历方法，会修改原数组方法，返回新数组方法。

### 遍历方法

js中遍历数组并不会改变原始数组的方法总共有12个:

```js
 	ES5：
    forEach、every 、some、 filter、map、reduce、reduceRight、
    ES6：
    find、findIndex、keys、values、entries
```

---

#### forEach()

**语法：**

```js
    array.forEach(callback(currentValue, index, arr), thisArg)
```

**参数:**

```
 callback:为数组中每个元素执行的函数，该函数接收一至三个参数
 		  currentValue 数组中正在处理的当前元素
 		  index (可选)  数组中正在处理的当前元素的索引
 		  arr (可选)    forEach() 方法正在操作的数组
 thisArg      可选参数,当执行回调函数callback,用作this值
```

**讲一讲thisArg用法吧**

```js
function Counter() {
  this.sum = 0;
  this.count = 0;
}
Counter.prototype.add = function(array) {
  array.forEach(function(entry) {
    this.sum += entry;
    ++this.count;
  }, this);
  // ^---- Note
};

const obj = new Counter();
obj.add([2, 5, 9]);
obj.count;
// 3 === (1 + 1 + 1)
obj.sum;
// 16 === (2 + 5 + 9)
```

很明显，第9行中传入的this，决定了forEach回调函数中this指向的问题。

第14行，obj调用了add方法，所以this指向的就是obj，也就是forEach中this指向的就是obj这个对象了。

> **注意：**如果使用[箭头函数表达式](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Functions/Arrow_functions)来传入函数参数， `thisArg` 参数会被忽略，因为箭头函数在词法上绑定了 [`this`](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Operators/this) 值

看看源码v8中array.js[第1258行开始forEach之旅](https://github.com/v8/v8/blob/4.9-lkgr/src/js/array.js#L1258)

**我们试着模仿写一个：**

```js
		/**
         * Array.prototype.forEach(callback, thisArg)
         * 除了抛出异常外,无法终止或者跳出forEach()循环
         * 遍历数组
         **/
        Array.prototype.myforEach = function (callback, thisArg) {
            if( this == null ) throw new TypeError("this is null or not defined")
            let newArr = Object(this)
            let len = newArr.length >>> 0
            if( typeof callback !== 'function' ) throw new TypeError(callback + ' is not a function');
            let thatArg = arguments.length >= 2 ? arguments[1] : void 0
            let k = 0

            while( k < len ) {
                
                if(k in newArr){ 
                    callback.call(thatArg, newArr[k], k, newArr);
                }
                k++
            }
            return void 0
        }
```

**从代码角度来看，你需要注意的点：**

- 无法中途退出循环，每次你都是调用回调函数的，return只能退出本次回调
- 该方法返回的是undefined, 即使你return 一个值也没有用
- thisArg改变的是回调函数中的this，从源码中可以看出来，还有就是如果回调函数是箭头函数的话，我们知道箭头函数是无法改变this的，所以会忽略thisArg

----

#### every()

**定义：**

测试一个数组内的所有元素是否都能通过某个指定函数的测试。它返回一个布尔值。

**语法:**

```js
    array.every(function(currentValue, index, arr), thisArg)
```

**参数:**

```markdown
 callback:为数组中每个元素执行的函数，该函数接收一至三个参数
 		  currentValue 数组中正在处理的当前元素
 		  index (可选)  数组中正在处理的当前元素的索引
 		  arr (可选)    every() 方法正在操作的数组
 thisArg      可选参数,当执行回调函数callback,用作this值
```

**用法：**

```js
function isBigEnough(element, index, array) {
  return element >= 10;
}
[12, 5, 8, 130, 44].every(isBigEnough);   // false
[12, 54, 18, 130, 44].every(isBigEnough); // true
```

**看看源码v8中array.js**[第1322行开始every之旅](https://github.com/v8/v8/blob/4.9-lkgr/src/js/array.js#L1322)

```js
		/**
         * Array.prototype.every(callback, thisArg)
         **/
        Array.prototype.myevery = function (callback, thisArg) {
            if( this == null ) throw new TypeError("this is null or not defined")
            let newArr = Object(this)
            let len = newArr.length >>> 0
            if( typeof callback !== 'function' ) throw new TypeError(callback + ' is not a function');
            let thatArg = arguments.length >= 2 ? arguments[1] : void 0
            let k = 0

            while( k < len ) {
                
                if(k in newArr){ 
                    let testResult = callback.call(thatArg, newArr[k], k, newArr);
                    if( !testResult ) return false
                }
                k++
            }
            return true
        }
```

**从代码角度来看，你需要注意的点：**

- 空数组的情况下，只要第一个参数是回调函数，一切情况返回为true
- 要每次返回值都为true,最后返回true,否则为false
- 如果thisArg参数的话，则`callback` 被调用时的 `this` 值，在非严格模式下为全局对象，在严格模式下传入 `undefined`，详见 `this` 条目。
- every不会改变原数组
- `every` 遍历的元素范围在第一次调用 `callback` 之前就已确定了。在调用 `every` 之后添加到数组中的元素不会被 `callback` 访问到。如果数组中存在的元素被更改，则他们传入 `callback` 的值是 `every` 访问到他们那一刻的值。那些被删除的元素或从来未被赋值的元素将不会被访问到。

-----

#### some

**定义：**

测试数组中是不是至少有1个元素通过了被提供的函数测试。它返回的是一个Boolean类型的值

**语法:**

```js
    array.some(function(currentValue, index, arr), thisArg)
```

**参数:**

```markdown
 callback:为数组中每个元素执行的函数，该函数接收一至三个参数
 		  currentValue 数组中正在处理的当前元素
 		  index (可选)  数组中正在处理的当前元素的索引
 		  arr (可选)    some() 方法正在操作的数组
 thisArg      可选参数,当执行回调函数callback,用作this值
```

**用法：**

```js
function isBiggerThan10(element, index, array) {
  return element > 10;
}
[2, 5, 8, 1, 4].some(isBiggerThan10);  // false
[12, 5, 8, 1, 4].some(isBiggerThan10); // true

//此例中为模仿 includes()  方法, 若元素在数组中存在, 则回调函数返回值为 true :
var fruits = ['apple', 'banana', 'mango', 'guava'];

function checkAvailability(arr, val) {
  return arr.some(function(arrVal) {
    return val === arrVal;
  });
}

checkAvailability(fruits, 'kela');   // false
checkAvailability(fruits, 'banana'); // true
```

**看看源码v8中array.js**[第1298行开始some之旅](https://github.com/v8/v8/blob/4.9-lkgr/src/js/array.js#L1298)

```js
		/**
         * 测试数组中是不是至少有1个元素通过了被提供的函数测试
         * Array.prototype.some(callback, thisArg)
         **/
        Array.prototype.mysome = function (callback, thisArg) {
            if (this == null) throw new TypeError("this is null or not defined")
            let newArr = Object(this)
            let len = newArr.length >>> 0
            if (typeof callback !== 'function') throw new TypeError(callback + ' is not a function');
            let thatArg = arguments.length >= 2 ? arguments[1] : void 0

            for (let i = 0; i < len; i++) {
                if (i in newArr && callback.call(thatArg, newArr[i], i, newArr))
                    return true
            }
            return false
        }
```

**从代码角度来看，你需要注意的点：**

- some不会改变原数组
- 如果用一个空数组进行测试，在任何情况下它返回的都是`false`
- 如果你回调函数没有返回值，每次都是undefined，最后调用some结果返回也是`false`
- 传入thisArg，回调函数中的this值，取决于this指向规则。

-----

#### filter

**定义：**

创建一个新数组, 其包含通过所提供函数实现的测试的所有元素。 

**语法:**

```js
let newArray = array.filter(function(currentValue, index, arr), thisArg)
```

**参数:**

```markdown
 callback:为数组中每个元素执行的函数，该函数接收一至三个参数
 		  currentValue 数组中正在处理的当前元素
 		  index (可选)  数组中正在处理的当前元素的索引
 		  arr (可选)    filter() 方法正在操作的数组
 thisArg      可选参数,当执行回调函数callback,用作this值
```

**用法：**

```js
function isBigEnough(element) {
  return element >= 10;
}
var filtered = [12, 5, 8, 130, 44].filter(isBigEnough);
// filtered is [12, 130, 44] 

var fruits = ['apple', 'banana', 'grapes', 'mango', 'orange'];

/**
 * Array filters items based on search criteria (query)
 */
function filterItems(query) {
  return fruits.filter(function(el) {
      return el.toLowerCase().indexOf(query.toLowerCase()) > -1;
  })
}

console.log(filterItems('ap')); // ['apple', 'grapes']
console.log(filterItems('an')); // ['banana', 'mango', 'orange']
```

**看看源码v8中array.js**[第1245行开始filter之旅](https://github.com/v8/v8/blob/4.9-lkgr/src/js/array.js#L1245)

```js
/**
         * 创建一个新数组, 其包含通过所提供函数实现的测试的所有元素。 
         * Array.prototype.filter(callback, thisArg)
         *
         */
        Array.prototype.myfilter = function (callback, thisArg) {
            if (this == null) throw new TypeError("this is null or not defined")
            let newArr = Object(this)
            let len = newArr.length >>> 0
            if (typeof callback !== 'function') throw new TypeError(callback + ' is not a function');
            let thatArg = arguments.length >= 2 ? arguments[1] : void 0,
                resultArr = new Array(len),
                count = 0

            for (let i = 0; i < len; i++) {
                if (i in newArr) {
                    if (typeof thatArg === 'undefined' && callback(newArr[i], i, newArr)) 
                        resultArr[count++] = newArr[i]
                    if (typeof thatArg !== 'undefined' && callback.call(thatArg, newArr[i], i, newArr)) 
                        resultArr[count++] = newArr[i]
                }
            }
            resultArr.length = count
            return resultArr
        }
```

**从代码角度来看，你需要注意的点：**

- 自定义回调函数要有Boolean返回值，不写默认返回undefined，则转Boolean为false
- 不会修改原始数组，但是会返回一个新数组，包含通过所提供函数实现的测试所以元素
- 没有任何元素通过的话，返回空数组
- `filter` 不会改变原数组，它返回过滤后的新数组
- `filter` 遍历的元素范围在第一次调用 `callback` 之前就已经确定了。在调用 `filter` 之后被添加到数组中的元素不会被 `filter` 遍历到。如果已经存在的元素被改变了，则他们传入 `callback` 的值是 `filter` 遍历到它们那一刻的值。被删除或从来未被赋值的元素不会被遍历到。
- 如果为 `filter` 提供一个 `thisArg` 参数，则它会被作为 `callback` 被调用时的 `this` 值。否则，`callback` 的 `this` 值在非严格模式下将是全局对象，严格模式下为 `undefined`。`callback` 函数最终观察到的 `this` 值是根据通常**函数所看到的 "this"的规则**确定的。
- 特别注意箭头函数中this指向

-------

#### map

**定义：**

创建一个新数组，其结果是该数组中的每个元素是调用一次提供的回调函数后的返回值。

**语法:**

```js
let newArray = array.map(function(currentValue, index, arr), thisArg)
```

**参数:**

```markdown
 callback:为数组中每个元素执行的函数，该函数接收一至三个参数
 		  currentValue 数组中正在处理的当前元素
 		  index (可选)  数组中正在处理的当前元素的索引
 		  arr (可选)    map() 方法正在操作的数组
 thisArg      可选参数,当执行回调函数callback,用作this值
```

**用法：**

```js
//数组中每个元素的平方根
var numbers = [1, 4, 9];
var roots = numbers.map(Math.sqrt);
// roots的值为[1, 2, 3], numbers的值仍为[1, 4, 9]

var numbers = [1, 4, 9];
var doubles = numbers.map(function(num) {
  return num * 2;
});

// doubles数组的值为： [2, 8, 18]
// numbers数组未被修改： [1, 4, 9]

//演示如何在一个 String  上使用 map 方法获取字符串中每个字符所对应的 ASCII 码组成的数组：
var map = Array.prototype.map
var a = map.call("Hello World", function(x) { 
  return x.charCodeAt(0); 
})
// a的值为[72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100]
```

**看看源码v8中array.js**[第1333行开始map之旅](https://github.com/v8/v8/blob/4.9-lkgr/src/js/array.js#L1333)

```js
/**
         * 一个由原数组每个元素执行回调函数的结果组成的新数组 
         * Array.prototype.map(callback, thisArg)
         *
         */
        Array.prototype.mymap = function (callback, thisArg) {
            if (this == null) throw new TypeError("this is null or not defined")
            let newArr = Object(this)
            let len = newArr.length >>> 0
            if (typeof callback !== 'function') throw new TypeError(callback + ' is not a function');
            let thatArg = arguments.length >= 2 ? arguments[1] : void 0,
                resultArr = new Array(len),
                mappedValue

            for (let i = 0; i < len; i++) {
                if (i in newArr) {
                    // 可能会有疑惑的地方
                    mappedValue = callback.call(thatArg, newArr[i], i, newArr)
                    resultArr[i] = mappedValue
                }
            }
            return resultArr
        }
```

可能有疑惑的地方就是第17行了吧，为什么可以直接写这样子，不需要考虑thisArg为void 0的情况，我当时是考虑分情况考虑的，但是后面想一想，哪怕是undefined值，你map执行的是回调函数，回调函数的this取值，非严格模式下，是window，

```js
		var numbers = [1, 4, 9];
        var doubles = numbers.map(function (num) {
            console.log(this)    // window
            return num * 2;
        }, void 0);
```

👆在控制台运行代码，你会发现传入thisArg，当值为undefined时，结果还是window，严格模式下当然就是undefined了，这个留给读者去思考

**从代码角度来看，你需要注意的点：**

- `map `不修改调用它的原数组本身（当然可以在 `callback` 执行时改变原数组）
- 回调函数不返回值时，最后新数组的每个值都为undefined
- `this`的值最终相对于`callback`函数的可观察性是依据`this`规则，也就是this指向问题
- 因为`map`生成一个新数组，当你不打算使用返回的新数组却使用`map`是违背设计初衷的，请用`forEach`或者`for-of`替代。
- `map` 方法处理数组元素的范围是在 `callback` 方法第一次调用之前就已经确定了。调用`map`方法之后追加的数组元素不会被`callback`访问。如果存在的数组元素改变了，那么传给`callback`的值是`map`访问该元素时的值。

----

#### reduce

**定义：**

对数组中的每个元素执行一个由您提供的**reducer**函数(升序执行)，将其结果汇总为单个返回值。

**语法:**

```js
let result = array.reduce(callback(accumulator, currentValue, currentIndex, array), initialValue)
```

**参数:**

```markdown
 callback:为数组中每个元素执行的函数，该函数接收一至4个参数
 		    accumulator 累计器
			currentValue 当前值
			currentIndex 当前索引
			array 数组
 initialValue      
作为第一次调用 callback函数时的第一个参数的值。 如果没有提供初始值，则将使用数组中的第一个元素。 在没有初始值的空数组上调用 reduce 将报错。
```

**用法：**

用例的只是简单用法，更多的reduce高级用法，最后有参考链接👇

```js
const arr = [3, 5, 1, 4, 2];
const a = arr.reduce((t, v) => t + v);
// 等同于
const b = arr.reduce((t, v) => t + v, 0);
```

看看gif动图怎么解释的👇

![](https://s.poetries.top/gitee/2020/09/24.png)

这可能是最简单的用法了，下面发散一下思维😼

```
// 功能型函数通道
const double = x => x + x;
const triple = x => 3 * x;
const quadruple = x => 4 * x;

// Function composition enabling pipe functionality
const pipe = (...functions) => input => functions.reduce(
    (acc, fn) => fn(acc),
    input
);

// Composed functions for multiplication of specific values
const multiply6 = pipe(double, triple);
const multiply9 = pipe(triple, triple);
const multiply16 = pipe(quadruple, quadruple);
const multiply24 = pipe(double, triple, quadruple);

// Usage
multiply6(6); // 36
multiply9(9); // 81
multiply16(16); // 256
multiply24(10); // 240
```

有时候，用好reduce真的是使开发变得高效起来✊

看看源码v8中array.js**[第1505行开始reduce之旅](https://github.com/v8/v8/blob/4.9-lkgr/src/js/array.js#L1505)

```js
/**
         * 对数组中的每个元素执行一个由您提供的reducer函数(升序执行)，将其结果汇总为单个返回值
         * Array.prototype.reduce(callback, initialValue)
         *
         */
        Array.prototype.myreduce = function (callback /*, initialValue*/ ) {
            if (this == null) throw new TypeError("this is null or not defined")
            let newArr = Object(this)
            let len = newArr.length >>> 0
            if (typeof callback !== 'function') throw new TypeError(callback + ' is not a function');
            let initialValue,
                k = 0

            if (arguments.length >= 2) {
                initialValue = arguments[1]
            } else {
                while (k < len && !(k in newArr))
                    k++
                if (k >= len)
                    throw new TypeError('Reduce of empty array with no initial value')
                initialValue = newArr[k++]
            }

            for (let i = k; i < len; i++) {
                if (i in newArr) {
                    initialValue = callback(initialValue, newArr[i], i, newArr)
                }
            }
            return initialValue
        }
```

**从代码角度来看，你需要注意的点：**

- 回调函数第一次执行时，`accumulator` 和`currentValue`的取值有两种情况：如果调用`reduce()`时提供了`initialValue`，`accumulator`取值为`initialValue`，`currentValue`取数组中的第一个值；如果没有提供 `initialValue`，那么`accumulator`取数组中的第一个值，`currentValue`取数组中的第二个值。
- 如果没有提供`initialValue`，reduce 会从索引1的地方开始执行 callback 方法，跳过第一个索引。如果提供`initialValue`，从索引0开始。
- 如果数组为空且没有提供`initialValue`，会抛出[`TypeError`]() 。
- 如果数组仅有一个元素（无论位置如何）并且没有提供`initialValue`， 或者有提供`initialValue`但是数组为空，那么此唯一值将被返回并且`callback`不会被执行。

reduce功能太强大了，有兴趣的人，可以好好去了解一下✊

当然了，有了这次代码的解析，相信你对reduce有了更深的认识

-------------

#### reduceRight

从右向左累加，跟reduce相似，源码的实现自然就会了✍

**定义：**

接受一个函数作为累加器（accumulator）和数组的每个值（从右到左）为单个值。，将其结果汇总为单个返回值。

**语法:**

```js
let result = array.reduceRight(callback(accumulator, currentValue, currentIndex, array), initialValue)
```

**参数:**

```markdown
 callback:为数组中每个元素执行的函数，该函数接收一至4个参数
 		    accumulator 上一次调用回调函数时，回调函数返回的值。
			currentValue 当前值
			currentIndex 当前索引
			array 数组
 initialValue      
首次调用 callback 函数时，累加器 accumulator 的值。如果未提供该初始值，则将使用数组中的最后一个元素，并跳过该元素。
```

**用法：**

这里就举个跟reduce的区别吧👏

```js
var a = ['1', '2', '3', '4', '5']; 
var left  = a.reduce(function(prev, cur)      { return prev + cur; }); 
var right = a.reduceRight(function(prev, cur) { return prev + cur; }); 

console.log(left);  // "12345"
console.log(right); // "54321"
```

看看源码v8中array.js**[第1505行开始reduceRight之旅](https://github.com/v8/v8/blob/4.9-lkgr/src/js/array.js#L1545)

实现的话，就拿一个类似指针的下标，从数组最后一位从后往前模拟😹 注意边界值就行

#### find findIndex

本方法在ECMAScript 6规范中被加入，可能不存在于某些实现中。

**定义：**

**find:**返回数组中满足提供的测试函数的第一个元素的值。否则返回 [`undefined`]()。

**findIndex：**数组中通过提供测试函数的第一个元素的**索引**。否则，返回-1。

**语法:**

```js
let ele = array.find(function(elemnet, index, arr), thisArg)
let eleIndex = array.findIndex(function(elemnet, index, arr), thisArg)
```

**参数:**

两者语法相似

```markdown
 callback:为数组中每个元素执行的函数，该函数接收一至三个参数
 		  elemnet 数组中正在处理的当前元素
 		  index (可选)  数组中正在处理的当前元素的索引
 		  arr (可选)     find方法正在操作的数组
 thisArg      可选参数,当执行回调函数callback,用作this值
```

**find用法：**

```js
//寻找数组中的质数
function isPrime(element, index, array) {
  var start = 2;
  while (start <= Math.sqrt(element)) {
    if (element % start++ < 1) {
      return false;
    }
  }
  return element > 1;
}

console.log([4, 6, 8, 12].find(isPrime)); // undefined, not found
console.log([4, 5, 8, 12].find(isPrime)); // 5
```

**findIndex用法：**

```js
//找数组中首个质数元素的索引 不存在素数返回-1
function isPrime(element, index, array) {
  var start = 2;
  while (start <= Math.sqrt(element)) {
    if (element % start++ < 1) {
      return false;
    }
  }
  return element > 1;
}

console.log([4, 6, 8, 12].findIndex(isPrime)); // -1, not found
console.log([4, 6, 7, 12].findIndex(isPrime)); // 2
```

看看源码v8中array.js**[第1633行开始find之旅](https://github.com/v8/v8/blob/4.9-lkgr/src/js/array.js#L1633)

```js
		/**
         * 返回数组中满足提供的测试函数的第一个元素的值。否则返回 undefined
         * Array.prototype.find(callback, thisArg)
         *
         */
        Array.prototype.myfind = function (callback /*, thisArg */ ) {
            if (this == null) throw new TypeError("this is null or not defined")
            let newArr = Object(this)
            let len = newArr.length >>> 0
            if (typeof callback !== 'function') throw new TypeError(callback + ' is not a function');

            let thatArg = arguments.length >= 2 ? arguments[1] : void 0

            for (let i = 0; i < len; i++) {
                if (i in newArr && callback.call(thatArg, newArr[i], i, newArr))
                    return newArr[i]
            }
            return void 0
        }
```

findIndex函数实现的原理一模一样，返回是下标就行❗

**从代码角度来看，你需要注意的点：**

- find方法不会改变原始数组
- 在第一次调用 `callback`函数时会确定元素的索引范围，因此在 `find`方法开始执行之后添加到数组的新元素将不会被 `callback`函数访问到。
- 如果数组中一个尚未被`callback`函数访问到的元素的值被`callback`函数所改变，那么当`callback`函数访问到它时，它的值是将是根据它在数组中的索引所访问到的当前值。被删除的元素仍旧会被访问到，但是其返回值已经是undefined了。
- 我看了很多关于find函数说法，我个人认为不指定`thisArg`参数的话，回调函数this指向并不是一直都是undefined，更合理的说话，**this符合this指向规则**。

---

#### keys & values & entries

**定义：**

 `keys() `方法返回一个包含数组中每个索引键的`**Array Iterator**`对象。

`values()` 方法返回一个新的 **Array Iterator** 对象，该对象包含数组每个索引的值

`entries()` 方法返回一个新的**Array Iterator**对象，该对象包含数组中每个索引的键/值对。

**语法:**

```js
arr.entries()
```

**用法：**

三者用法相似，举其中一个例子说明吧

```js
const array1 = ['a', 'b', 'c'];
const iterator1 = array1.entries();
const iterator2 = array1.values();
const iterator3 = array1.keys();
console.log(iterator1);
/*Array Iterator {}
         __proto__:Array Iterator
         next:ƒ next()
         Symbol(Symbol.toStringTag):"Array Iterator"
         __proto__:Object
*/	
```

**iterator.next()**

```js
var arr = ["a", "b", "c"]; 
var iterator = arr.entries();
console.log(iterator.next());

/*{value: Array(2), done: false}
          done:false
          value:(2) [0, "a"]
           __proto__: Object
*/
// iterator.next()返回一个对象，对于有元素的数组，
// 是next{ value: Array(2), done: false }；
// next.done 用于指示迭代器是否完成：在每次迭代时进行更新而且都是false，
// 直到迭代器结束done才是true。
// next.value是一个["key","value"]的数组，是返回的迭代器中的元素值。
```

**使用[for…of]() 循环**

```js
var arr = ["a", "b", "c"];
var iterator = arr.entries();
// undefined

for (let e of iterator) {
    console.log(e);
}

// [0, "a"] 
// [1, "b"] 
// [2, "c"]
```

内容好多，希望可以仔细看看🉑

-----

### 改变原始数组方法

#### splice

**定义：**

通过删除或替换现有元素或者原地添加新的元素来修改数组,并以数组形式返回被修改的内容，**注意此方法会改变原数组**

**语法:**

```js
array.splice(start,deleteCount,item1,.....,itemX)
```

**参数:**

```markdown
 start: 指定修改的开始位置（从0计数）
		1. 如果超出了数组的长度，则从数组末尾开始添加内容
		2. 如果是负值，则表示从数组末位开始的第几位（从-1计数，这意味着-n是倒数第n个元素，并且等价于array.length-n）
		3. 如果负数的绝对值大于数组的长度，则表示开始位置为第0位
deleteCount(可选) : 整数,表示要移除的数组元素个数	
		1. 如果 deleteCount 大于 start 之后的元素的总数，则从 start 后面的元素都将被			删除(含第 start 位)
		2. 如果 deleteCount 被省略了，或者它的值大于等于array.length - start(也就是		   说，如果它大于或者等于start之后的所有元素的数量)，那么start之后数组的所有元素都会被删除。
		3. 如果 deleteCount 是 0 或者负数，则不移除元素。这种情况下，至少应添加一个新		   元素。
item1, item2, ...(可选) 
要添加进数组的元素,从start 位置开始。如果不指定，则 splice() 将只删除数组元素。
```

**用法：**

```js
//从第 2 位开始删除 0 个元素，插入“drum”
var myFish = ["angel", "clown", "mandarin", "sturgeon"];
var removed = myFish.splice(2, 0, "drum");

// 运算后的 myFish: ["angel", "clown", "drum", "mandarin", "sturgeon"]
// 被删除的元素: [], 没有元素被删除
// 从第 2 位开始删除 0 个元素，插入“drum” 和 "guitar"
var removed2 = myFish.splice(2, 0, 'drum', 'guitar');
// 运算后的 myFish: ["angel", "clown", "drum", "guitar", "mandarin", "sturgeon"]
// 被删除的元素: [], 没有元素被删除
```

从第 2 位开始删除 1 个元素，插入“trumpet”

```js
var myFish = ['angel', 'clown', 'drum', 'sturgeon'];
var removed = myFish.splice(2, 1, "trumpet");

// 运算后的 myFish: ["angel", "clown", "trumpet", "sturgeon"]
// 被删除的元素: ["drum"]
```

---

> 以上是免费部分。完整内容需要「前端进阶之旅」会员，原文：https://feinterview.poetries.top/docs/fe-blog-docs/blog-docs/javascript/-V8%E6%BA%90%E7%A0%81%E6%B5%85%E6%9E%90JS%E6%95%B0%E7%BB%84%E5%B8%B8%E8%A7%81%E6%96%B9%E6%B3%95
