slice 方法不会修改原数组，而是返回一个新数组。1. 它通过指定起始和结束索引（不包含结束）截取原数组的一部分，支持负数索引表示从末尾开始；2. 不传参数时可实现数组的浅拷贝，即复制基本类型值和引用类型的地址；3. 与 splice 的核心区别在于 slice 是非破坏性的，splice 会直接修改原数组；4. 常用于分页、限制显示数量、创建子数组独立操作以及与其他数组方法链式调用；5. 还可用于将类数组对象转换为数组，尽管 array.from() 更推荐。这些特性使 slice 在保持数据不变性和构建清晰数据处理流程中非常实用。
slice
Array.prototype.slice()
splice
它的基本语法是：
array.slice(startIndex, endIndex)
startIndex
-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 (原数组的引用对象被修改了)使用场景：
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);arguments
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()
slice
slice
实现分页逻辑：这是最常见的应用之一。当你从后端获取大量数据，需要在前端进行分页展示时，
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"]这种方式非常直观，而且性能也不错，因为它只是创建了一个小范围的新数组。
截断数组以限制显示数量：在 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
创建子数组进行独立操作：有时候你需要对数组的某个特定部分进行一系列复杂操作，但又不希望这些操作影响到原数组的其他部分。你可以先
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] (未变)这种模式有助于代码的模块化和清晰度，每个操作都在它自己的数据副本上进行，减少了潜在的副作用。
结合其他数组方法进行链式操作：因为
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 }]这种链式调用让数据处理逻辑变得非常流畅和富有表现力，是我在日常开发中经常会用到的模式。
以上就是js 如何用slice获取数组的某一部分的详细内容，更多请关注php中文网其它相关文章！
每个人都需要一台速度更快、更稳定的 PC。随着时间的推移，垃圾文件、旧注册表数据和不必要的后台进程会占用资源并降低性能。幸运的是，许多工具可以让 Windows 保持平稳运行。
Copyright 2014-2025 //m.sbmmt.com/ All Rights Reserved | php.cn | 湘ICP备2023035733号
469
收藏
