Array.prototype.slice()

¥Syntax

slice()
slice(start)
slice(start, end)

¥Parameters

start Optional

开始提取的从零开始的索引，转换为整数。

• 负索引从数组末尾开始倒数 — 如果使用 -array.length <= start < 0、start + array.length。
• 如果省略 start < -array.length 或 start，则使用 0。
• 如果是 start >= array.length，则不会提取任何内容。

end Optional

结束提取的从零开始的索引，转换为整数。slice() 提取直至但不包括 end。

• 负索引从数组末尾开始倒数 — 如果使用 -array.length <= end < 0、end + array.length。
• 如果使用 end < -array.length、0。
• 如果省略 end >= array.length 或 end，则使用 array.length，导致提取直到末尾的所有元素。
• 如果 end 暗示的位置在 start 暗示的位置之前或处，则不会提取任何内容。

¥Return value

包含提取元素的新数组。

¥A new array containing the extracted elements.

¥Description

slice() 方法是 复印法 方法。它不会更改 this，而是返回 浅拷贝，其中包含一些与原始数组中的元素相同的元素。

¥The slice() method is a copying method. It does not alter this but instead returns a shallow copy that contains some of the same elements as the ones from the original array.

slice() 方法保留空槽。如果切片部分是 sparse，则返回的数组也是稀疏的。

¥The slice() method preserves empty slots. If the sliced portion is sparse, the returned array is sparse as well.

slice() 方法是 generic。它只期望 this 值具有 length 属性和整数键控属性。

¥The slice() method is generic. It only expects the this value to have a length property and integer-keyed properties.

¥Examples

¥Return a portion of an existing array

const fruits = ["Banana", "Orange", "Lemon", "Apple", "Mango"];
const citrus = fruits.slice(1, 3);

// fruits contains ['Banana', 'Orange', 'Lemon', 'Apple', 'Mango']
// citrus contains ['Orange','Lemon']

¥Using slice

在以下示例中，slice 从 myCar 创建一个新数组 newCar。两者都包含对对象 myHonda 的引用。当 myHonda 的颜色变为紫色时，两个数组都会反映该变化。

¥In the following example, slice creates a new array, newCar, from myCar. Both include a reference to the object myHonda. When the color of myHonda is changed to purple, both arrays reflect the change.

// Using slice, create newCar from myCar.
const myHonda = {
  color: "red",
  wheels: 4,
  engine: { cylinders: 4, size: 2.2 },
};
const myCar = [myHonda, 2, "cherry condition", "purchased 1997"];
const newCar = myCar.slice(0, 2);

console.log("myCar =", myCar);
console.log("newCar =", newCar);
console.log("myCar[0].color =", myCar[0].color);
console.log("newCar[0].color =", newCar[0].color);

// Change the color of myHonda.
myHonda.color = "purple";
console.log("The new color of my Honda is", myHonda.color);

console.log("myCar[0].color =", myCar[0].color);
console.log("newCar[0].color =", newCar[0].color);

这个脚本写道：

¥This script writes:

myCar = [
  { color: 'red', wheels: 4, engine: { cylinders: 4, size: 2.2 } },
  2,
  'cherry condition',
  'purchased 1997'
]
newCar = [ { color: 'red', wheels: 4, engine: { cylinders: 4, size: 2.2 } }, 2 ]
myCar[0].color = red
newCar[0].color = red
The new color of my Honda is purple
myCar[0].color = purple
newCar[0].color = purple

¥Calling slice() on non-array objects

slice() 方法读取 this 的 length 属性。然后，它读取从 start 到 end 的整数键属性，并在新创建的数组上定义它们。

¥The slice() method reads the length property of this. It then reads the integer-keyed properties from start to end and defines them on a newly created array.

const arrayLike = {
  length: 3,
  0: 2,
  1: 3,
  2: 4,
  3: 33, // ignored by slice() since length is 3
};
console.log(Array.prototype.slice.call(arrayLike, 1, 3));
// [ 3, 4 ]

¥Using slice() to convert array-like objects to arrays

slice() 方法通常与 bind() 和 call() 一起使用来创建将类似数组的对象转换为数组的实用方法。

¥The slice() method is often used with bind() and call() to create a utility method that converts an array-like object into an array.

// slice() is called with `this` passed as the first argument
const slice = Function.prototype.call.bind(Array.prototype.slice);

function list() {
  return slice(arguments);
}

const list1 = list(1, 2, 3); // [1, 2, 3]

¥Using slice() on sparse arrays

如果源是稀疏的，则从 slice() 返回的数组可能是稀疏的。

¥The array returned from slice() may be sparse if the source is sparse.

console.log([1, 2, , 4, 5].slice(1, 4)); // [2, empty, 4]

¥See also

• core-js 中 Array.prototype.slice 的 Polyfill
• 索引集合 指南
• Array
• Array.prototype.pop()
• Array.prototype.shift()
• Array.prototype.concat()
• Array.prototype.splice()
• TypedArray.prototype.slice()
• String.prototype.slice()