es-toolkit/compat 的 takeRight：从数组尾部安全截取元素的 Lodash 兼容实现

es-toolkit/compat 的 takeRight：从数组尾部安全截取元素的 Lodash 兼容实现

【免费下载链接】es-toolkitA modern JavaScript utility library that's 2-3 times faster and up to 97% smaller, a major upgrade to lodash.项目地址: https://gitcode.com/GitHub_Trending/es/es-toolkit

takeRight 是 es-toolkit 兼容层（es-toolkit/compat）中用于从数组末尾截取指定数量元素的函数，它 1:1 复刻了 Lodash_.takeRight的行为，包括对null、undefined、类数组对象以及 iteratee 调用场景的完整支持。本文以 docs/compat/reference/array/takeRight.md 为核心，结合 src/compat/array/takeRight.ts 的实现与 src/compat/array/takeRight.spec.ts 的测试用例，系统讲解该函数的用法、边界行为、底层原理，以及它与标准版es-toolkit/array中 takeRight 的差异与选型建议。

一、函数定位：Lodash 兼容层中的尾部截取工具

在 es-toolkit 中，takeRight存在两个版本：

• 标准版es-toolkit/array的 takeRight：仅接受普通数组，类型安全、性能更优，见 docs/reference/array/takeRight.md；
• 兼容版es-toolkit/compat的 takeRight：为迁移 Lodash 代码库而生，完整继承 Lodash 的接口与行为，包括隐式类型处理、null/undefined容忍和 iteratee 守卫参数。

根据 docs/compat/intro.md，es-toolkit/compat与 Lodash 的接口和行为 1:1 对齐，目的是让你在不改写调用点的前提下，把现有 Lodash 代码切换到 es-toolkit，再逐步迁移到严格 API。takeRight正是这种"零成本迁移"策略的典型代表：把import { takeRight } from 'lodash'换成import { takeRight } from 'es-toolkit/compat'即可，所有现有调用无需修改。

官方文档对兼容版 takeRight 给出了明确提醒：由于需要处理null或undefined输入，它比标准版运行得更慢；如果项目没有 Lodash 历史包袱，应直接使用标准版es-toolkit/array的 takeRight。

二、基本用法与返回值语义

兼容版 takeRight 的调用签名如下：

const result = takeRight(array, count);

它从数组末尾截取指定数量的元素并返回一个新数组，原始数组不会被修改。

常规截取

import { takeRight } from 'es-toolkit/compat'; // 从数字数组末尾取最后 2 个元素 takeRight([1, 2, 3, 4, 5], 2); // 返回: [4, 5] // 从字符串数组末尾取最后 2 个元素 takeRight(['a', 'b', 'c'], 2); // 返回: ['b', 'c']

边界行为

import { takeRight } from 'es-toolkit/compat'; // 请求数量大于数组长度时，返回整个数组 takeRight([1, 2, 3], 5); // 返回: [1, 2, 3] // 请求 0 个元素时，返回空数组 takeRight([1, 2, 3], 0); // 返回: [] // 请求负数时，返回空数组 takeRight([1, 2, 3], -1); // 返回: []

参数与返回值

count省略时只取最后一个元素：

import { takeRight } from 'es-toolkit/compat'; takeRight([1, 2, 3]); // 返回: [3]

三、null / undefined 与类数组输入的处理

与标准版不同，兼容版 takeRight 对null或undefined不做抛错处理，而是将其视为空数组：

import { takeRight } from 'es-toolkit/compat'; takeRight(null, 2); // [] takeRight(undefined, 2); // []

在 src/compat/array/takeRight.ts 的源码实现中，这一逻辑非常清晰：

export function takeRight<T>(arr: ArrayLike<T> | null | undefined, count = 1, guard?: unknown): T[] { count = guard ? 1 : toInteger(count); if (count <= 0 || !isArrayLike(arr)) { return []; } return takeRightToolkit(toArray(arr), count); }

这里有三层关键处理：

1. isArrayLike校验：借助 src/compat/predicate/isArrayLike.ts 判断输入是否为类数组（存在length属性且为合法数字）。null、undefined、数字、布尔值等都会在此被拦截，直接返回[]；
2. toInteger规范化：借助 src/compat/util/toInteger.ts 将传入的count转成整数，非数字输入也会被规范为可比较的值，从而保证count <= 0的边界判断可靠；
3. toArray归一化：通过 src/compat/_internal/toArray.ts 把类数组对象转为真正的数组：

export function toArray<T>(value: ArrayLike<T>): T[] { return Array.isArray(value) ? value : Array.from(value); }

因此，兼容版 takeRight 也完整支持类数组输入。测试用例 src/compat/array/takeRight.spec.ts 验证了三种典型场景：

