docs: Translate Simplified Chinese (#165)

* Translate Simplified Chinese * Supplement the omitted * Supplement the omitted * Supplement the omitted * Supplement the omitted * Supplement the omitted * Supplement the omitted * Supplement the omitted * Supplement the omitted * Supplement the omitted * Update docs/.vitepress/shared.mts --------- Co-authored-by: Sojin Park <raon0211@gmail.com>
2024-11-24 03:32:58 +03:00 · 2024-07-12 09:08:55 +08:00 · 2024-07-12 09:08:55 +08:00 · e9ede74362
commit e9ede74362
parent 16d326c4b2
83 changed files with 2790 additions and 2 deletions
--- a/README-ko_kr.md
+++ b/README-ko_kr.md
@ -2,7 +2,7 @@

 # es-toolkit &middot; [![MIT License](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/toss/slash/blob/main/LICENSE) [![codecov](https://codecov.io/gh/toss/es-toolkit/graph/badge.svg?token=8N5S3AR3C7)](https://codecov.io/gh/toss/es-toolkit)

-[English](https://github.com/toss/es-toolkit/blob/main/README.md) | 한국어
+[English](https://github.com/toss/es-toolkit/blob/main/README.md) | 한국어 | [简体中文](https://github.com/toss/es-toolkit/blob/main/README-zh_hans.md)

 es-toolkit은 높은 성능과 작은 번들 사이즈, 강력한 타입을 자랑하는 현대적인 JavaScript 유틸리티 라이브러리예요.

--- a/README-zh_hans.md
+++ b/README-zh_hans.md
@ -0,0 +1,50 @@
+![](./docs/public/og.png)
+
+# es-toolkit &middot; [![MIT License](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/toss/slash/blob/main/LICENSE) [![codecov](https://codecov.io/gh/toss/es-toolkit/graph/badge.svg?token=8N5S3AR3C7)](https://codecov.io/gh/toss/es-toolkit) [![NPM badge](https://img.shields.io/npm/v/es-toolkit?logo=npm)](https://www.npmjs.com/package/es-toolkit) [![JSR badge](https://jsr.io/badges/@es-toolkit/es-toolkit)](https://jsr.io/@es-toolkit/es-toolkit)
+
+[English](https://github.com/toss/es-toolkit/blob/main/README.md) | [한국어](https://github.com/toss/es-toolkit/blob/main/README-ko_kr.md) | 简体中文
+
+es-toolkit 是一个先进的、高性能的 JavaScript 实用工具库，具有小的捆绑包大小和强大的类型注解。
+
+- es-toolkit 提供多种现代实现的日常实用函数，如 [debounce](https://es-toolkit.slash.page/reference/function/debounce.html)、[delay](https://es-toolkit.slash.page/reference/promise/delay.html)、[chunk](https://es-toolkit.slash.page/reference/array/chunk.html)、[sum](https://es-toolkit.slash.page/reference/math/sum.html) 和 [pick](https://es-toolkit.slash.page/reference/object/pick.html)。
+- 设计时考虑了性能，es-toolkit 在现代 JavaScript 环境中实现了 [2-3 倍的性能提升](https://es-toolkit.slash.page/zh_hans/performance.html)。
+- es-toolkit 支持开箱即用，并且与其他库相比，可以将 JavaScript 代码减少高达 [97%](https://es-toolkit.slash.page/zh_hans/bundle-size.html)。
+- es-toolkit 包含内置的 TypeScript 支持，提供直观且强大的类型。它还提供诸如 [isNotNil](https://es-toolkit.slash.page/zh_hans/reference/predicate/isNotNil.html) 等有用的类型保护。
+- es-toolkit 经过了百分之百的测试覆盖率的实战检验，确保其可靠性和稳健性。
+
+## 示例
+
+```tsx
+// import from '@es-toolkit/es-toolkit' in jsr.
+import { debounce, chunk } from 'es-toolkit';
+
+const debouncedLog = debounce(message => {
+  console.log(message);
+}, 300);
+
+// 这个调用将会被防抖处理
+debouncedLog('Hello, world!');
+
+const array = [1, 2, 3, 4, 5, 6];
+const chunkedArray = chunk(array, 2);
+
+console.log(chunkedArray);
+// 输出: [[1, 2], [3, 4], [5, 6]]
+```
+
+## 贡献
+
+我们欢迎社区中的每个人贡献。请阅读下面的详细贡献指南。
+
+[CONTRIBUTING](https://github.com/toss/es-toolkit/blob/main/.github/CONTRIBUTING.md)
+
+## 许可证
+
+MIT © Viva Republica, Inc. 详细信息请参阅 [LICENSE](./LICENSE)。
+
+<a title="Toss" href="https://toss.im">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="https://static.toss.im/logos/png/4x/logo-toss-reverse.png">
+    <img alt="Toss" src="https://static.toss.im/logos/png/4x/logo-toss.png" width="100">
+  </picture>
+</a>
--- a/README.md
+++ b/README.md
@ -2,7 +2,7 @@

 # es-toolkit &middot; [![MIT License](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/toss/slash/blob/main/LICENSE) [![codecov](https://codecov.io/gh/toss/es-toolkit/graph/badge.svg?token=8N5S3AR3C7)](https://codecov.io/gh/toss/es-toolkit) [![NPM badge](https://img.shields.io/npm/v/es-toolkit?logo=npm)](https://www.npmjs.com/package/es-toolkit) [![JSR badge](https://jsr.io/badges/@es-toolkit/es-toolkit)](https://jsr.io/@es-toolkit/es-toolkit)

-English | [한국어](https://github.com/toss/es-toolkit/blob/main/README-ko_kr.md)
+English | [한국어](https://github.com/toss/es-toolkit/blob/main/README-ko_kr.md) | [简体中文](https://github.com/toss/es-toolkit/blob/main/README-zh_hans.md)

 es-toolkit is a state-of-the-art, high-performance JavaScript utility library with a small bundle size and strong type annotations.

--- a/docs/.vitepress/config.mts
+++ b/docs/.vitepress/config.mts
@ -1,6 +1,7 @@
 import { defineConfig } from 'vitepress';
 import { en } from './en.mts';
 import { ko } from './ko.mts';
+import { zh_hans } from './zh_hans.mts';
 import { shared } from './shared.mts';

 export default defineConfig({
@ -8,5 +9,6 @@ export default defineConfig({
  locales: {
    root: { label: 'English', ...en },
    ko: { label: '한국어', ...ko },
+    zh_hans: { label: '简体中文', ...zh_hans },
  },
 });
--- a/docs/.vitepress/shared.mts
+++ b/docs/.vitepress/shared.mts
@ -2,6 +2,7 @@ import { createRequire } from 'module';
 import path from 'path';
 import { defineConfig } from 'vitepress';
 import { search as koSearch } from './ko.mts';
+import { search as zh_hansSearch } from './zh_hans.mts';

 const require = createRequire(import.meta.url);

@ -58,6 +59,7 @@ export const shared = defineConfig({
      options: {
        locales: {
          ...koSearch,
+          ...zh_hansSearch,
        },
      },
    },
--- a/docs/.vitepress/zh_hans.mts
+++ b/docs/.vitepress/zh_hans.mts
@ -0,0 +1,179 @@
+import { defineConfig, type DefaultTheme } from 'vitepress';
+
+export const zh_hans = defineConfig({
+  lang: 'zh_hans',
+  description:
+    '一款先进的高性能 JavaScript 实用库，具有小巧的包体积和强大的类型注解。',
+
+  themeConfig: {
+    nav: nav(),
+
+    sidebar: sidebar(),
+
+    editLink: {
+      pattern: 'https://github.com/toss/es-toolkit/edit/main/docs/:path',
+      text: '在 GitHub 上编辑此页面',
+    },
+
+    footer: {
+      message: '采用 MIT 许可证发布。',
+      copyright: `Copyright © ${new Date().getFullYear()} Viva Republica, Inc.`,
+    },
+  },
+});
+
+function nav(): DefaultTheme.NavItem[] {
+  return [
+    { text: '主页', link: '/zh_hans/' },
+    { text: '简介', link: '/zh_hans/intro' },
+    { text: '参考', link: '/zh_hans/reference/array/chunk' },
+  ];
+}
+
+function sidebar(): DefaultTheme.Sidebar {
+  return [
+    {
+      text: '指南',
+      items: [
+        { text: '简介', link: '/zh_hans/intro' },
+        { text: '安装', link: '/zh_hans/installation' },
+        { text: '包体积影响', link: '/zh_hans/bundle-size' },
+        { text: '性能', link: '/zh_hans/performance' },
+      ],
+    },
+    {
+      text: '参考',
+      items: [
+        {
+          text: '数组工具',
+          items: [
+            { text: 'chunk', link: '/zh_hans/reference/array/chunk' },
+            { text: 'countBy', link: '/zh_hans/reference/array/countBy' },
+            { text: 'compact', link: '/zh_hans/reference/array/compact' },
+            { text: 'difference', link: '/zh_hans/reference/array/difference' },
+            { text: 'differenceBy', link: '/zh_hans/reference/array/differenceBy' },
+            { text: 'differenceWith', link: '/zh_hans/reference/array/differenceWith' },
+            { text: 'drop', link: '/zh_hans/reference/array/drop' },
+            { text: 'dropWhile', link: '/zh_hans/reference/array/dropWhile' },
+            { text: 'dropRight', link: '/zh_hans/reference/array/dropRight' },
+            { text: 'dropRightWhile', link: '/zh_hans/reference/array/dropRightWhile' },
+            { text: 'fill', link: '/zh_hans/reference/array/fill' },
+            { text: 'toFilled', link: '/zh_hans/reference/array/toFilled' },
+            { text: 'flatten', link: '/zh_hans/reference/array/flatten' },
+            { text: 'forEachRight', link: '/zh_hans/reference/array/forEachRight' },
+            { text: 'groupBy', link: '/zh_hans/reference/array/groupBy' },
+            { text: 'intersection', link: '/zh_hans/reference/array/intersection' },
+            { text: 'intersectionBy', link: '/zh_hans/reference/array/intersectionBy' },
+            { text: 'intersectionWith', link: '/zh_hans/reference/array/intersectionWith' },
+            { text: 'keyBy', link: '/zh_hans/reference/array/keyBy' },
+            { text: 'minBy', link: '/zh_hans/reference/array/minBy' },
+            { text: 'maxBy', link: '/zh_hans/reference/array/maxBy' },
+            { text: 'orderBy', link: '/zh_hans/reference/array/orderBy' },
+            { text: 'partition', link: '/zh_hans/reference/array/partition' },
+            { text: 'sample', link: '/zh_hans/reference/array/sample' },
+            { text: 'sampleSize', link: '/zh_hans/reference/array/sampleSize' },
+            { text: 'shuffle', link: '/zh_hans/reference/array/shuffle' },
+            { text: 'take', link: '/zh_hans/reference/array/take' },
+            { text: 'takeWhile', link: '/zh_hans/reference/array/takeWhile' },
+            { text: 'takeRight', link: '/zh_hans/reference/array/takeRight' },
+            { text: 'takeRightWhile', link: '/zh_hans/reference/array/takeRightWhile' },
+            { text: 'union', link: '/zh_hans/reference/array/union' },
+            { text: 'unionBy', link: '/zh_hans/reference/array/unionBy' },
+            { text: 'unionWith', link: '/zh_hans/reference/array/unionWith' },
+            { text: 'uniq', link: '/zh_hans/reference/array/uniq' },
+            { text: 'uniqBy', link: '/zh_hans/reference/array/uniqBy' },
+            { text: 'uniqWith', link: '/zh_hans/reference/array/uniqWith' },
+            { text: 'unzip', link: '/zh_hans/reference/array/unzip' },
+            { text: 'unzipWith', link: '/zh_hans/reference/array/unzipWith' },
+            { text: 'without', link: '/zh_hans/reference/array/without' },
+            { text: 'xor', link: '/zh_hans/reference/array/xor' },
+            { text: 'xorBy', link: '/zh_hans/reference/array/xorBy' },
+            { text: 'xorWith', link: '/zh_hans/reference/array/xorWith' },
+            { text: 'zip', link: '/zh_hans/reference/array/zip' },
+            { text: 'zipObject', link: '/zh_hans/reference/array/zipObject' },
+            { text: 'zipWith', link: '/zh_hans/reference/array/zipWith' },
+            { text: 'head', link: '/zh_hans/reference/array/head' },
+            { text: 'tail', link: '/zh_hans/reference/array/tail' },
+            { text: 'last', link: '/zh_hans/reference/array/last' },
+          ],
+        },
+        {
+          text: '函数工具',
+          items: [
+            { text: 'debounce', link: '/zh_hans/reference/function/debounce' },
+            { text: 'throttle', link: '/zh_hans/reference/function/throttle' },
+            { text: 'once', link: '/zh_hans/reference/function/once' },
+            { text: 'noop', link: '/zh_hans/reference/function/noop' },
+          ],
+        },
+        {
+          text: '数学工具',
+          items: [
+            { text: 'clamp', link: '/zh_hans/reference/math/clamp' },
+            { text: 'inRange', link: '/zh_hans/reference/math/inRange' },
+            { text: 'mean', link: '/zh_hans/reference/math/mean' },
+            { text: 'meanBy', link: '/zh_hans/reference/math/meanBy' },
+            { text: 'random', link: '/zh_hans/reference/math/random' },
+            { text: 'randomInt', link: '/zh_hans/reference/math/randomInt' },
+            { text: 'range', link: '/zh_hans/reference/math/range' },
+            { text: 'round', link: '/zh_hans/reference/math/round' },
+            { text: 'sum', link: '/zh_hans/reference/math/sum' },
+          ],
+        },
+        {
+          text: '对象工具',
+          items: [
+            { text: 'omit', link: '/zh_hans/reference/object/omit' },
+            { text: 'omitBy', link: '/zh_hans/reference/object/omitBy' },
+            { text: 'pick', link: '/zh_hans/reference/object/pick' },
+            { text: 'pickBy', link: '/zh_hans/reference/object/pickBy' },
+            { text: 'invert', link: '/zh_hans/reference/object/invert' },
+          ],
+        },
+        {
+          text: '谓词',
+          items: [
+            { text: 'isNil', link: '/zh_hans/reference/predicate/isNil' },
+            { text: 'isNotNil', link: '/zh_hans/reference/predicate/isNotNil' },
+            { text: 'isNull', link: '/zh_hans/reference/predicate/isNull' },
+            { text: 'isUndefined', link: '/zh_hans/reference/predicate/isUndefined' },
+          ],
+        },
+        {
+          text: 'Promise 工具',
+          items: [{ text: 'delay', link: '/zh_hans/reference/promise/delay' }],
+        },
+        {
+          text: '字符串工具',
+          items: [{ text: 'snakeCase', link: '/zh_hans/reference/string/snakeCase' }],
+        },
+      ],
+    },
+  ];
+}
+
+export const search: DefaultTheme.LocalSearchOptions['locales'] = {
+  zh_hans: {
+    translations: {
+      button: {
+        buttonText: '搜索',
+        buttonAriaLabel: '搜索',
+      },
+      modal: {
+        backButtonTitle: '返回',
+        displayDetails: '显示详情',
+        footer: {
+          closeKeyAriaLabel: '关闭',
+          closeText: '关闭',
+          navigateDownKeyAriaLabel: '向下导航',
+          navigateText: '导航',
+          navigateUpKeyAriaLabel: '向上导航',
+          selectKeyAriaLabel: '选择',
+          selectText: '选择',
+        },
+        noResultsText: '未找到搜索结果。',
+        resetButtonTitle: '重置',
+      },
+    },
+  },
+};
--- a/docs/zh_hans/bundle-size.md
+++ b/docs/zh_hans/bundle-size.md
@ -0,0 +1,23 @@
+---
+description: es-toolkit提供的最小包体积
+---
+
+# 包体积
+
+![图表显示es-toolkit与lodash之间包大小的差异，差异高达97%。](/assets/bundle-size.png)
+
+通过其现代化的实现，es-toolkit显著减少了其包体积，与lodash等其他库相比，可以减少高达97%。
+
+这使得es-toolkit在包体积方面成为最高效的选择，其中一些实用函数的体积甚至少于100字节。
+
+## 包体积比较
+
+|                                            | es-toolkit@0.0.1 | lodash-es@4.17.21 | Difference |
+| ------------------------------------------ | ---------------- | ----------------- | ---------- |
+| [sample](./reference/array/sample)         | 88 bytes         | 2000 bytes        | -95.6%     |
+| [difference](./reference/array/difference) | 91 bytes         | 3190 bytes        | -97.2%     |
+| [sum](./reference/math/sum)                | 152 bytes        | 413 bytes         | -63.2%     |
+| [debounce](./reference/function/debounce)  | 144 bytes        | 1400 bytes        | -89.7%     |
+| [throttle](./reference/function/throttle)  | 110 bytes        | 1460 bytes        | -92.5%     |
+| [pick](./reference/object/pick)            | 657 bytes        | 3860 bytes        | -83.0%     |
+| [zip](./reference/array/zip)               | 797 bytes        | 1790 bytes        | -55.5%     |
--- a/docs/zh_hans/index.md
+++ b/docs/zh_hans/index.md
@ -0,0 +1,33 @@
+---
+# https://vitepress.dev/reference/default-theme-home-page
+layout: home
+
+hero:
+  name: 'es-toolkit'
+  text: '最先进的JavaScript工具库'
+  # tagline:
+  actions:
+    - theme: brand
+      text: 关于 es-toolkit
+      link: /zh_hans/intro
+    - theme: alt
+      text: 参考文档
+      link: /zh_hans/reference/array/chunk
+    - theme: alt
+      text: 安装指南
+      link: /zh_hans/installation
+
+features:
+  - title: 最佳性能
+    details: es-toolkit在现代JavaScript运行时中的性能比其他库提高了2-3倍。
+  - title: 小型包体积
+    details: 与其他替代库相比，es-toolkit的JavaScript代码体积最多减少了97%。
+  - title: 现代化实现
+    details: es-toolkit充分利用现代JavaScript API进行简单且无错误的实现。
+  - title: 强大的类型支持
+    details: es-toolkit为所有函数提供简单而强大的类型支持。
+  - title: 经过实战验证
+    details: es-toolkit具有100%的测试覆盖率，确保最大的健壮性。
+  - title: 全面的运行时支持
+    details: es-toolkit支持包括Node.js、Deno、Bun和浏览器在内的所有JavaScript环境。
+---
--- a/docs/zh_hans/installation.md
+++ b/docs/zh_hans/installation.md
@ -0,0 +1,57 @@
+---
+description: 如何安装 es-toolkit
+prev:
+  text: es-toolkit 简介
+  link: ./intro.md
+next:
+  text: 包体积对比
+  link: ./bundle-size
+---
+
+# 安装
+
+es-toolkit 可通过 [npm](https://npmjs.com/package/es-toolkit) 安装，适用于 Node.js 和 Bun，也可以通过 [JSR](https://jsr.io/@es-toolkit/es-toolkit) 安装到 Deno。
+
+## Node.js
+
+es-toolkit 支持 Node.js 18及更高版本。使用以下命令安装 es-toolkit：
+
+::: code-group
+
+```sh [npm]
+npm install es-toolkit
+```
+
+```sh [pnpm]
+pnpm install es-toolkit
+```
+
+```sh [yarn]
+yarn add es-toolkit
+```
+
+:::
+
+## Deno
+
+es-toolkit 也可以通过 [JSR](https://jsr.io/@es-toolkit/es-toolkit) 安装到 Deno。使用以下命令安装 es-toolkit：
+
+```sh
+deno add @es-toolkit/es-toolkit
+```
+
+请注意，根据 JSR 的限制，包名包含额外的作用域，与 npm 不同。
+
+```typescript
+import { sum } from '@es-toolkit/es-toolkit';
+
+sum([1, 2, 3]);
+```
+
+## Bun
+
+es-toolkit 也支持 Bun。您可以使用以下命令安装它：
+
+```sh
+bun add es-toolkit
+```
--- a/docs/zh_hans/intro.md
+++ b/docs/zh_hans/intro.md
@ -0,0 +1,25 @@
+# 关于 es-toolkit
+
+es-toolkit 是一个现代的 JavaScript 实用库，提供了一系列强大的函数，适用于日常使用。
+
+与 lodash 等替代品相比，es-toolkit 提供了 [显著更小的包体积](./bundle-size.md)（最多减少97%）和 [2-3倍更快的运行时性能](./performance.md)。这是通过利用最新的 JavaScript 特性实现的。
+
+es-toolkit 内置 TypeScript 类型，并经过严格测试，确保了100%的测试覆盖率，以保证最大的可靠性。
+
+## 功能特点
+
+以下是 es-toolkit 提供的一些功能特点：
+
+- **Array**: 数组操作工具，如 [uniq](./reference/array/uniq.md) 和 [difference](./reference/array/difference.md)。
+- **Function**: 控制函数执行的工具，包括 [debounce](./reference/function/debounce.md) 和 [throttle](./reference/function/throttle.md)。
+- **Math**: 数值操作工具，如 [sum](./reference/math/sum.md) 和 [round](./reference/math/round.md)。
+- **Object**: 操作 JavaScript 对象的工具，如 [pick](./reference/object/pick.md) 和 [omit](./reference/object/omit.md)。
+- **Predicate**: 类型保护函数，如 [isNotNil](./reference/predicate/isNotNil.md)。
+- **Promise**: 异步操作工具，如 [delay](./reference/promise/delay.md)。
+- **String**: 字符串操作工具，如 [snakeCase](./reference/string/snakeCase.md)。
+
+## 链接
+
+请参考以下链接获取有关该项目的更多信息。
+
+- [GitHub](https://github.com/toss/es-toolkit)
--- a/docs/zh_hans/performance.md
+++ b/docs/zh_hans/performance.md
@ -0,0 +1,26 @@
+---
+description: es-toolkit与替代库之间的性能差异
+---
+
+# 性能
+
+![图表显示es-toolkit与lodash之间性能差异。使用es-toolkit可获得高达11倍的性能提升。](/assets/performance.png)
+
+es-toolkit 设计时考虑了性能，与类似 lodash 的替代库相比，平均性能提升了2倍。通过充分利用现代 JavaScript API，部分函数甚至可以获得高达11倍的性能提升。
+
+## 性能比较
+
+|                                                           | es-toolkit@0.0.1 | lodash-es@4.17.21 | Difference |
+| --------------------------------------------------------- | ---------------- | ----------------- | ---------- |
+| [omit](./reference/object/omit.md)                        | 4,767,360 times  | 403,624 times     | 11.8×      |
+| [pick](./reference/object/pick.md)                        | 9,121,839 times  | 2,663,072 times   | 3.43×      |
+| [differenceWith](./reference/array/differenceWith.md)     | 9,291,897 times  | 4,275,222 times   | 2.17×      |
+| [difference](./reference/array/difference.md)             | 10,436,101 times | 5,155,631 times   | 2.02×      |
+| [intersectionWith](./reference/array/intersectionWith.md) | 8,074,722 times  | 3,814,479 times   | 2.12×      |
+| [intersection](./reference/array/intersection.md)         | 9,999,571 times  | 4,630,316 times   | 2.15×      |
+| [unionBy](./reference/array/unionBy.md)                   | 6,435,983 times  | 3,794,899 times   | 1.69×      |
+| [union](./reference/array/union.md)                       | 5,059,209 times  | 4,771,400 times   | 1.06×      |
+| [dropRightWhile](./reference/array/dropRightWhile.md)     | 7,529,559 times  | 5,606,439 times   | 1.34×      |
+| [groupBy](./reference/array/groupBy.md)                   | 5,000,235 times  | 5,206,286 times   | 0.96×      |
+
+在 MacBook Pro 14-inch (M1 Max, 2021) 上进行了测试。请参考我们的 [基准测试代码](https://github.com/toss/es-toolkit/tree/main/benchmarks)。
--- a/docs/zh_hans/reference/array/chunk.md
+++ b/docs/zh_hans/reference/array/chunk.md
@ -0,0 +1,39 @@
+# chunk
+
+将一个数组分割成指定长度的多个子数组。
+
+该函数接受一个输入数组，并将其分割成多个指定长度的子数组。
+
+如果输入数组无法均匀分割，则最后一个子数组将包含剩余的元素。
+
+## 签名
+
+```typescript
+function chunk<T>(arr: T[], size: number): T[][];
+```
+
+### 参数
+
+- `arr` (`T[]`): 要分割成小数组的数组。
+- `size` (`number`): 每个小数组的长度。必须是正整数。
+
+### 返回值
+
+(`T[][]`) 一个二维数组，其中每个子数组的最大长度为 `size`。
+
+### 抛出异常
+
+如果 `size` 不是正整数，则抛出错误。
+
+## 示例
+
+```typescript
+import { chunk } from 'es-toolkit/array';
+
+// 将一组数字分割成长度为2的子数组
+chunk([1, 2, 3, 4, 5], 2);
+// 返回: [[1, 2], [3, 4], [5]]
+
+// 将一组字符串分割成长度为3的子数组
+chunk(['a', 'b', 'c', 'd', 'e', 'f', 'g'], 3);
+// 返回: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g']]
--- a/docs/zh_hans/reference/array/compact.md
+++ b/docs/zh_hans/reference/array/compact.md
@ -0,0 +1,23 @@
+# compact
+
+从数组中删除假值（`false`、`null`、`0`、`''`、`undefined`、`NaN`）。
+
+## 签名
+
+```typescript
+function compact<T>(arr: T[]): Array<Exclude<T, false | null | 0 | '' | undefined>>;
+```
+
+### 参数
+
+- `arr` (`T[]`): 要移除假值的输入数组。
+
+### 返回值
+
+(`Array<Exclude<T, false | null | 0 | '' | undefined>>`) 移除所有假值后的新数组。
+
+## 示例
+
+```typescript
+compact([0, 1, false, 2, '', 3, null, undefined, 4, NaN, 5]);
+// 返回: [1, 2, 3, 4, 5]
--- a/docs/zh_hans/reference/array/countBy.md
+++ b/docs/zh_hans/reference/array/countBy.md
@ -0,0 +1,30 @@
+# countBy
+
+ 根据 `mapper` 函数统计数组中每个项目的出现次数。
+
+## 签名
+
+```typescript
+function countBy<T>(arr: T[], mapper: (item: T) => string): Record<string, number>
+```
+
+### 参数
+
+- `arr` (`T[]`): 输入数组，用于统计每个项目的出现次数。
+- `mapper` (`(item: T) => string`): 将每个项目映射到字符串键的转换函数。
+
+### 返回值
+
+(`Record<string, number>`) 包含基于转换函数的每个项目计数的对象。
+
+## 示例
+
+```javascript
+import { countBy } from 'es-toolkit/array';
+
+const array = [1, 2, 3, 4, 5, 6];
+const result = countBy(array, x => x % 2 === 0 ? 'even' : 'odd');
+
+console.log(result);
+// 输出: { 'odd': 3, 'even': 3 }
+```
--- a/docs/zh_hans/reference/array/difference.md
+++ b/docs/zh_hans/reference/array/difference.md
@ -0,0 +1,33 @@
+# difference
+
+计算两个数组之间的差异。
+
+该函数接受两个数组，并返回一个新数组，其中包含仅存在于第一个数组中但不在第二个数组中的元素。
+
+它有效地过滤掉第一个数组中与第二个数组中出现的元素相匹配的部分。
+
+## 签名
+
+```typescript
+function difference<T>(firstArr: T[], secondArr: T[]): T[];
+```
+
+### 参数
+
+- `firstArr` (`T[]`): 要计算差异的数组。这是主要的数组，从中将比较和过滤元素。
+- `secondArr` (`T[]`): 包含要从第一个数组中排除的元素的数组。将检查这个数组中的每个元素是否在第一个数组中，如果找到匹配，则将其从结果中排除。
+
+### 返回值
+
+(`T[]`) 包含仅存在于第一个数组中但不在第二个数组中的元素的新数组。
+
+## 示例
+
+```typescript
+import { difference } from 'es-toolkit/array';
+
+const array1 = [1, 2, 3, 4, 5];
+const array2 = [2, 4];
+const result = difference(array1, array2);
+// 结果将是 [1, 3, 5]，因为 2 和 4 都在两个数组中，所以它们被排除在结果之外。
+```
--- a/docs/zh_hans/reference/array/differenceBy.md
+++ b/docs/zh_hans/reference/array/differenceBy.md
@ -0,0 +1,35 @@
+# differenceBy
+
+计算经过提供的函数映射后的两个数组之间的差异。
+
+该函数接受两个数组和一个映射函数作为参数。它返回一个新数组，其中包含仅存在于第一个数组中但不在第二个数组中的元素，基于映射函数计算的标识。
+
+本质上，它过滤掉第一个数组中任何映射后与第二个数组中映射版本的元素匹配的部分。
+
+## 签名
+
+```typescript
+function differenceBy<T, U>(firstArr: T[], secondArr: T[], mapper: (value: T) => U): T[];
+```
+
+### 参数
+
+- `firstArr` (`T[]`): 主要的数组，从中计算差异。
+- `secondArr` (`T[]`): 包含要从第一个数组中排除的元素的数组。
+- `mapper` (`(value: T) => U`): 用于映射两个数组元素的函数。该函数应用于两个数组中的每个元素，并基于映射后的值进行比较。
+
+### 返回值
+
+(`T[]`) 包含第一个数组中没有对应映射标识的元素的新数组。
+
+## 示例
+
+```typescript
+import { differenceBy } from 'es-toolkit/array';
+
+const array1 = [{ id: 1 }, { id: 2 }, { id: 3 }, { id: 4 }, { id: 5 }];
+const array2 = [{ id: 2 }, { id: 4 }];
+const mapper = item => item.id;
+const result = differenceBy(array1, array2, mapper);
+// 结果将是 [{ id: 1 }, { id: 3 }, { id: 5 }] 因为具有 id 为 2 的元素在两个数组中都存在，所以它们被排除在结果之外。
+```
--- a/docs/zh_hans/reference/array/differenceWith.md
+++ b/docs/zh_hans/reference/array/differenceWith.md
@ -0,0 +1,35 @@
+# differenceWith
+
+根据自定义相等函数计算两个数组之间的差异。
+
+该函数接受两个数组和一个自定义比较函数作为参数。它返回一个新数组，其中包含仅存在于第一个数组中但不在第二个数组中的元素。
+
+判断元素是否相等是使用提供的自定义函数进行的。
+
+## 签名
+
+```typescript
+function differenceWith<T>(firstArr: T[], secondArr: T[], areItemsEqual: (x: T, y: T) => boolean): T[];
+```
+
+### 参数
+
+- `firstArr` (`T[]`): 要获取差异的数组。
+- `secondArr` (`T[]`): 包含要从第一个数组中排除的元素的数组。
+- `areItemsEqual` (`(x: T, y: T) => boolean`): 用于确定两个项是否相等的函数。
+
+### 返回值
+
+(`T[]`) 一个新数组，包含根据自定义相等函数，第一个数组中与第二个数组中任何元素不匹配的元素。
+
+## 示例
+
+```typescript
+import { differenceWith } from 'es-toolkit/array';
+
+const array1 = [{ id: 1 }, { id: 2 }, { id: 3 }];
+const array2 = [{ id: 2 }, { id: 4 }];
+const areItemsEqual = (a, b) => a.id === b.id;
+const result = differenceWith(array1, array2, areItemsEqual);
+// 结果将是 [{ id: 1 }, { id: 3 }] 因为具有 id 为 2 的元素被认为是相等的，因此被排除在结果之外。
+```
--- a/docs/zh_hans/reference/array/drop.md
+++ b/docs/zh_hans/reference/array/drop.md
@ -0,0 +1,28 @@
+# drop
+
+从数组的开头移除指定数量的元素并返回剩余部分。
+
+该函数接受一个数组和一个数字作为参数，返回一个新数组，从开头移除指定数量的元素。
+
+## 签名
+
+```typescript
+function drop<T>(arr: T[], itemsCount: number): T[];
+```
+
+### 参数
+
+- `arr` (`T[]`): 要从中移除元素的数组。
+- `itemsCount` (`number`): 要从数组开头移除的元素数量。
+
+### 返回值
+
+(`T[]`) 一个新数组，从开头移除了指定数量的元素。
+
+## 示例
+
+```typescript
+const array = [1, 2, 3, 4, 5];
+const result = drop(array, 2);
+// 结果将是 [3, 4, 5] 因为前两个元素被移除了。
+```
--- a/docs/zh_hans/reference/array/dropRight.md
+++ b/docs/zh_hans/reference/array/dropRight.md
@ -0,0 +1,28 @@
+# dropRight
+
+从数组的末尾移除指定数量的元素并返回剩余部分。
+
+该函数接受一个数组和一个数字作为参数，返回一个新数组，从末尾移除指定数量的元素。
+
+## 签名
+
+```typescript
+function dropRight<T>(arr: T[], itemsCount: number): T[];
+```
+
+### 参数
+
+- `arr` (`T[]`): 要从中移除元素的数组。
+- `itemsCount` (`number`): 要从数组末尾移除的元素数量。
+
+### 返回值
+
+(`T[]`) 一个新数组，从末尾移除了指定数量的元素。
+
+## 示例
+
+```typescript
+const array = [1, 2, 3, 4, 5];
+const result = dropRight(array, 2);
+// 结果将是 [1, 2, 3] 因为最后两个元素被移除了。
+```
--- a/docs/zh_hans/reference/array/dropRightWhile.md
+++ b/docs/zh_hans/reference/array/dropRightWhile.md
@ -0,0 +1,28 @@
+# dropRightWhile
+
+从数组末尾移除元素，直到谓词函数返回 false。
+
+该函数迭代数组，并从开头开始移除元素，直到提供的谓词函数返回 false 为止。然后返回剩余元素组成的新数组。
+
+## 签名
+
+```typescript
+function dropRightWhile<T>(arr: T[], canContinueDropping: (item: T) => boolean): T[];
+```
+
+### 参数
+
+- `arr` (`T[]`): 要从中移除元素的数组。
+- `canContinueDropping` (`(item: T) => boolean`): 一个谓词函数，用于确定是否继续移除元素。该函数将对数组中的每个元素调用，只要返回 true，移除操作就会继续。
+
+### 返回值
+
+(`T[]`) 谓词函数返回 false 后剩余的元素组成的新数组。
+
+## 示例
+
+```typescript
+const array = [1, 2, 3, 4, 5];
+const result = dropRightWhile(array, x => x > 3);
+// 结果将是 [1, 2, 3] 因为大于 3 的元素从末尾被移除了。
+```
--- a/docs/zh_hans/reference/array/dropWhile.md
+++ b/docs/zh_hans/reference/array/dropWhile.md
@ -0,0 +1,28 @@
+# dropWhile
+
+从数组开头移除元素，直到谓词函数返回 false。
+
+该函数迭代数组，并从开头开始移除元素，直到提供的谓词函数返回 false 为止。然后返回剩余元素组成的新数组。
+
+## 签名
+
+```typescript
+function dropWhile<T>(arr: T[], canContinueDropping: (item: T) => boolean): T[];
+```
+
+### 参数
+
+- `arr` (`T[]`): 要从中移除元素的数组。
+- `canContinueDropping` (`(item: T) => boolean`): 一个谓词函数，用于确定是否继续移除元素。该函数将对数组中的每个元素调用，只要返回 true，移除操作就会继续。
+
+### 返回值
+
+(`T[]`) 谓词函数返回 false 后剩余的元素组成的新数组。
+
+## 示例
+
+```typescript
+const array = [1, 2, 3, 4, 5];
+const result = dropWhile(array, x => x < 3);
+// 结果将是 [3, 4, 5]，因为小于 3 的元素从开头被移除了。
+```
--- a/docs/zh_hans/reference/array/fill.md
+++ b/docs/zh_hans/reference/array/fill.md
@ -0,0 +1,40 @@
+# fill
+
+填充数组中从起始位置到结束位置（不包括结束位置）的元素为指定值。
+
+该函数会修改原始数组，并用提供的值替换从指定的起始索引到结束索引（不包括结束索引）的元素。如果未提供起始或结束索引，则默认填充整个数组。
+
+## 签名
+
+```typescript
+function fill<T>(array: unknown[], value: T): T[];
+function fill<T, P>(array: T[], value: P, start: number): Array<T | P>;
+function fill<T, P>(array: T[], value: P, start: number, end: number): Array<T | P>;
+```
+
+### 参数
+
+- `array` (`Array<T | P>`): 要填充的数组。
+- `value` (`P`): 用来填充数组的值。
+- `start` (`number`, 默认值为 0): 起始位置。默认为 0。
+- `end` (`number`, 默认值为 array.length): 结束位置。默认为数组的长度。
+
+### 返回值
+
+(`Array<T | P>`): 填充后的数组。
+
+## 示例
+
+```typescript
+const array1 = [1, 2, 3];
+const result1 = fill(array1, 'a');
+// result1 => ['a', 'a', 'a']
+
+const array2 = Array(3);
+const result2 = fill(array2, 2);
+// result2 => [2, 2, 2]
+
+const array3 = [4, 6, 8, 10];
+const result3 = fill(array3, '*', 1, 3);
+// result3 => [4, '*', '*', 10]
+```
--- a/docs/zh_hans/reference/array/flatten.md
+++ b/docs/zh_hans/reference/array/flatten.md
@ -0,0 +1,35 @@
+# flatten
+
+将作为参数传递的嵌套数组展开到指定的深度。
+
+它与 JavaScript 默认提供的 [Array.prototype.flat](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/flat) 功能相同，并返回相同的类型。不过，其性能更优秀。
+
+## 签名
+
+```typescript
+function flatten<T, D extends number = 1>(arr: T[], depth?: D): Array<FlatArray<T[], D>>;
+```
+
+### 参数
+
+- `arr` (`T[]`): 要展开的数组。
+- `depth` (`D`): 展开的深度，默认为 1。
+
+### 返回值
+
+(`Array<FlatArray<T[], D>>`) 展开后的新数组。
+
+## 示例
+
+```typescript
+const originArr = [1, [2, 3], [4, [5, 6]]];
+
+const array1 = flatten(originArr);
+// Return [1, 2, 3, 4, [5, 6]]
+
+const array2 = flatten(originArr, 1);
+// Return [1, 2, 3, 4, [5, 6]]
+
+const array3 = flatten(originArr, 2);
+// Return [1, 2, 3, 4, 5, 6]
+```
--- a/docs/zh_hans/reference/array/forEachRight.md
+++ b/docs/zh_hans/reference/array/forEachRight.md
@ -0,0 +1,37 @@
+# forEachRight
+
+从右到左迭代 `arr` 数组的每个元素，并对每个元素调用 `callback` 函数。
+
+## 签名
+
+```ts
+function forEachRight<T>(arr: T[], callback: (value: T, index: number, arr: T[]) => void): void;
+```
+
+### 参数
+
+- `arr` (`T[]`): 要迭代的数组。
+- `callback` (`(value: T, index: number, arr: T[])`): 每次迭代调用的函数。
+  - `value`: 数组中当前正在处理的元素。
+  - `index`: 数组中当前正在处理的元素的索引。
+  - `arr`: 被调用 `forEachRight` 的数组。
+
+### 返回值
+
+`void`
+
+## 示例
+
+```ts
+import { forEachRight } from 'es-toolkit/forEachRight';
+
+const array = [1, 2, 3];
+const result: number[] = [];
+
+// 使用 `forEachRight` 函数迭代数组，并将每个元素添加到结果数组中。
+forEachRight(array,  (value) => {
+  result.push(value);
+});
+
+console.log(result) // Output: [3, 2, 1];
+```
--- a/docs/zh_hans/reference/array/groupBy.md
+++ b/docs/zh_hans/reference/array/groupBy.md
@ -0,0 +1,41 @@
+# groupBy
+
+将数组的元素根据提供的键生成函数进行分组。
+
+该函数接受一个数组和一个从每个元素生成键的函数。它返回一个对象，其中键是生成的键，值是具有相同键的元素数组。
+
+## 签名
+
+```typescript
+function groupBy<T, K extends PropertyKey>(arr: T[], getKeyFromItem: (item: T) => K): Record<K, T[]>;
+```
+
+### 参数
+
+- `arr` (`T[]`): 要分组的数组。
+- `getKeyFromItem` (`(item: T) => K`): 从元素生成键的函数。
+
+### 返回值
+
+(`Record<K, T[]>`) 一个对象，其中每个键关联一个具有共享该键的元素数组。
+
+## 示例
+
+```typescript
+const array = [
+  { category: 'fruit', name: 'apple' },
+  { category: 'fruit', name: 'banana' },
+  { category: 'vegetable', name: 'carrot' },
+];
+const result = groupBy(array, item => item.category);
+// 结果将是:
+// {
+//   fruit: [
+//     { category: 'fruit', name: 'apple' },
+//     { category: 'fruit', name: 'banana' }
+//   ],
+//   vegetable: [
+//     { category: 'vegetable', name: 'carrot' }
+//   ]
+// }
+```
--- a/docs/zh_hans/reference/array/head.md
+++ b/docs/zh_hans/reference/array/head.md
@ -0,0 +1,44 @@
+# head
+
+返回数组的第一个元素。
+
+该函数接受一个数组，并返回数组的第一个元素。如果数组为空，则函数返回 `undefined`。
+
+## 签名
+
+```typescript
+export function head<T>(arr: readonly [T, ...T[]]): T;
+export function head<T>(arr: readonly T[]): T | undefined;
+```
+
+### 参数
+
+- `arr` (`T[]`): 要获取第一个元素的数组。
+
+### 返回值
+
+(`T | undefined`): 数组的第一个元素，如果数组为空则返回 `undefined`。
+
+## 示例
+
+```typescript
+const arr1 = [1, 2, 3];
+const firstElement1 = head(arr1);
+// firstElement1 将是 1
+
+const arr2: string[] = [];
+const firstElement2 = head(arr2);
+// firstElement2 将是 undefined
+
+const arr3 = ['a', 'b', 'c'];
+const firstElement3 = head(arr3);
+// firstElement3 将是 'a'
+
+const arr4 = [true, false, true];
+const firstElement4 = head(arr4);
+// firstElement4 将是 true
+
+const arr5: [number, string, boolean] = [1, 'a', true];
+const firstElement5 = head(arr5);
+// firstElement5 将是 1
+```
--- a/docs/zh_hans/reference/array/intersection.md
+++ b/docs/zh_hans/reference/array/intersection.md
@ -0,0 +1,31 @@
+# intersection
+
+返回两个数组的交集。
+
+该函数接受两个数组并返回一个新数组，该数组包含同时存在于两个数组中的元素。
+
+它有效地过滤掉第一个数组中不在第二个数组中的元素。
+
+## 签名
+
+```typescript
+function intersection<T>(firstArr: T[], secondArr: T[]): T[];
+```
+
+### 参数
+
+- `firstArr` (`T[]`): 要比较的第一个数组。
+- `secondArr` (`T[]`): 要比较的第二个数组。
+
+### 返回值
+
+(`T[]`) 包含同时存在于两个数组中的元素的新数组。
+
+## 示例
+
+```typescript
+const array1 = [1, 2, 3, 4, 5];
+const array2 = [3, 4, 5, 6, 7];
+const result = intersection(array1, array2);
+// 结果将是 [3, 4, 5] 因为这些元素在两个数组中都存在。
+```
--- a/docs/zh_hans/reference/array/intersectionBy.md
+++ b/docs/zh_hans/reference/array/intersectionBy.md
@ -0,0 +1,33 @@
+# intersectionBy
+
+返回基于映射函数的两个数组的交集。
+
+该函数接受两个数组和一个映射函数。它返回一个新数组，该数组包含从第一个数组中选取的元素，这些元素在使用提供的函数进行映射后，在第二个数组中有匹配的映射元素。
+
+它有效地过滤掉第一个数组中没有在第二个数组中具有相应映射值的元素。
+
+## 签名
+
+```typescript
+function intersectionBy<T, U>(firstArr: T[], secondArr: T[], mapper: (item: T) => U): T[];
+```
+
+### 参数
+
+- `firstArr` (`T[]`): 要比较的第一个数组。
+- `secondArr` (`T[]`): 要比较的第二个数组。
+- `mapper` (`(item: T) => U`): 用于映射两个数组元素以进行比较的函数。
+
+### 返回值
+
+(`T[]`) 包含第一个数组中具有第二个数组中对应映射值的元素的新数组。
+
+## 示例
+
+```typescript
+const array1 = [{ id: 1 }, { id: 2 }, { id: 3 }];
+const array2 = [{ id: 2 }, { id: 4 }];
+const mapper = item => item.id;
+const result = intersectionBy(array1, array2, mapper);
+// 结果将是 [{ id: 2 }] 因为只有这个元素在两个数组中具有匹配的 id。
+```
--- a/docs/zh_hans/reference/array/intersectionWith.md
+++ b/docs/zh_hans/reference/array/intersectionWith.md
@ -0,0 +1,33 @@
+# intersectionWith
+
+返回基于自定义相等函数的两个数组的交集。
+
+该函数接受两个数组和一个自定义相等函数。它返回一个新数组，该数组包含从第一个数组中选取的元素，这些元素在使用提供的自定义相等函数进行比较时，在第二个数组中有匹配的元素。
+
+它有效地过滤掉第一个数组中根据相等函数没有在第二个数组中具有对应匹配的元素。
+
+## 签名
+
+```typescript
+function intersectionWith<T>(firstArr: T[], secondArr: T[], areItemsEqual: (x: T, y: T) => boolean): T[];
+```
+
+### 参数
+
+- `firstArr` (`T[]`): 要比较的第一个数组。
+- `secondArr` (`T[]`): 要比较的第二个数组。
+- `areItemsEqual` (`(x: T, y: T) => boolean`): 一个自定义函数，用于确定两个元素是否相等。该函数接受两个参数，分别来自每个数组，如果这两个元素被认为相等，则返回 true，否则返回 false。
+
+### 返回值
+
+(`T[]`) 包含第一个数组中具有第二个数组中对应匹配的元素的新数组。
+
+## 示例
+
+```typescript
+const array1 = [{ id: 1 }, { id: 2 }, { id: 3 }];
+const array2 = [{ id: 2 }, { id: 4 }];
+const areItemsEqual = (a, b) => a.id === b.id;
+const result = intersectionWith(array1, array2, areItemsEqual);
+// 结果将是 [{ id: 2 }] 因为这个元素在两个数组中具有匹配的 id。
+```
--- a/docs/zh_hans/reference/array/keyBy.md
+++ b/docs/zh_hans/reference/array/keyBy.md
@ -0,0 +1,38 @@
+# keyBy
+
+映射数组中的每个元素，基于提供的生成键的函数。
+
+该函数接受一个数组和一个生成键的函数，返回一个对象，其中键是生成的键，值是对应的元素。
+
+如果有多个元素生成相同的键，则最后一个元素将作为该键的值。
+
+## 签名
+
+```typescript
+function keyBy<T, K extends PropertyKey>(arr: readonly T[], getKeyFromItem: (item: T) => K): Record<K, T>;
+```
+
+### 参数
+
+- `arr` (`T[]`): 要映射的元素数组。
+- `getKeyFromItem` (`(item: T) => K`): 从元素生成键的函数。
+
+### 返回值
+
+(`Record<K, T>`) 一个对象，其中键映射到数组中的每个元素。
+
+## 示例
+
+```typescript
+const array = [
+  { category: 'fruit', name: 'apple' },
+  { category: 'fruit', name: 'banana' },
+  { category: 'vegetable', name: 'carrot' },
+];
+const result = keyBy(array, item => item.category);
+// result 将会是:
+// {
+//   fruit: { category: 'fruit', name: 'banana' },
+//   vegetable: { category: 'vegetable', name: 'carrot' }
+// }
+```
--- a/docs/zh_hans/reference/array/last.md
+++ b/docs/zh_hans/reference/array/last.md
@ -0,0 +1,46 @@
+# last
+
+返回数组的最后一个元素。
+
+该函数接受一个数组，并返回该数组的最后一个元素。如果数组为空，则函数返回 `undefined`。
+
+## 签名
+
+```typescript
+function last<T>(arr: [...T[], T]): T;
+function last<T>(arr: T[]): T | undefined;
+```
+
+### 参数
+
+- `arr` (`T[]`): 要获取最后一个元素的数组。
+
+### 返回值
+
+(`T | undefined`): 数组的最后一个元素，如果数组为空则返回 `undefined`。
+
+## 示例
+
+```typescript
+const arr1 = [1, 2, 3];
+const result = last(arr1);
+// result 将会是 3
+
+const arr2: number[] = [];
+const result = last(arr2);
+// result 将会是 undefined
+
+const largeArray = Array(1000)
+  .fill(0)
+  .map((_, i) => i);
+const result = last(largeArray);
+// result 将会是 999
+
+const nestedArray = [
+  [3, 1],
+  [3, 2],
+  [3, 3],
+];
+const result = last(nestedArray);
+// result 将会是 [3,3]
+```
--- a/docs/zh_hans/reference/array/maxBy.md
+++ b/docs/zh_hans/reference/array/maxBy.md
@ -0,0 +1,26 @@
+# maxBy
+
+找出应用 `getValue` 函数到每个元素后具有最大值的元素。
+
+如果列表为空，则返回 `undefined`。
+
+## 签名
+
+```typescript
+function maxBy<T>(items: T[], getValue: (item: T) => number): T;
+```
+
+### 参数
+
+- `items` (`T[]`): 要搜索的元素数组。
+- `getValue` (`(item: T) => number`): 从每个元素中选择数值的函数。
+
+### 返回值
+
+由 `getValue` 函数确定的具有最大值的元素。
+
+### 示例
+
+```typescript
+maxBy([{ a: 1 }, { a: 2 }, { a: 3 }], x => x.a); // 返回: { a: 3 }
+maxBy([], x => x.a); // 返回: undefined
--- a/docs/zh_hans/reference/array/minBy.md
+++ b/docs/zh_hans/reference/array/minBy.md
@ -0,0 +1,27 @@
+# minBy
+
+找到数组中通过将 `getValue` 函数应用于每个元素后具有最小值的元素。
+
+如果列表为空，则返回 `undefined`。
+
+## 签名
+
+```typescript
+function minBy<T>(items: T[], getValue: (item: T) => number): T;
+```
+
+### 参数
+
+- `items` (`T[]`): 要搜索的元素数组。
+- `getValue` (`(item: T) => number`): 从每个元素中选择数值的函数。
+
+### 返回值
+
+通过 `getValue` 函数确定的具有最小值的元素。
+
+### 示例
+
+```typescript
+minBy([{ a: 1 }, { a: 2 }, { a: 3 }], x => x.a); // 返回: { a: 1 }
+minBy([], x => x.a); // 返回: undefined
+```
--- a/docs/zh_hans/reference/array/orderBy.md
+++ b/docs/zh_hans/reference/array/orderBy.md
@ -0,0 +1,45 @@
+# orderBy
+
+根据多个属性和它们对应的排序方向对对象数组进行排序。
+
+此函数接受一个对象数组，一个要排序的属性键数组，以及一个排序方向数组。
+
+它返回排序后的数组，根据每个键及其对应的方向（'asc' 表示升序，'desc' 表示降序）进行排序。
+
+如果一个键的值相等，则继续比较下一个键以确定顺序。
+
+## 签名
+
+```typescript
+function orderBy<T>(collection: T[], keys: Array<keyof T>, orders: Order[]): T[];
+```
+
+### 参数
+
+- `collection` (`T[]`): 要排序的对象数组。
+- `keys` (`Array<keyof T>`): 用于排序的键（属性）数组。
+- `orders` (`Order[]`): 排序方向数组（'asc' 表示升序，'desc' 表示降序）。
+
+### 返回值
+
+(`T[]`) 排序后的数组。
+
+## 示例
+
+```typescript
+const users = [
+  { user: 'fred', age: 48 },
+  { user: 'barney', age: 34 },
+  { user: 'fred', age: 40 },
+  { user: 'barney', age: 36 },
+];
+
+const result = orderBy(users, ['user', 'age'], ['asc', 'desc']);
+// result 将会是:
+// [
+//   { user: 'barney', age: 36 },
+//   { user: 'barney', age: 34 },
+//   { user: 'fred', age: 48 },
+//   { user: 'fred', age: 40 },
+// ]
+```
--- a/docs/zh_hans/reference/array/partition.md
+++ b/docs/zh_hans/reference/array/partition.md
@ -0,0 +1,33 @@
+# partition
+
+根据谓词函数将数组分割为两组。
+
+该函数接受一个数组和一个谓词函数作为参数。它返回一个包含两个数组的元组：
+
+第一个数组包含谓词函数返回 true 的元素，
+
+第二个数组包含谓词函数返回 false 的元素。
+
+## 签名
+
+```typescript
+function partition<T>(arr: T[], isInTruthy: (value: T) => boolean): [truthy: T[], falsy: T[]];
+```
+
+### 参数
+
+- `arr` (`T[]`): 要分组的数组。
+- `isInTruthy` (`(value: T) => boolean`): 判断元素应该放入真值数组的谓词函数。该函数将对数组的每个元素进行调用。
+
+### 返回值
+
+(`[T[], T[]]`): 包含两个数组的元组：第一个数组包含谓词函数返回 true 的元素，第二个数组包含谓词函数返回 false 的元素。
+
+## 示例
+
+```typescript
+const array = [1, 2, 3, 4, 5];
+const isEven = x => x % 2 === 0;
+const [even, odd] = partition(array, isEven);
+// even 将会是 [2, 4] 而 odd 将会是 [1, 3, 5]
+```
--- a/docs/zh_hans/reference/array/sample.md
+++ b/docs/zh_hans/reference/array/sample.md
@ -0,0 +1,27 @@
+# sample
+
+返回数组中的随机元素。
+
+该函数接受一个数组，并从数组中随机选择一个元素。
+
+## 签名
+
+```typescript
+function sample<T>(arr: T[]): T;
+```
+
+### 参数
+
+- `arr` (`T[]`): 要从中取样的数组。
+
+### 返回值
+
+(`T`): 数组中的一个随机元素。
+
+## 示例
+
+```typescript
+const array = [1, 2, 3, 4, 5];
+const randomElement = sample(array);
+// randomElement 将会是数组中的某个随机元素。
+```
--- a/docs/zh_hans/reference/array/sampleSize.md
+++ b/docs/zh_hans/reference/array/sampleSize.md
@ -0,0 +1,32 @@
+# sampleSize
+
+返回一个指定大小的数组样本。
+
+该函数接受一个数组和一个数字，并返回一个包含采样元素的数组，采用[Floyd's algorithm](https://www.nowherenearithaca.com/2013/05/robert-floyds-tiny-and-beautiful.html)。
+
+## 签名
+
+```typescript
+export function sampleSize<T>(array: readonly T[], size: number): T[];
+```
+
+### 参数
+
+- `array` (`T[]`): 要从中采样的数组。
+- `size` (`number`): 采样的大小。
+
+### 返回值
+
+(`T[]`): 应用了采样大小的新数组。
+
+### 抛出异常
+
+如果 `size` 大于 `array` 的长度，则抛出错误。
+
+## 示例
+
+```typescript
+const result = sampleSize([1, 2, 3], 2);
+// 结果将是一个包含数组中两个元素的数组。
+// [1, 2] 或者 [1, 3] 或者 [2, 3]
+```
--- a/docs/zh_hans/reference/array/shuffle.md
+++ b/docs/zh_hans/reference/array/shuffle.md
@ -0,0 +1,27 @@
+# shuffle
+
+随机化数组中元素的顺序，使用 Fisher-Yates 算法。
+
+该函数接受一个数组作为参数，并返回一个新数组，其中元素以随机顺序进行了洗牌。
+
+## 签名
+
+```typescript
+function shuffle<T>(arr: T[]): T[];
+```
+
+### 参数
+
+- `arr` (`T[]`): 要洗牌的数组。
+
+### 返回值
+
+(`T[]`): 元素以随机顺序洗牌后的新数组。
+
+## 示例
+
+```typescript
+const array = [1, 2, 3, 4, 5];
+const shuffledArray = shuffle(array);
+// shuffledArray 将会是一个新数组，其中包含 array 的元素以随机顺序排列，例如 [3, 1, 4, 5, 2]
+```
--- a/docs/zh_hans/reference/array/tail.md
+++ b/docs/zh_hans/reference/array/tail.md
@ -0,0 +1,40 @@
+# tail
+
+返回一个新数组，其中除了第一个元素外，包含所有元素。
+
+该函数接受一个数组作为参数，并返回一个新数组，该数组包含除第一个元素外的所有元素。
+
+如果输入数组为空或只有一个元素，则返回一个空数组。
+
+## 签名
+
+```typescript
+function tail<T>(arr: [T]): [];
+function tail(arr: []): [];
+function tail<T, U>(arr: [T, ...U[]]): U[];
+function tail<T>(arr: T[]): T[];
+```
+
+### 参数
+
+- `arr` (`T[]`): 要获取尾部的数组。
+
+### 返回值
+
+(`T[]`): 一个新数组，包含除输入数组第一个元素外的所有元素。
+
+## 示例
+
+```typescript
+const arr1 = [1, 2, 3];
+const result = tail(arr1);
+// result 将会是 [2, 3]
+
+const arr2 = [1];
+const result2 = tail(arr2);
+// result2 将会是 []
+
+const arr3 = [];
+const result3 = tail(arr3);
+// result3 将会是 []
+```
--- a/docs/zh_hans/reference/array/take.md
+++ b/docs/zh_hans/reference/array/take.md
@ -0,0 +1,33 @@
+# take
+
+返回一个新数组，其中包含从输入数组 `arr` 中获取的前 `count` 个元素。
+
+如果 `count` 大于 `arr` 的长度，则返回整个数组。
+
+## 签名
+
+```typescript
+function take<T>(arr: T[], count: number): T[];
+```
+
+### 参数
+
+- `arr` (`T[]`): 要提取元素的数组。
+- `count` (`number`): 要提取的元素数量。
+
+### 返回值
+
+(`T[]`): 包含从 `arr` 中取出的前 `count` 个元素的新数组。
+
+## 示例
+
+```typescript
+// 返回 [1, 2, 3]
+take([1, 2, 3, 4, 5], 3);
+
+// 返回 ['a', 'b']
+take(['a', 'b', 'c'], 2);
+
+// 返回 [1, 2, 3]
+take([1, 2, 3], 5);
+```
--- a/docs/zh_hans/reference/array/takeRight.md
+++ b/docs/zh_hans/reference/array/takeRight.md
@ -0,0 +1,33 @@
+# takeRight
+
+返回一个新数组，其中包含从输入数组 `arr` 中获取的最后 `count` 个元素。
+
+如果 `count` 大于 `arr` 的长度，则返回整个数组。
+
+## 签名
+
+```typescript
+function takeRight<T>(arr: T[], count: number): T[];
+```
+
+### 参数
+
+- `arr` (`T[]`): 要提取元素的数组。
+- `count` (`number`): 要提取的元素数量。
+
+### 返回值
+
+(`T[]`) 包含从 `arr` 中取出的最后 `count` 个元素的新数组。
+
+## 示例
+
+```typescript
+// 返回 [4, 5]
+takeRight([1, 2, 3, 4, 5], 2);
+
+// 返回 ['b', 'c']
+takeRight(['a', 'b', 'c'], 2);
+
+// 返回 [1, 2, 3]
+takeRight([1, 2, 3], 5);
+```
--- a/docs/zh_hans/reference/array/takeRightWhile.md
+++ b/docs/zh_hans/reference/array/takeRightWhile.md
@ -0,0 +1,28 @@
+# takeRightWhile
+
+从数组末尾获取元素，直到谓词函数返回 `false`。
+
+## 签名
+
+```typescript
+function takeRightWhile<T>(arr: T[], shouldContinueTaking: (item: T) => boolean): T[];
+```
+
+### 参数
+
+- `arr` (`T[]`): 要获取元素的数组。
+- `shouldContinueTaking` (`(item: T) => boolean`): 谓词函数，对每个元素调用该函数。只要该函数返回 `true`，就将元素包含在结果中。
+
+### 返回值
+
+(`T[]`) 包含从数组末尾获取的元素，直到谓词函数返回 `false` 的新数组。
+
+## 示例
+
+```typescript
+// 返回 [3, 2, 1]
+takeRightWhile([5, 4, 3, 2, 1], n => n < 4);
+
+// 返回 []
+takeRightWhile([1, 2, 3], n => n > 3);
+```
--- a/docs/zh_hans/reference/array/takeWhile.md
+++ b/docs/zh_hans/reference/array/takeWhile.md
@ -0,0 +1,30 @@
+# takeWhile
+
+返回一个新数组，其中包含满足提供的谓词函数的前导元素。
+
+一旦有一个元素不满足谓词，就停止获取元素。
+
+## 签名
+
+```typescript
+function takeWhile<T>(arr: T[], shouldContinueTaking: (element: T) => boolean): T[];
+```
+
+### 参数
+
+- `arr` (`T[]`): 要获取元素的数组。
+- `shouldContinueTaking` (`(item: T) => boolean`): 谓词函数，对每个元素调用该函数。只要该函数返回 `true`，就将元素包含在结果中。
+
+### 返回值
+
+(`T[]`) 包含从数组开头获取的元素，直到谓词函数返回 `false` 的新数组。
+
+## 示例
+
+```typescript
+// 返回 [1, 2]
+takeWhile([1, 2, 3, 4], x => x < 3);
+
+// 返回 []
+takeWhile([1, 2, 3, 4], x => x > 3);
+```
--- a/docs/zh_hans/reference/array/toFilled.md
+++ b/docs/zh_hans/reference/array/toFilled.md
@ -0,0 +1,48 @@
+# toFilled
+
+创建一个新数组，从指定的起始位置到结束位置（不包括结束位置），填充指定的值。
+
+如果未提供起始或结束索引，则默认填充整个数组。
+
+还可以使用负索引，此时索引从数组末尾开始计数。
+
+## 签名
+
+```typescript
+function toFilled<T, U>(arr: T[], value: U): Array<T | U>;
+function toFilled<T, U>(arr: T[], value: U, start: number): Array<T | U>;
+function toFilled<T, U>(arr: T[], value: U, start: number, end: number): Array<T | U>;
+```
+
+### 参数
+
+- `arr` (`Array<T>`): 基于其创建新数组的原始数组。
+- `value` (`U`): 要用来填充新数组的值。
+- `start` (`number, 默认值 = 0`): 起始位置。默认为 0。
+- `end` (`number, 默认值 = array.length`): 结束位置。默认为数组的长度。
+
+### Return Value
+
+(`Array<T | U>`): 包含指定值填充的新数组。
+
+### 示例
+
+```typescript
+const array = [1, 2, 3, 4, 5];
+
+let result = toFilled(array, '*', 2);
+console.log(result); // [1, 2, '*', '*', '*']
+console.log(array); // [1, 2, 3, 4, 5]
+
+result = toFilled(array, '*', 1, 4);
+console.log(result); // [1, '*', '*', '*', 5]
+console.log(array); // [1, 2, 3, 4, 5]
+
+result = toFilled(array, '*');
+console.log(result); // ['*', '*', '*', '*', '*']
+console.log(array); // [1, 2, 3, 4, 5]
+
+result = toFilled(array, '*', -4, -1);
+console.log(result); // [1, '*', '*', '*', 5]
+console.log(array); // [1, 2, 3, 4, 5]
+```
--- a/docs/zh_hans/reference/array/union.md
+++ b/docs/zh_hans/reference/array/union.md
@ -0,0 +1,29 @@
+# union
+
+从所有给定的数组中创建一个包含唯一值的数组。
+
+此函数接受两个数组，将它们合并为一个数组，并返回一个新数组，其中包含合并后数组中的唯一值。
+
+## 签名
+
+```typescript
+function union<T>(arr1: T[], arr2: T[]): T[];
+```
+
+### 参数
+
+- `arr1` (`T[]`): 第一个数组，用于合并和筛选唯一值。
+- `arr2` (`T[]`): 第二个数组，用于合并和筛选唯一值。
+
+### 返回值
+
+(`T[]`): 包含唯一值的新数组。
+
+## 示例
+
+```typescript
+const array1 = [1, 2, 3];
+const array2 = [3, 4, 5];
+const result = union(array1, array2);
+// result 将会是 [1, 2, 3, 4, 5]
+```
--- a/docs/zh_hans/reference/array/unionBy.md
+++ b/docs/zh_hans/reference/array/unionBy.md
@ -0,0 +1,26 @@
+# unionBy
+
+使用提供的映射函数来确定相等性，从所有给定的数组中创建一个按顺序的唯一值数组。
+
+## 签名
+
+```typescript
+function unionBy<T, U>(arr1: T[], arr2: T[], mapper: (item: T) => U): T[];
+```
+
+### 参数
+
+- `arr1` (`T[]`): 第一个数组。
+- `arr2` (`U[]`): 第二个数组。
+- `mapper` (`(item: T) => U`): 将数组元素映射到比较值的函数。
+
+### 返回值
+
+(`T[]`): 包含来自 `arr1` 和 `arr2` 的唯一元素并按顺序排列的新数组，基于映射函数返回的值。
+
+## 示例
+
+```typescript
+unionBy([{ id: 1 }, { id: 2 }], [{ id: 2 }, { id: 3 }], x => x.id);
+// 返回 [{ id: 1 }, { id: 2 }, { id: 3 }]
+```
--- a/docs/zh_hans/reference/array/unionWith.md
+++ b/docs/zh_hans/reference/array/unionWith.md
@ -0,0 +1,31 @@
+# unionWith
+
+根据自定义相等性函数，从两个给定的数组创建一个唯一值数组。
+
+此函数接受两个数组和一个自定义相等性函数，合并这两个数组，并返回一个新数组，该数组仅包含根据自定义相等性函数确定的唯一值。
+
+## 签名
+
+```typescript
+function unionWith<T>(arr1: T[], arr2: T[], areItemsEqual: (item1: T, item2: T) => boolean): T[];
+```
+
+### 参数
+
+- `arr1` (`T[]`): 第一个数组，用于合并和筛选唯一值。
+- `arr2` (`T[]`): 第二个数组，用于合并和筛选唯一值。
+- `areItemsEqual` (`(item1: T, item2: T) => boolean`): 自定义函数，用于确定两个元素是否相等。它接受两个参数，如果元素被视为相等则返回 `true`，否则返回 `false`。
+
+### 返回值
+
+(`T[]`): 基于自定义相等性函数的新唯一值数组。
+
+## 示例
+
+```typescript
+const array1 = [{ id: 1 }, { id: 2 }];
+const array2 = [{ id: 2 }, { id: 3 }];
+const areItemsEqual = (a, b) => a.id === b.id;
+const result = unionWith(array1, array2, areItemsEqual);
+// result 将是 [{ id: 1 }, { id: 2 }, { id: 3 }] 因为 { id: 2 } 在两个数组中被视为相等
+```
--- a/docs/zh_hans/reference/array/uniq.md
+++ b/docs/zh_hans/reference/array/uniq.md
@ -0,0 +1,27 @@
+# uniq
+
+创建一个数组的无重复版本。
+
+该函数接受一个数组，并返回一个新数组，其中仅包含原始数组中的唯一值，保留首次出现的顺序。
+
+## 签名
+
+```typescript
+function uniq<T>(arr: T[]): T[];
+```
+
+### 参数
+
+- `arr` (`T[]`): 要处理的数组。
+
+### 返回值
+
+(`T[]`): 一个新数组，仅包含原始数组中的唯一值。
+
+## 示例
+
+```typescript
+const array = [1, 2, 2, 3, 4, 4, 5];
+const result = uniq(array);
+// result 将会是 [1, 2, 3, 4, 5]
+```
--- a/docs/zh_hans/reference/array/uniqBy.md
+++ b/docs/zh_hans/reference/array/uniqBy.md
@ -0,0 +1,25 @@
+# uniqBy
+
+返回一个新数组，仅包含原始数组中基于 `mapper` 函数返回值的唯一元素。
+
+## 签名
+
+```typescript
+function uniqBy<T, U>(arr: T[], mapper: (item: T) => U): T[];
+```
+
+### 参数
+
+- `arr` (`T[]`): 要处理的数组。
+- `mapper` (`(item: T) => U`): 用于转换数组元素的函数。
+
+### 返回值
+
+(`T[]`): 一个新数组，仅包含原始数组中基于 `mapper` 函数返回值的唯一元素。
+
+## 示例
+
+```typescript
+uniqBy([1.2, 1.5, 2.1, 3.2, 5.7, 5.3, 7.19], Math.floor);
+// [1.2, 2.1, 3.3, 5.7, 7.19]
+```
--- a/docs/zh_hans/reference/array/uniqWith.md
+++ b/docs/zh_hans/reference/array/uniqWith.md
@ -0,0 +1,25 @@
+# uniqWith
+
+返回一个新数组，仅包含原始数组中基于比较器函数返回值的唯一元素。
+
+## 签名
+
+```typescript
+function uniqWith<T>(arr: T[], areItemsEqual: (item1: T, item2: T) => boolean): T[];
+```
+
+### 参数
+
+- `arr` (`T[]`): 要处理的数组。
+- `areItemsEqual` (`(x: T, y: T) => boolean`): 自定义函数，用于确定两个元素是否相等。此函数接受两个参数，分别来自每个数组，并在元素被认为相等时返回 true，否则返回 false。
+
+### 返回值
+
+(`T[]`): 一个新数组，仅包含基于比较器函数返回值的原始数组中的唯一元素。
+
+## 示例
+
+```typescript
+uniqWith([1.2, 1.5, 2.1, 3.2, 5.7, 5.3, 7.19], (a, b) => Math.abs(a - b) < 1);
+// [1.2, 3.2, 5.7, 7.19]
+```
--- a/docs/zh_hans/reference/array/unzip.md
+++ b/docs/zh_hans/reference/array/unzip.md
@ -0,0 +1,28 @@
+# unzip
+
+将一个元素组的数组中相同位置的元素收集起来，并将它们作为一个新数组返回。
+
+## 签名
+
+```typescript
+type Unzip<K extends unknown[]> = { [I in keyof K]: Array<K[I]> };
+function unzip<T extends unknown[]>(zipped: Array<[...T]>): Unzip<T>;
+```
+
+### 参数
+
+- `zipped` (`Array<[...T]>`): 一个包含元素组的数组。
+
+### 返回值
+
+(`Unzip<T>`): 收集同一位置的内部数组元素而创建的新数组。
+
+## 示例
+
+```typescript
+unzip([
+  ['a', true, 1],
+  ['b', false, 2],
+]);
+// 返回: [['a', 'b'], [true, false], [1, 2]]
+```
--- a/docs/zh_hans/reference/array/unzipWith.md
+++ b/docs/zh_hans/reference/array/unzipWith.md
@ -0,0 +1,30 @@
+# unzipWith
+
+将一个嵌套的数组解压缩，并对重新分组的元素应用一个 `iteratee` 函数。
+
+## 签名
+
+```typescript
+function unzipWith<T, R>(target: T[][], iteratee: (...args: T[]) => R): R[];
+```
+
+### 参数
+
+- `target` (`T[][]`): 要解压缩的嵌套数组。这是一个数组的数组，其中每个内部数组包含要解压缩的元素。
+- `iteratee` (`(...args: T[]) => R`): 用于转换解压缩后的元素的函
+
+### 返回值
+
+(`R[]`): 新的解压缩和转换后的元素数组。
+
+## 示例
+
+```typescript
+const nestedArray = [
+  [1, 2],
+  [3, 4],
+  [5, 6],
+];
+const result = unzipWith(nestedArray, (item, item2, item3) => item + item2 + item3);
+// [9, 12]
+```
--- a/docs/zh_hans/reference/array/without.md
+++ b/docs/zh_hans/reference/array/without.md
@ -0,0 +1,42 @@
+# without
+
+创建一个数组，其中排除了所有指定的值。
+
+它正确地排除了 `NaN`，因为它使用 [SameValueZero](https://tc39.es/ecma262/multipage/abstract-operations.html#sec-samevaluezero) 进行值比较。
+
+## 签名
+
+```typescript
+function without<T>(array: T[], ...values: T[]): T[];
+```
+
+### 参数
+
+- `array` (`T[]`): 要排除值的数组。
+- `values` (`...T[]`): 要排除的值。
+
+### 返回值
+
+(`T[]`) 不包含指定值的新数组。
+
+## 示例
+
+```typescript
+import { without } from 'es-toolkit/array';
+
+// 从数组中移除指定的值
+without([1, 2, 3, 4, 5], 2, 4);
+// 返回: [1, 3, 5]
+
+// 从数组中移除指定的字符串值
+without(['a', 'b', 'c', 'a'], 'a');
+// 返回: ['b', 'c']
+
+// 处理没有任何指定值在数组中的情况
+without([1, 2, 3], 4, 5);
+// 返回: [1, 2, 3]
+
+// 处理包含不同类型值的情况
+without([1, '2', 3, '4'], 2, '4');
+// 返回: [1, '2', 3]
+```
--- a/docs/zh_hans/reference/array/xor.md
+++ b/docs/zh_hans/reference/array/xor.md
@ -0,0 +1,30 @@
+# xor
+
+计算两个数组之间的对称差异。
+
+对称差异是指在任一数组中存在，但不在它们的交集中的元素集合。
+
+## 签名
+
+```typescript
+function xor<T>(arr1: T[], arr2: T[]): T[];
+```
+
+### 参数
+
+- `arr1` (`T[]`): 第一个数组。
+- `arr2` (`T[]`): 第二个数组。
+
+### 返回值
+
+(`T[]`): 包含在 `arr1` 或 `arr2` 中存在但不同时存在于两者中的元素的数组。
+
+## 示例
+
+```typescript
+// 返回 [1, 2, 5, 6]
+xor([1, 2, 3, 4], [3, 4, 5, 6]);
+
+// 返回 ['a', 'c']
+xor(['a', 'b'], ['b', 'c']);
+```
--- a/docs/zh_hans/reference/array/xorBy.md
+++ b/docs/zh_hans/reference/array/xorBy.md
@ -0,0 +1,28 @@
+# xorBy
+
+使用自定义映射函数计算两个数组之间的对称差异。
+
+对称差异是指在任一数组中存在，但不在它们的交集中的元素集合，根据映射函数返回的值确定。
+
+## 签名
+
+```typescript
+function xorBy<T, U>(arr1: T[], arr2: T[], mapper: (item: T) => U): T[];
+```
+
+### 参数
+
+- `arr1` (`T[]`): 第一个数组。
+- `arr2` (`T[]`): 第二个数组。
+- `mapper` (`(item: T) => U`): 将数组元素映射为比较值的函数。
+
+### 返回值
+
+(`T[]`): 包含在 `arr1` 或 `arr2` 中存在但不同时存在于两者中的元素的数组，基于映射函数返回的值。
+
+## 示例
+
+```typescript
+// 返回 [{ id: 1 }, { id: 3 }]
+xorBy([{ id: 1 }, { id: 2 }], [{ id: 2 }, { id: 3 }], x => x.id);
+```
--- a/docs/zh_hans/reference/array/xorWith.md
+++ b/docs/zh_hans/reference/array/xorWith.md
@ -0,0 +1,28 @@
+# xorWith
+
+使用自定义相等性函数计算两个数组之间的对称差异。
+
+对称差异是指在任一数组中存在，但不在它们的交集中的元素集合，根据自定义的相等性函数进行比较。
+
+## 签名
+
+```typescript
+function xorWith<T>(arr1: T[], arr2: T[], areElementsEqual: (item1: T, item2: T) => boolean): T[];
+```
+
+### 参数
+
+- `arr1` (`T[]`): 第一个数组。
+- `arr2` (`T[]`): 第二个数组。
+- `areElementsEqual` (`(item1: T, item2: T) => boolean`): 自定义的相等性函数，用于比较元素。
+
+### 返回值
+
+(`T[]`): 包含在 `arr1` 或 `arr2` 中存在但不同时存在于两者中的元素的数组，基于自定义的相等性函数。
+
+## 示例
+
+```typescript
+// 返回 [{ id: 1 }, { id: 3 }]
+xorWith([{ id: 1 }, { id: 2 }], [{ id: 2 }, { id: 3 }], (a, b) => a.id === b.id);
+```
--- a/docs/zh_hans/reference/array/zip.md
+++ b/docs/zh_hans/reference/array/zip.md
@ -0,0 +1,38 @@
+# zip
+
+将多个数组组合成一个元组数组。
+
+该函数接受多个数组作为输入，并返回一个新数组，其中每个元素都是一个元组，包含来自输入数组的对应元素。
+
+如果输入数组的长度不同，结果数组的长度将取决于最长的输入数组，缺失的元素将用 `undefined` 值填充。
+
+## 签名
+
+```typescript
+function zip<T>(arr1: T[]): [T][];
+function zip<T, U>(arr1: T[], arr2: U[]): [T, U][];
+function zip<T, U, V>(arr1: T[], arr2: U[], arr3: V[]): [T, U, V][];
+function zip<T, U, V, W>(arr1: T[], arr2: U[], arr3: V[], arr4: W[]): [T, U, V, W][];
+function zip<T>(...arrs: T[][]): T[][];
+```
+
+### 参数
+
+- `...arrs` (`T[][]`): 要合并的数组。
+
+### 返回值
+
+(`T[][]`): 包含来自输入数组的对应元素的新数组，每个元素都是一个元组。
+
+## 示例
+
+```typescript
+const arr1 = [1, 2, 3];
+const arr2 = ['a', 'b', 'c'];
+const result = zip(arr1, arr2);
+// result 将会是 [[1, 'a'], [2, 'b'], [3, 'c']]
+
+const arr3 = [true, false];
+const result2 = zip(arr1, arr2, arr3);
+// result2 将会是 [[1, 'a', true], [2, 'b', false], [3, 'c', undefined]]
+```
--- a/docs/zh_hans/reference/array/zipObject.md
+++ b/docs/zh_hans/reference/array/zipObject.md
@ -0,0 +1,41 @@
+# zipObject
+
+将两个数组合并为一个对象，一个数组包含属性名称，另一个数组包含对应的值。
+
+该函数接受两个数组作为输入：一个包含属性名称，另一个包含相应的值。它返回一个新对象，其中第一个数组中的属性名称作为键，第二个数组中对应的元素作为值。
+
+如果 `keys` 数组的长度大于 `values` 数组的长度，则剩余的键将具有 `undefined` 作为它们的值。
+
+## 签名
+
+```typescript
+function zipObject<P extends string | number | symbol, V>(keys: P[], values: V[]): { [K in P]: V };
+```
+
+### 参数
+
+- `keys` (`P[]`): 属性名称的数组。
+- `values` (`V[]`): 与属性名称对应的值的数组。
+
+### 返回值
+
+(`{ [K in P]: V }`): 由给定的属性名称和值组成的新对象。
+
+## 示例
+
+```typescript
+const keys = ['a', 'b', 'c'];
+const values = [1, 2, 3];
+const result = zipObject(keys, values);
+// result 将会是 { a: 1, b: 2, c: 3 }
+
+const keys2 = ['a', 'b', 'c'];
+const values2 = [1, 2];
+const result2 = zipObject(keys2, values2);
+// result2 将会是 { a: 1, b: 2, c: undefined }
+
+const keys3 = ['a', 'b'];
+const values3 = [1, 2, 3];
+const result3 = zipObject(keys3, values3);
+// result3 将会是 { a: 1, b: 2 }
+```
--- a/docs/zh_hans/reference/array/zipWith.md
+++ b/docs/zh_hans/reference/array/zipWith.md
@ -0,0 +1,49 @@
+# zipWith
+
+将多个数组使用自定义组合函数合并为单个数组。
+
+该函数接受多个数组和一个组合函数，并返回一个新数组，其中每个元素是将组合函数应用于输入数组的对应元素的结果。
+
+## 签名
+
+```typescript
+function zipWith<T, R>(arr1: T[], combine: (item: T) => R): R[];
+function zipWith<T, U, R>(arr1: T[], arr2: U[], combine: (item1: T, item2: U) => R): R[];
+function zipWith<T, U, V, R>(arr1: T[], arr2: U[], arr3: V[], combine: (item1: T, item2: U, item3: V) => R): R[];
+function zipWith<T, U, V, W, R>(
+  arr1: T[],
+  arr2: U[],
+  arr3: V[],
+  arr4: W[],
+  combine: (item1: T, item2: U, item3: V, item4: W) => R
+): R[];
+```
+
+### 参数
+
+- `arr1` (`T[]`): 第一个要合并的数组。
+- `arr2` (`U[]`, 可选): 第二个要合并的数组。
+- `arr3` (`V[]`, 可选): 第三个要合并的数组。
+- `arr4` (`W[]`, 可选): 第四个要合并的数组。
+- `combine` (`(item1: T, item2: U, item3: V, item4: W) => R`): 接受每个数组对应元素并返回单个值的组合函数。
+
+### 返回值
+
+(`R[]`): 一个新数组，其中每个元素是将组合函数应用于输入数组的对应元素的结果。
+
+## 示例
+
+```typescript
+// 与两个数组一起使用的示例：
+const arr1 = [1, 2, 3];
+const arr2 = [4, 5, 6];
+const result = zipWith(arr1, arr2, (a, b) => a + b);
+// result 将会是 [5, 7, 9]
+
+// 与三个数组一起使用的示例：
+const arr1 = [1, 2];
+const arr2 = [3, 4];
+const arr3 = [5, 6];
+const result = zipWith(arr1, arr2, arr3, (a, b, c) => `${a}${b}${c}`);
+// result 将会是 ['135', '246']
+```
--- a/docs/zh_hans/reference/function/debounce.md
+++ b/docs/zh_hans/reference/function/debounce.md
@ -0,0 +1,62 @@
+# debounce
+
+创建一个防抖函数，它会延迟调用提供的函数，直到距离上次调用已过去 `debounceMs` 毫秒为止。
+
+防抖函数还具有一个 `cancel` 方法，用于取消任何待定的执行。
+
+## 签名
+
+```typescript
+function debounce<F extends (...args: any[]) => void>(
+  func: F,
+  debounceMs: number,
+  options?: DebounceOptions
+): F & { cancel: () => void };
+```
+
+### 参数
+
+- `func` (`F`): 要进行防抖处理的函数。
+- `debounceMs` (`number`): 延迟执行的毫秒数。
+- `options` (`DebounceOptions`, 可选): 一个选项对象。
+  - `signal` (`AbortSignal`, 可选): 可选的 `AbortSignal` 对象，用于取消防抖函数的执行。
+
+### 返回值
+
+(`F & { cancel: () => void }`): 一个带有 `cancel` 方法的新的防抖函数。
+
+## 示例
+
+### 基本用法
+
+```typescript
+const debouncedFunction = debounce(() => {
+  console.log('Function executed');
+}, 1000);
+
+// 如果在此期间没有再次调用，则在1秒后输出 'Function executed'
+debouncedFunction();
+
+// 前一个调用被取消，因此不会记录任何内容
+debouncedFunction.cancel();
+```
+
+### 使用 AbortSignal
+
+```typescript
+const controller = new AbortController();
+const signal = controller.signal;
+const debouncedWithSignalFunction = debounce(
+  () => {
+    console.log('Function executed');
+  },
+  1000,
+  { signal }
+);
+
+// 如果在此期间没有再次调用，则在1秒后输出 'Function executed'
+debouncedWithSignalFunction();
+
+// 取消了防抖函数的调用
+controller.abort();
+```
--- a/docs/zh_hans/reference/function/noop.md
+++ b/docs/zh_hans/reference/function/noop.md
@ -0,0 +1,28 @@
+# noop
+
+一个什么也不做的空操作函数。可以用作占位符或默认函数。
+
+## 签名
+
+```typescript
+function noop(): void;
+```
+
+### 返回值
+
+(`void`): 此函数不返回任何内容。
+
+## 示例
+
+```typescript
+import { noop } from 'es-toolkit/function';
+
+interface Props {
+  onChange?: () => void;
+}
+
+function MyComponent({ onChange = noop }: Props) {
+  // 这里的 onChange 是一个函数，因此可以放心调用它。
+  onChange();
+}
+```
--- a/docs/zh_hans/reference/function/once.md
+++ b/docs/zh_hans/reference/function/once.md
@ -0,0 +1,31 @@
+# once
+
+创建一个函数，限制只能调用提供的函数 `func` 一次。
+
+对该函数的重复调用会返回第一次调用时的结果。
+
+## 签名
+
+```typescript
+function once<F extends () => any>(func: F): F;
+```
+
+### 参数
+
+- `func` (`F extends () => any`): 要限制的函数。
+
+### 返回值
+
+(`F`): 调用 `func` 一次并缓存结果的新函数。
+
+## 示例
+
+```typescript
+const initialize = once(() => {
+  console.log('Initialized!');
+  return true;
+});
+
+initialize(); // 输出：'Initialized!' 并返回 true
+initialize(); // 返回 true，但不会再输出
+```
--- a/docs/zh_hans/reference/function/throttle.md
+++ b/docs/zh_hans/reference/function/throttle.md
@ -0,0 +1,39 @@
+# throttle
+
+创建一个节流函数，每隔 `throttleMs` 毫秒最多调用一次提供的函数。
+
+在等待时间内，对节流函数的后续调用不会触发原始函数的执行。
+
+## 签名
+
+```typescript
+function throttle<F extends (...args: any[]) => void>(func: F, throttleMs: number): F;
+```
+
+### 参数
+
+- `func` (`F`): 要节流的函数。
+- `throttleMs` (`number`): 节流执行的毫秒数。
+
+### 返回值
+
+(`F`): A new throttled function.
+
+## 示例
+
+```typescript
+const throttledFunction = throttle(() => {
+  console.log('Function executed');
+}, 1000);
+
+// 立即输出 'Function executed'
+throttledFunction();
+
+// 由于在节流时间内，不会输出任何内容
+throttledFunction();
+
+// 1秒后
+setTimeout(() => {
+  throttledFunction(); // 输出 'Function executed'
+}, 1000);
+```
--- a/docs/zh_hans/reference/math/clamp.md
+++ b/docs/zh_hans/reference/math/clamp.md
@ -0,0 +1,33 @@
+# clamp
+
+将一个数字限制在指定的包含边界内。
+
+该函数接受一个数字和两个边界，并返回将数字限制在指定边界内的结果。
+
+如果只提供一个边界，则返回值与该边界和值的最小值相同。
+
+## 签名
+
+```typescript
+function clamp(value: number, maximum: number): number;
+function clamp(value: number, minimum: number, maximum: number): number;
+```
+
+### 参数
+
+- `value` (`number`): 要限制的数字。
+- `minimum` (`number`): 限制的最小边界。
+- `maximum` (`number`): 限制的最大边界。
+
+### 返回值
+
+(`number`): 在指定边界内的限制后的数字。
+
+## 示例
+
+```typescript
+const result1 = clamp(10, 5); // result1 将为 5，因为 10 被限制在边界 5 上
+const result2 = clamp(10, 5, 15); // result2 将为 10，因为它在边界 5 和 15 内
+const result3 = clamp(2, 5, 15); // result3 将为 5，因为 2 被限制在较低边界 5 上
+const result4 = clamp(20, 5, 15); // result4 将为 15，因为 20 被限制在较高边界 15 上
+```
--- a/docs/zh_hans/reference/math/inRange.md
+++ b/docs/zh_hans/reference/math/inRange.md
@ -0,0 +1,32 @@
+# inRange
+
+检查值是否在指定范围内。
+
+## 签名
+
+```typescript
+export function inRange(value: number, maximum: number): boolean;
+export function inRange(value: number, minimum: number, maximum: number): boolean;
+```
+
+### 参数
+
+- `value` (`number`): 要检查的值。
+- `minimum` (`number`): 范围的下限（包含在内）。
+- `maximum` (`number`): 范围的上限（不包含在内）。
+
+### 返回值
+
+(`boolean`): 如果值在指定范围内返回 `true`，否则返回 `false`。
+
+### 抛出异常
+
+如果 `minimum` 大于等于 `maximum`，会抛出错误。
+
+## 示例
+
+```typescript
+const result1 = inRange(3, 5); // result1 将为 true。
+const result2 = inRange(1, 2, 5); // result2 将为 false。
+const result3 = inRange(1, 5, 2); // 如果最小值大于等于最大值，会抛出错误。
+```
--- a/docs/zh_hans/reference/math/mean.md
+++ b/docs/zh_hans/reference/math/mean.md
@ -0,0 +1,27 @@
+# mean
+
+计算数字数组的平均值。
+
+如果数组为空，则此函数返回 `NaN`。
+
+## 签名
+
+```typescript
+function mean(nums: number[]): number;
+```
+
+### 参数
+
+- `nums` (`number[]`): 要计算平均值的数字数组。
+
+### 返回值
+
+(`number`): 数组中所有数字的平均值。
+
+## 示例
+
+```typescript
+const numbers = [1, 2, 3, 4, 5];
+const result = mean(numbers);
+// result 将会是 3
+```
--- a/docs/zh_hans/reference/math/meanBy.md
+++ b/docs/zh_hans/reference/math/meanBy.md
@ -0,0 +1,27 @@
+# meanBy
+
+计算数字数组的平均值，通过对每个元素应用 `getValue` 函数来选择数值。
+
+如果数组为空，则此函数返回 `NaN`。
+
+## 签名
+
+```typescript
+export function meanBy<T>(items: T[], getValue: (element: T) => number): number;
+```
+
+### 参数
+
+- `items` (`T[]`): 要计算平均值的数组。
+- `getValue` (`(item: T) => number`): 从每个元素选择数值的函数。
+
+### 返回值
+
+(`number`): 根据 `getValue` 函数确定的所有数值的平均值。
+
+## 示例
+
+```typescript
+meanBy([{ a: 1 }, { a: 2 }, { a: 3 }], x => x.a); // 返回: 2
+meanBy([], x => x.a); // 返回: NaN
+```
--- a/docs/zh_hans/reference/math/random.md
+++ b/docs/zh_hans/reference/math/random.md
@ -0,0 +1,29 @@
+# random
+
+生成指定范围内的随机数。该数可以是整数或小数。
+
+如果只提供一个参数，则返回在 `0` 到给定数之间的随机数。
+
+## 签名
+
+```typescript
+function random(maximum: number): number;
+function random(minimum: number, maximum: number): number;
+```
+
+### 参数
+
+- `minimum` (`number`): 随机数的下限（包含）。
+- `maximum` (`number`): 随机数的上限（不包含）。
+
+### 返回值
+
+- (`number`): 指定范围内的随机数。该数可以是整数或小数。
+
+## 示例
+
+```typescript
+const result1 = random(0, 5); // 返回一个在 0 到 5 之间的随机数。
+const result2 = random(5, 0); // 如果最小值大于最大值，则会抛出错误。
+const result3 = random(5, 5); // 如果最小值等于最大值，则会抛出错误。
+```
--- a/docs/zh_hans/reference/math/randomInt.md
+++ b/docs/zh_hans/reference/math/randomInt.md
@ -0,0 +1,29 @@
+# randomInt
+
+生成指定范围内的随机整数。
+
+如果只提供一个参数，则返回一个在 `0` 到给定数之间的随机整数。
+
+## 签名
+
+```typescript
+function randomInt(maximum: number): number;
+function randomInt(minimum: number, maximum: number): number;
+```
+
+### 参数
+
+- `minimum` (`number`): 随机整数的下限（包含）。
+- `maximum` (`number`): 随机整数的上限（不包含）。
+
+### 返回值
+
+- (`number`): A random integer within the specified range.
+
+## 示例
+
+```typescript
+const result1 = randomInt(0, 5); // 返回一个在 0 到 5 之间的随机整数。
+const result2 = randomInt(5, 0); // 如果最小值大于最大值，则会抛出错误。
+const result3 = randomInt(5, 5); // 如果最小值等于最大值，则会抛出错误。
+```
--- a/docs/zh_hans/reference/math/range.md
+++ b/docs/zh_hans/reference/math/range.md
@ -0,0 +1,42 @@
+# range
+
+返回一个从 `start` 到 `end` 的数字数组，步长为 `step`。
+
+如果未提供 `step` 参数，则默认为 `1`。注意，`step` 必须是一个非零整数。
+
+## 签名
+
+```typescript
+function range(end: number): number[];
+function range(start: number, end: number): number[];
+function range(start: number, end: number, step: number): number[];
+```
+
+### 参数
+
+- `start` (`number`): 数字范围的起始值（包含）。
+- `end` (`number`): 数字范围的结束值（不包含）。
+- `step` (`number`): 数字范围的步长值（默认为 `1`）。
+
+### 返回值
+
+- (`number[]`): 从 `start` 到 `end` 的数字数组，使用指定的 `step`。
+
+## 示例
+
+```typescript
+// 返回 [0, 1, 2, 3]
+range(4);
+
+// 返回 [0, 5, 10, 15]
+range(0, 20, 5);
+
+// 返回 [0, 5, 10, 15, 20]
+range(0, 21, 5);
+
+// 返回 [0, -1, -2, -3]
+range(0, -4, -1);
+
+// 抛出错误：步长值必须是非零整数。
+range(1, 4, 0);
+```
--- a/docs/zh_hans/reference/math/round.md
+++ b/docs/zh_hans/reference/math/round.md
@ -0,0 +1,29 @@
+# round
+
+将一个数字四舍五入到指定的精度。
+
+该函数接受一个数字和一个可选的精度值，返回将数字四舍五入到指定小数位数的结果。
+
+## 签名
+
+```typescript
+function round(value: number, precision?: number): number;
+```
+
+### 参数
+
+- value (`number`): 要四舍五入的数字。
+- precision (`number`, 可选): 要四舍五入到的小数位数。默认为 `0`。
+
+### 返回值
+
+(`number`): 四舍五入后的数字。
+
+## 示例
+
+```typescript
+const result1 = round(1.2345); // result1 将会是 1
+const result2 = round(1.2345, 2); // result2 将会是 1.23
+const result3 = round(1.2345, 3); // result3 将会是 1.235
+const result4 = round(1.2345, 3.1); // 这将会抛出一个错误
+```
--- a/docs/zh_hans/reference/math/sum.md
+++ b/docs/zh_hans/reference/math/sum.md
@ -0,0 +1,27 @@
+# sum
+
+计算一个数字数组的总和。
+
+该函数接受一个数字数组，并返回数组中所有元素的总和。
+
+## 签名
+
+```typescript
+function sum(nums: number[]): number;
+```
+
+### 参数
+
+- `nums` (`number[]`): 要求和的数字数组。
+
+### 返回值
+
+(`number`): 数组中所有数字的总和。
+
+## 示例
+
+```typescript
+const numbers = [1, 2, 3, 4, 5];
+const result = sum(numbers);
+// result 将会是 15
+```
--- a/docs/zh_hans/reference/object/invert.md
+++ b/docs/zh_hans/reference/object/invert.md
@ -0,0 +1,31 @@
+# invert
+
+创建一个通过交换给定对象的键和值而得到的新对象。
+
+该函数接受一个对象，并创建一个新对象，其中原始对象的键变为新对象的值，原始对象的值变为新对象的键。
+
+如果输入对象中存在重复的值，则使用最后出现的键作为新对象的键。
+
+## 签名
+
+```typescript
+function invert<K extends string | number | symbol, V extends string | number | symbol>(
+  obj: Record<K, V>
+): { [key in V]: K };
+```
+
+### 参数
+
+- `obj` (`Record<K, V>`): 要反转的对象。
+
+### 返回值
+
+(`{ [key in V]: K }`): 一个新对象，其键和值被反转了。
+
+## 示例
+
+```typescript
+const obj = { a: 1, b: 1, c: 2 };
+const result = invert(obj);
+// result 将会是 { 1: 'b', 2: 'c' }
+```
--- a/docs/zh_hans/reference/object/omit.md
+++ b/docs/zh_hans/reference/object/omit.md
@ -0,0 +1,28 @@
+# omit
+
+创建一个省略指定键的新对象。
+
+该函数接受一个对象和一个键数组，返回一个新对象，该对象排除了与指定键对应的属性。
+
+## 签名
+
+```typescript
+function omit<T extends Record<string, any>, K extends keyof T>(obj: T, keys: K[]): Omit<T, K>;
+```
+
+### 参数
+
+- `obj` (`T`): 要从中省略键的对象。
+- `keys` (`K[]`): 要从对象中省略的键的数组。
+
+### 返回值
+
+(`Omit<T, K>`): 一个省略了指定键的新对象。
+
+## 示例
+
+```typescript
+const obj = { a: 1, b: 2, c: 3 };
+const result = omit(obj, ['b', 'c']);
+// result 将会是 { a: 1 }
+```
--- a/docs/zh_hans/reference/object/omitBy.md
+++ b/docs/zh_hans/reference/object/omitBy.md
@ -0,0 +1,33 @@
+# omitBy
+
+创建一个新对象，该对象由不满足条件的属性组成。
+
+该函数接受一个对象和一个谓词函数，并返回一个新对象，该对象仅包含条件函数返回 `false` 的属性。
+
+## 签名
+
+```typescript
+function omitBy<T extends Record<string, any>>(
+  obj: T,
+  shouldOmit: (value: T[keyof T], key: keyof T) => boolean
+): Partial<T>;
+```
+
+### 参数
+
+- `obj` (`T`): 要从中省略属性的对象。
+- `shouldOmit` (`(value: T[keyof T], key: keyof T) => boolean`): 一个谓词函数，确定是否应省略属性。
+  它以属性的键和值作为参数，返回 `true` 表示应省略该属性，返回 `false` 表示不应省略。
+
+### 返回值
+
+(`Partial<T>`): 一个由不满足条件的属性组成的新对象。
+
+## 示例
+
+```typescript
+const obj = { a: 1, b: 'omit', c: 3 };
+const shouldOmit = (value, key) => typeof value === 'string';
+const result = omitBy(obj, shouldOmit);
+// result 将会是 { a: 1, c: 3 }
+```
--- a/docs/zh_hans/reference/object/pick.md
+++ b/docs/zh_hans/reference/object/pick.md
@ -0,0 +1,28 @@
+# pick
+
+创建一个由指定属性组成的新对象。
+
+该函数接受一个对象和一个键数组，并返回一个新对象，该对象仅包含与指定键对应的属性。
+
+## 签名
+
+```typescript
+function pick<T extends Record<string, any>, K extends keyof T>(obj: T, keys: K[]): Pick<T, K>;
+```
+
+### 参数
+
+- `obj` (`T`): 要提取属性的对象。
+- `keys` (`K[]`): 要从对象中提取的键数组。
+
+### 返回值
+
+(`Pick<T, K>`): 一个包含了指定键的新对象。
+
+## 示例
+
+```typescript
+const obj = { a: 1, b: 2, c: 3 };
+const result = pick(obj, ['a', 'c']);
+// result 将会是 { a: 1, c: 3 }
+```
--- a/docs/zh_hans/reference/object/pickBy.md
+++ b/docs/zh_hans/reference/object/pickBy.md
@ -0,0 +1,33 @@
+# pickBy
+
+创建一个新对象，该对象由满足条件的属性组成。
+
+该函数接受一个对象和一个谓词函数，并返回一个新对象，该对象仅包含谓词函数返回 `true` 的属性。
+
+## 签名
+
+```typescript
+function pickBy<T extends Record<string, any>>(
+  obj: T,
+  shouldPick: (value: T[keyof T], key: keyof T) => boolean
+): Partial<T>;
+```
+
+### 参数
+
+- `obj` (`T`): 要从中挑选属性的对象。
+- `shouldPick` (`(value: T[keyof T], key: keyof T) => boolean`): 一个谓词函数，确定是否应挑选属性。
+  它以属性的键和值作为参数，返回 `true` 表示应挑选该属性，返回 `false` 表示不应挑选。
+
+### 返回值
+
+(`Partial<T>`): 一个由满足条件的属性组成的新对象。
+
+## 示例
+
+```typescript
+const obj = { a: 1, b: 'pick', c: 3 };
+const shouldPick = (value, key) => typeof value === 'string';
+const result = pickBy(obj, shouldPick);
+// result 将会是 { b: 'pick' }
+```
--- a/docs/zh_hans/reference/predicate/isNil.md
+++ b/docs/zh_hans/reference/predicate/isNil.md
@ -0,0 +1,28 @@
+# isNil
+
+检查给定的值是否为 null 或 undefined。
+
+该函数测试提供的值是否为 `null` 或 `undefined`。
+
+如果值为 `null` 或 `undefined`，则返回 `true`；否则返回 `false`。
+
+该函数在 TypeScript 中还可以作为类型谓词，将参数的类型缩小为 `null` 或 `undefined`。
+
+## 签名
+
+```typescript
+function isNil(x: unknown): x is null | undefined;
+```
+
+## 示例
+
+```typescript
+import { isNil } from 'es-toolkit/predicate';
+
+const value1 = null;
+const value2 = undefined;
+const value3 = 42;
+const result1 = isNil(value1); // true
+const result2 = isNil(value2); // true
+const result3 = isNil(value3); // false
+```
--- a/docs/zh_hans/reference/predicate/isNotNil.md
+++ b/docs/zh_hans/reference/predicate/isNotNil.md
@ -0,0 +1,29 @@
+# isNotNil
+
+检查给定的值是否不为 null 或 undefined。
+
+该函数在 TypeScript 中还可以作为类型谓词，确保参数的类型不可为 null。
+
+## 签名
+
+```typescript
+function isNotNil<T>(x: T | null | undefined): x is T;
+```
+
+### 参数
+
+- `x` (`T | null | undefined`): 要测试的值，检查其是否不为 null 或 undefined。
+
+### 返回值
+
+(`x is T`): 如果值不为 null 或 undefined，则返回 true；否则返回 false。
+
+## 示例
+
+```typescript
+// 在这里 `arr` 的类型是 (number | undefined)[]
+const arr = [1, undefined, 3];
+// `result` 的类型是 number[]
+const result = arr.filter(isNotNil);
+// result 将会是 [1, 3]
+```
--- a/docs/zh_hans/reference/predicate/isNull.md
+++ b/docs/zh_hans/reference/predicate/isNull.md
@ -0,0 +1,35 @@
+# isNull
+
+检查给定的值是否为 null。
+
+该函数测试提供的值是否严格相等于 `null`。
+
+如果值为 `null`，则返回 true；否则返回 false。
+
+在 TypeScript 中，该函数还可以作为类型谓词，将参数的类型缩小为 `null`。
+
+## 签名
+
+```typescript
+function isNull(x: unknown): x is null;
+```
+
+### 参数
+
+- `x` (`unknown`): 要检查是否为 null 的值
+
+### 返回值
+
+(`x is null`): 如果值为 null，则返回 true；否则返回 false。
+
+## 示例
+
+```typescript
+const value1 = null;
+const value2 = undefined;
+const value3 = 42;
+
+console.log(isNull(value1)); // true
+console.log(isNull(value2)); // false
+console.log(isNull(value3)); // false
+```
--- a/docs/zh_hans/reference/predicate/isUndefined.md
+++ b/docs/zh_hans/reference/predicate/isUndefined.md
@ -0,0 +1,35 @@
+# isUndefined
+
+检查给定的值是否为 `undefined`。
+
+该函数测试提供的值是否严格相等于 `undefined`。
+
+如果值为 `undefined`，则返回 true；否则返回 false。
+
+在 TypeScript 中，该函数还可以作为类型谓词，将参数的类型缩小为 `undefined`。
+
+## 签名
+
+```typescript
+function isUndefined(x: unknown): x is undefined;
+```
+
+### 参数
+
+- `x` (`unknown`): 要检查是否为 `undefined` 的值。
+
+### 返回值
+
+(`x is undefined`): 如果值为 `undefined`，则返回 true；否则返回 false。
+
+## 示例
+
+```typescript
+const value1 = undefined;
+const value2 = null;
+const value3 = 42;
+
+console.log(isUndefined(value1)); // true
+console.log(isUndefined(value2)); // false
+console.log(isUndefined(value3)); // false
+```
--- a/docs/zh_hans/reference/promise/delay.md
+++ b/docs/zh_hans/reference/promise/delay.md
@ -0,0 +1,53 @@
+# delay
+
+延迟执行代码指定的毫秒数。
+
+该函数返回一个 Promise，在指定的延迟后解析，可以与 async/await 结合使用来暂停执行。
+
+它还支持一个可选的 AbortSignal 来取消延迟。
+
+## 签名
+
+```typescript
+function delay(ms: number, options?: DelayOptions): Promise<void>;
+```
+
+### 参数
+
+- `ms` (`number`): 要延迟的毫秒数。
+- `options` (`DelayOptions`, 可选): 一个选项对象。
+  - `signal` (`AbortSignal`, 可选): 用于取消延迟的可选 `AbortSignal`。
+
+### 返回值
+
+(`Promise<void>`): 在指定延迟后解析的 Promise。
+
+## 示例
+
+### 基本用法
+
+```typescript
+async function foo() {
+  console.log('Start');
+  await delay(1000); // 延迟执行 1 秒钟
+  console.log('End');
+}
+
+foo();
+```
+
+### 使用 AbortSignal
+
+```typescript
+async function foo() {
+  const controller = new AbortController();
+  const signal = controller.signal;
+
+  setTimeout(() => controller.abort(), 50); // 在 50 毫秒后取消延迟
+  try {
+    await delay(1000, { signal });
+  } catch (error) {
+    console.log(error); // 将会输出 'The operation was aborted'
+  }
+}
+```
--- a/docs/zh_hans/reference/string/snakeCase.md
+++ b/docs/zh_hans/reference/string/snakeCase.md
@ -0,0 +1,32 @@
+# snakeCase
+
+将字符串转换为蛇形命名法（snake case）。
+
+蛇形命名法是一种命名约定，其中每个单词都以小写字母书写，并用下划线（\_）分隔。
+
+例如 `snake_case`。
+
+## 签名
+
+```typescript
+function snakeCase(str: string): string;
+```
+
+### 参数
+
+- `str` (`string`): 要转换为蛇形命名法的字符串。
+
+### 返回值
+
+(`string`) 转换后的蛇形命名法字符串。
+
+## 示例
+
+```typescript
+import { snakeCase } from 'es-toolkit/string';
+
+snakeCase('camelCase'); // 返回  'camel_case'
+snakeCase('some whitespace'); // 返回  'some_whitespace'
+snakeCase('hyphen-text'); // 返回  'hyphen_text'
+snakeCase('HTTPRequest'); // 返回  'http_request'
+```