js 如何用slice获取数组的某一部分

slice 方法不会修改原数组，而是返回一个新数组。1. 它通过指定起始和结束索引（不包含结束）截取原数组的一部分，支持负数索引表示从末尾开始；2. 不传参数时可实现数组的浅拷贝，即复制基本类型值和引用类型的地址；3. 与 splice 的核心区别在于 slice 是非破坏性的，splice 会直接修改原数组；4. 常用于分页、限制显示数量、创建子数组独立操作以及与其他数组方法链式调用；5. 还可用于将类数组对象转换为数组，尽管 array.from() 更推荐。这些特性使 slice 在保持数据不变性和构建清晰数据处理流程中非常实用。

slice

方法是 JavaScript 数组的一个非常实用的工具，它能让你不改变原数组的前提下，轻松截取你需要的那一部分。简单来说，就是“切”出你想要的部分，原数组依然完整无缺。

解决方案

Array.prototype.slice()

方法返回一个从原数组中指定开始和结束位置（不包含结束位置）的浅拷贝。它不会修改原数组，这是它和

splice

最大的不同，也是我个人非常喜欢它的一个点。

它的基本语法是：

array.slice(startIndex, endIndex)

。

• startIndex

  ：可选。截取的起始索引（包含该索引的元素）。如果省略，默认为 0。如果是负数，则表示从数组末尾开始的偏移量。比如

  -1

  表示最后一个元素，

  -2

  表示倒数第二个。

• endIndex

  ：可选。截取的结束索引（不包含该索引的元素）。如果省略，则截取到数组末尾。如果是负数，同样表示从数组末尾开始的偏移量。

举几个例子可能更直观：

const originalArray = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];  // 1. 从索引 2 开始，到索引 5 结束（不包含索引 5） const part1 = originalArray.slice(2, 5); // 结果: [3, 4, 5] console.log('截取 [3, 4, 5]:', part1); console.log('原数组不变:', originalArray); // 结果: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]  // 2. 从索引 4 开始，一直到数组末尾 const part2 = originalArray.slice(4); // 结果: [5, 6, 7, 8, 9, 10] console.log('截取 [5, 6, 7, 8, 9, 10]:', part2);  // 3. 使用负数索引：从倒数第 3 个元素开始，到倒数第 1 个元素结束（不包含倒数第 1 个） const part3 = originalArray.slice(-3, -1); // 结果: [8, 9] console.log('截取 [8, 9]:', part3);  // 4. 只用一个负数索引：从倒数第 5 个元素开始，一直到数组末尾 const part4 = originalArray.slice(-5); // 结果: [6, 7, 8, 9, 10] console.log('截取 [6, 7, 8, 9, 10]:', part4);  // 5. 不传任何参数：实现数组的浅拷贝 const shallowCopy = originalArray.slice(); // 结果: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] console.log('浅拷贝:', shallowCopy);

深入理解：

slice

和

splice

方法的核心区别是什么？

在 JavaScript 数组操作中，

slice

和

splice

这两个方法名字太像了，一不小心就容易混淆。但它们的核心区别在于对原数组的影响：

slice

是非破坏性的，而

splice

是破坏性的。

• slice

  (切片)：正如我们上面讲的，它就像切面包一样，从原面包上切下一片，原面包还在，你拿到的是新切下来的那一片。它返回一个新的数组，包含你“切”出来的元素，原数组保持不变。这对于需要保持数据完整性，或者在不影响原始数据的情况下进行操作的场景非常重要。

• splice

  (拼接/剪接)：这个方法就比较“暴力”了，它直接在原数组上进行操作，可以删除、替换或添加元素。一旦你用了

  splice

  ，原数组可能就面目全非了。它返回一个包含被删除元素的数组（如果没有删除元素则返回空数组），但重点是，原数组被修改了。

来看个对比：

const arr1 = [1, 2, 3, 4, 5]; const arr2 = [1, 2, 3, 4, 5];  // 使用 slice const slicedArr = arr1.slice(1, 3); console.log('slice 后的新数组:', slicedArr); // [2, 3] console.log('slice 后的原数组:', arr1);     // [1, 2, 3, 4, 5] (不变)  // 使用 splice const splicedArr = arr2.splice(1, 3); // 从索引 1 开始删除 3 个元素 console.log('splice 返回的被删除元素:', splicedArr); // [2, 3, 4] console.log('splice 后的原数组:', arr2);     // [1, 5] (被修改了)

所以，当你只需要获取数组的一部分，且不希望改变原始数据时，毫不犹豫地选择

slice

。如果你需要修改原数组，比如删除或插入元素，那

splice

才是你的工具。

slice

如何实现数组的浅拷贝？在哪些场景下会用到？

slice

方法在不传入任何参数时，会返回原数组的一个浅拷贝。这意味着它会创建一个新数组，并将原数组的所有元素（如果元素是基本类型，则直接复制值；如果元素是引用类型，则复制引用地址）复制到新数组中。

const originalArr = [1, { name: 'Alice' }, [10, 20]]; const shallowCopyArr = originalArr.slice();  console.log(shallowCopyArr); // [1, { name: 'Alice' }, [10, 20]] console.log(originalArr === shallowCopyArr); // false (是不同的数组对象)  // 验证浅拷贝：修改基本类型不影响原数组 shallowCopyArr[0] = 99; console.log(originalArr[0]); // 1 (原数组未变)  // 验证浅拷贝：修改引用类型会影响原数组 shallowCopyArr[1].name = 'Bob'; console.log(originalArr[1].name); // Bob (原数组的引用对象被修改了)  shallowCopyArr[2][0] = 100; console.log(originalArr[2][0]); // 100 (原数组的引用对象被修改了)