// 类数组对象 takeRight({ 0: 1, 1: 2, 2: 3, length: 3 }, 2); // [2, 3] // 字符串 takeRight('123', 2); // ['2', '3'] // arguments 对象 takeRight(args, 2); // [2, 3]

四、底层原理：委托标准实现与 slice(-count)

兼容版 takeRight 的最后一个环节是把归一化后的数组委托给标准实现处理：

return takeRightToolkit(toArray(arr), count);

这里的takeRightToolkit来自 src/array/takeRight.ts，其核心实现只有短短几行：

export function takeRight<T>(arr: readonly T[], count: number): T[] { if (count <= 0 || arr.length === 0) { return []; } return arr.slice(-count); }

这解释了文档中的全部边界语义：

• count > arr.length返回整个数组：slice(-count)中当-count小于数组负索引范围时，slice会从索引 0 开始截取；
• count <= 0返回空数组：slice(-0)等价于slice(0)会返回全部元素，所以标准实现先用count <= 0的提前判断兜底，这也正是兼容版在调用标准实现前先用toInteger规范化并拦截非正数的原因；
• 返回新数组：slice天然返回新数组，不修改原数组。

从源码结构可以推断，标准版因为不需要isArrayLike、toInteger、toArray这些兼容性前置处理，调用链更短，这正是官方文档提示"兼容版更慢、标准版更快"的实现层面的原因。

五、iteratee 守卫参数：作为 map 回调直接使用

兼容版 takeRight 的第三个参数guard是一个容易被忽略但极具 Lodash 特色的设计：

count = guard ? 1 : toInteger(count);

当takeRight被作为map等方法的回调直接传递时，map会传入(value, index, array)三个参数，其中index会被误当作count。guard参数的存在让函数能够识别这种调用方式，强制将count重置为默认值1。

测试用例 src/compat/array/takeRight.spec.ts 验证了这一行为：

const array = [ [1, 2, 3], [4, 5, 6], [7, 8, 9], ]; const actual = array.map(item => takeRight(item)); // 输出: [[3], [6], [9]]

更贴近 Lodash 习惯的写法是直接传入函数引用：

[[1, 2], [3, 4], [5]].map(takeRight); // 输出: [[2], [4], [5]]

如果没有guard机制，map传入的第二个参数（索引0, 1, 2）会被当作count，结果将完全错误。这是兼容层"1:1 复刻 Lodash 行为"的典型细节。

六、全面行为矩阵（测试用例汇总）

综合 src/compat/array/takeRight.spec.ts 的全部用例，兼容版 takeRight 的行为可以归纳为如下矩阵：

这些用例直接移植自 Lodash 官方的takeRight测试（源码注释中标注了出处），是"100% 兼容 Lodash"承诺的实证。

七、与标准版 takeRight 的对比与选型建议

八、导入方式与迁移实践

takeRight既可以从聚合入口导入，也可以按需独立导入：

// 聚合入口（与 lodash 的写法一一对应） import { takeRight } from 'es-toolkit/compat'; // 按需独立入口（只加载该函数依赖的模块） import takeRight from 'es-toolkit/compat/takeRight';

按 docs/compat/intro.md 的说明，独立入口在无法进行 tree-shaking 的环境中（如 CommonJS 的require()、React Native、直接在 Node.js 上运行且无打包器的场景）尤其有用：

const takeRight = require('es-toolkit/compat/takeRight');

在源码层面，takeRight通过 src/compat/compat.ts 对外导出，并同样包含在 src/compat/index.ts 的聚合导出中。迁移路径建议为：先从lodash/lodash-es切换到es-toolkit/compat（调用点保持不变），随后逐步清理调用点、切换到es-toolkit/array的标准版，最终获得更小的包体积和更快的运行速度。

九、相关函数扩展

如果你需要的是"从末尾持续截取直到某个条件不再满足"，可以进一步了解与 takeRight 配套的 takeRightWhile（实现见 src/compat/array/takeRightWhile.ts）。它接受谓词函数，并从尾部开始截取满足条件的连续元素：

import { takeRightWhile } from 'es-toolkit/compat'; takeRightWhile([1, 2, 3, 4, 5], (item) => item > 3); // 返回: [4, 5]

与 takeRight 相同，takeRightWhile 也支持null/undefined（返回空数组）、类数组对象，以及 Lodash 风格的谓词简写（部分对象匹配、键值对、属性键）。其实现借助findLastIndex定位第一个不满足条件的元素位置，再对剩余部分切片，与 takeRight 共享isArrayLike、toArray等内部工具，两者配合可以覆盖绝大多数"从尾部取元素"的实战需求。

【免费下载链接】es-toolkitA modern JavaScript utility library that's 2-3 times faster and up to 97% smaller, a major upgrade to lodash.项目地址: https://gitcode.com/GitHub_Trending/es/es-toolkit