使用场景：

1. 避免副作用：当你需要对一个数组进行操作（比如排序、过滤），但又不想影响到原始数据时，可以先用

   slice()

   创建一个副本，然后在副本上进行操作。这在函数式编程中非常常见，有助于保持数据的不可变性。

   const users = [{ id: 3, name: 'C' }, { id: 1, name: 'A' }, { id: 2, name: 'B' }]; const sortedUsers = users.slice().sort((a, b) => a.id - b.id); console.log('排序后的新数组:', sortedUsers); console.log('原数组 (未变):', users);
2. 转换类数组对象：在一些旧的浏览器环境或者特定场景下，你可能会遇到一些“类数组对象”（比如

   arguments

   对象，或者 DOM 的

   NodeList

   ），它们有

   length

   属性和索引访问，但没有数组的

   forEach

   、

   map

   等方法。这时候，

   slice.call()

   是一种很经典的转换方式。

   // 假设这是一个函数内部的 arguments 对象 function logArguments() {     // arguments 是一个类数组对象     // const argsArray = Array.prototype.slice.call(arguments); // 经典用法     const argsArray = Array.from(arguments); // ES6 更推荐的写法     console.log(argsArray);     console.log(Array.isArray(argsArray)); // true } logArguments('hello', 123, true); // 输出: ["hello", 123, true]

   虽然现在

   Array.from()

   可能是更简洁和推荐的做法，但了解

   slice.call()

   这种老牌用法也很有意思，能让你理解更多 JavaScript 的底层机制。

除了截取和浅拷贝，

slice

在实际项目中还有哪些巧妙的应用？

slice

作为一个看似简单的数组方法，在实际开发中其实有不少非常实用的“小技巧”和应用场景，远不止于简单的截取。

1. 实现分页逻辑：这是最常见的应用之一。当你从后端获取大量数据，需要在前端进行分页展示时，

   slice

   可以轻松地帮你取出当前页的数据。

   const allItems = Array.from({ length: 100 }, (_, i) => `Item ${i + 1}`); const pageSize = 10; const currentPage = 3; // 第三页  const startIndex = (currentPage - 1) * pageSize; const endIndex = startIndex + pageSize;  const itemsForCurrentPage = allItems.slice(startIndex, endIndex); console.log(`第 ${currentPage} 页的数据:`, itemsForCurrentPage); // 结果: ["Item 21", "Item 22", ..., "Item 30"]

   这种方式非常直观，而且性能也不错，因为它只是创建了一个小范围的新数组。

2. 截断数组以限制显示数量：在 UI 界面中，我们经常需要展示列表的一部分，比如“最新评论”只显示前 5 条，或者“热门标签”只显示前 10 个。

   const comments = ['评论1', '评论2', '评论3', '评论4', '评论5', '评论6']; const displayComments = comments.slice(0, 3); // 只显示前 3 条 console.log('显示评论:', displayComments); // ["评论1", "评论2", "评论3"]

   这比手动循环或者用

   for

   循环控制要简洁很多。

3. 创建子数组进行独立操作：有时候你需要对数组的某个特定部分进行一系列复杂操作，但又不希望这些操作影响到原数组的其他部分。你可以先

   slice

   出一个子数组，然后在子数组上随意折腾。

   const dataSet = [10, 20, 30, 40, 50, 60, 70]; // 假设我们只想处理中间的一部分数据 const middlePart = dataSet.slice(2, 5); // [30, 40, 50]  const processedMiddlePart = middlePart.map(num => num * 2).filter(num => num > 70); console.log('处理后的中间部分:', processedMiddlePart); // [80, 100] console.log('原数据集:', dataSet); // [10, 20, 30, 40, 50, 60, 70] (未变)

   这种模式有助于代码的模块化和清晰度，每个操作都在它自己的数据副本上进行，减少了潜在的副作用。

4. 结合其他数组方法进行链式操作：因为

   slice

   返回一个新数组，你可以很自然地将它与其他数组方法（如

   map

   ,

   filter

   ,

   reduce

   ,

   sort

   等）进行链式调用，构建出非常强大且可读性高的操作流。

   const products = [   { id: 1, name: 'Laptop', price: 1200 },   { id: 2, name: 'Mouse', price: 25 },   { id: 3, name: 'Keyboard', price: 75 },   { id: 4, name: 'Monitor', price: 300 },   { id: 5, name: 'Webcam', price: 50 } ];  // 获取价格在 50 到 300 之间（不含 300）的商品，并按价格从低到高排序，只取前 2 个 const filteredAndSortedTop2 = products   .filter(p => p.price >= 50 && p.price < 300) // 过滤出符合条件的   .sort((a, b) => a.price - b.price)         // 排序   .slice(0, 2);                               // 只取前 2 个  console.log('筛选排序后的前2个商品:', filteredAndSortedTop2); // 结果: [{ id: 5, name: 'Webcam', price: 50 }, { id: 3, name: 'Keyboard', price: 75 }]

   这种链式调用让数据处理逻辑变得非常流畅和富有表现力，是我在日常开发中经常会用到的模式。