# fraction\.js 中文文档

规范地址：https://npmcn.com/package/fraction.js/

版本：5\.3\.4
npm 元数据更新时间：2025-08-22T11:44:45.725Z
中文译文更新时间：2026-11-05T16:21:17.381Z
软件包许可：MIT

本文由上游 README 翻译，可能存在偏差，请结合原文核对 API、命令与配置。版权与许可归原作者所有。

原始 npm 页面：https://www.npmjs.com/package/fraction.js
原文对照：https://npmcn.com/package/fraction.js/?lang=original
项目主页：https://raw.org/article/rational-numbers-in-javascript/
源码仓库：https://github.com/rawify/Fraction.js

## 关键信息（来自 npm 元数据）

- 包体积（解压后）：148 kB，21 个文件
- 模块格式：ESM + CJS
- TypeScript 类型：包内自带
- Node.js 要求：\*
- 运行依赖：0 个
- 首次发布：2014-03-12T01:46:09.440Z
- 最新版本发布：2025-08-22T11:44:45.549Z
- 近 30 天下载量：220801944（2026-10-05 至 2026-11-03，npm 官方下载统计）
- 已发布版本数：71（近 12 个月 0 个）

## 中文简介

RAW 合理数字库

## 安装

```sh
npm install fraction.js
```

也可以使用：`pnpm add fraction.js`、`yarn add fraction.js`、`bun add fraction.js`

## README

# 小数.js - Q in JavaScript

[![NPM Package](https://img.shields.io/npm/v/fraction.js.svg?style=flat)](https://npmjs.org/package/fraction.js "View this project on npm") [![MIT license](http://img.shields.io/badge/license-MIT-brightgreen.svg)](http://opensource.org/licenses/MIT)

你是否发现浮点算术的局限性令人沮丧,特别是当像QQ或QX2这样的理性和不合理数字被存储在相同的有限精确度内时? 这可能导致可避免的不准确之处,例如:

```javascript
1 / 98 * 98 // Results in 0.9999999999999999
```

对于需要更精确的应用软件或最好是与分数合作的应用软件,考虑纳入 _小数.js_ 进入你的项目.

图书馆有效处理精准问题,具体如下:

```javascript
Fraction(1).div(98).mul(98) // Returns 1
```

_小数.js_ 使用a `BigInt` 数字分母和分母的表示式,确保最小性能管理费用,同时最大限度地提高准确性。 其设计优化精度,使其成为其他数学工具的基础库的理想选择,例如: [波利诺米亚尔.js](https://github.com/rawify/Polynomial.js) 财务报告和审定财务报表 [数学Js](https://github.com/josdejong/mathjs)。 。 。 .

## 小数转换为分数

其核心特征之一 _小数.js_ 它能够将小数无缝地转换成分数.

```javascript
let x = new Fraction(1.88);
let res = x.toFraction(true); // Returns "1 22/25" as a string
```

这在需要精确分数表示而不是处理浮点算术的局限性时特别有用. 如果你允许一些错误容忍性呢?

```javascript
let x = new Fraction(0.33333);
let res = x.simplify(0.001) // Error < 0.001
       .toFraction(); // Returns "1/3" as a string
```

## 精确度

作为本地人 `BigInt` 在 JavaScript 中支持变得更加常见, 库如 _小数.js_ 用它来更精确地处理计算. 这提高了大量数学操作的速度和准确性,为需要比浮点数更精确的任务提供了更好的解决方案.

## 实例/动机

简单的使用示例 _小数.js_ 也许是这样的:

```javascript
var f = new Fraction("9.4'31'"); // 9.4313131313131...
f.mul([-4, 3]).mod("4.'8'"); // 4.88888888888888...
```

然后,结果可以显示为:

```javascript
console.log(f.toFraction()); // -4154 / 1485
```

此外,还可以访问分数的内部属性,如符号(s),数字(n)和分母(d)等. 请注意,这些值被存储为 `BigInt`数字 :

```javascript
Number(f.s) * Number(f.n) / Number(f.d) = -1 * 4154 / 1485 = -2.797306...
```

如果你试图用浮点算术手动计算, 你会得到一些类似的东西:

```javascript
(9.4313131 * (-4 / 3)) % 4.888888 = -2.797308133...
```

虽然结果相当接近 _小数.js_ 提供,特别是在处理重复小数或复杂操作时。 这突出说明了图书馆带来的精确性的价值.

### 位置概率

这里有一个简单的例子是使用 _小数.js_ 用于计算概率。 让我们来决定 在一个公平的死亡中 产生一个特定结果的可能性:

-   **P({3}) (中文(简体) )**: 滚动 a 3. 的概率.
-   **P({1、4}) (中文(简体) )**: 滚动1或4的概率.
-   **P({2, 4, 6} )**: 第2,4或6个滚动的概率.

#### P( {3} ) :

```javascript
var p = new Fraction([3].length, 6).toString(); // "0.1(6)"
```

#### P({1、4}) :

```javascript
var p = new Fraction([1, 4].length, 6).toString(); // "0.(3)"
```

#### P({2, 4, 6}) :

```javascript
var p = new Fraction([2, 4, 6].length, 6).toString(); // "0.5"
```

### 将度/分/秒转换成精确的合理表示 :

57+45/60+17/3600 (中文(简体) )

```javascript
var deg = 57; // 57°
var min = 45; // 45 Minutes
var sec = 17; // 17 Seconds

new Fraction(deg).add(min, 60).add(sec, 3600).toString() // -> 57.7547(2)
```

### 非理性数字的合理近似

大致数字像 _sqrt(5) - 2 (中文(简体) )_ 用一个数字和分母,可以重构等式如下: _pow(n / d + 2, 2)=5_。 。 。 .

然后,以下算法将生成除二进制表示外的理性数字.

```javascript
var x = "/", s = "";

var a = new Fraction(0),
    b = new Fraction(1);
for (var n = 0; n <= 10; n++) {

  var c = a.add(b).div(2);

  console.log(n + "\t" + a + "\t" + b + "\t" + c + "\t" + x);

  if (c.add(2).pow(2).valueOf() < 5) {
    a = c;
    x = "1";
  } else {
    b = c;
    x = "0";
  }
  s+= x;
}
console.log(s)
```

结果是

```
n   a[n]        b[n]        c[n]            x[n]
0   0/1         1/1         1/2             /
1   0/1         1/2         1/4             0
2   0/1         1/4         1/8             0
3   1/8         1/4         3/16            1
4   3/16        1/4         7/32            1
5   7/32        1/4         15/64           1
6   15/64       1/4         31/128          1
7   15/64       31/128      61/256          0
8   15/64       61/256      121/512         0
9   15/64       121/512     241/1024        0
10  241/1024    121/512     483/2048        1
```

因此,比分法11次重复后的近似值是 _483 / 2048 (英语)_ 二进制代表为0.0011100011(参见 [沃尔夫拉姆阿尔法](http://www.wolframalpha.com/input/?i=sqrt%285%29-2+binary)(中文(简体) )

我出版了另一个例子 如何将PI 与分数相近 [博客](https://raw.org/article/rational-numbers-in-javascript/) (仍然不是估计非理性数字的最佳想法,但它完美地说明了Fraction.js的能力).

### 获取数字的确切分数部分

```javascript
var f = new Fraction("-6.(3416)");
console.log(f.mod(1).abs().toFraction()); // = 3416/9999
```

### 数学正确的模组

负面相容性上的行为不同于计算机科学中大多数modulo执行. 甚至连 _模式( )_ fallaction.js 的功能以典型的方式进行。 解决用分数来调制数学正确调制的问题. 你可以想出这个:

```javascript
var a = -1;
var b = 10.99;

console.log(new Fraction(a)
  .mod(b)); // Not correct, usual Modulo

console.log(new Fraction(a)
  .mod(b).add(b).mod(b)); // Correct! Mathematical Modulo
```

## fmod () 不精确被绕过

结果Fraction.js几乎超越了任何fmod () 执行,包括JavaScript本身, [页:1](http://phpjs.org/functions/fmod/), C++, Python, Java 乃至 Wolframalpha 由于数字如 0.05, 0.1, . 在 Base 2 中是无限小数.

方程式 _fmod (4.55, 0.05) (中文(简体) )_ 给 _0.049999999999997_狼拉玛法说 _第1/20号决议_正确答案应该是: **零**,作为0.05除以4.55,没有任何剩余.

## 解析器

任何函数(见下文)以及 _分数_ class 解析其输入并将其缩小为最小的术语.

可以通过矩阵、对象、整数、双数或字符串.

### 矩阵/ 对象

```javascript
new Fraction(numerator, denominator);
new Fraction([numerator, denominator]);
new Fraction({n: numerator, d: denominator});
```

### 整数

```javascript
new Fraction(123);
```

### 双倍

```javascript
new Fraction(55.4);
```

**说明:** 如果你通过一个双倍的原样,Fraction.js会根据法雷序列进行数字分析. 如果涉及性能,缓存分数.js对象和通过数组/对象.

这种方法确实准确,但准确数字太高,如1234567.9991829将会导致错误的近似. 如果您想要保持原样的数字, 请将其转换为字符串, 因为字符串解析器不会执行任何进一步的观察 。 如果您对近似有问题, 在文件中 `examples/approx.js` 是一种不同的近似算法,在某些更具体的使用案中,它可能效果更好.

### 字符串

```javascript
new Fraction("123.45");
new Fraction("123/45"); // A rational number represented as two decimals, separated by a slash
new Fraction("123:45"); // A rational number represented as two decimals, separated by a colon
new Fraction("4 123/45"); // A rational number represented as a whole number and a fraction
new Fraction("123.'456'"); // Note the quotes, see below!
new Fraction("123.(456)"); // Note the brackets, see below!
new Fraction("123.45'6'"); // Note the quotes, see below!
new Fraction("123.45(6)"); // Note the brackets, see below!
```

### 两项论点

```javascript
new Fraction(3, 2); // 3/2 = 1.5
```

### 重复小数位数

_小数.js_ 很容易处理重复小数位。 举个例子 _1/3 (英语)_ 实值 _0.3333号..._。只有一个重复数字。 从上面的例子可以看出,你可以通过一个数字,比如: _1/3 (英语)_ 作为"0.'3"或"0.(3)",两者同义. 没有测试来分析类似0.166666666至1/6. 如果您真的想要处理这个数字, 请用下面的函数将括号自己围入: 0.1( 6666666)

假设您想要分割 123.32 / 33.6 (567) . [沃尔夫拉姆阿尔法](http://www.wolframalpha.com/input/?i=123.32+%2F+%2812453%2F370%29) 说你会得到一个1776个数字的时期. _小数.js_ 得出同样的结果。 试试看:

```javascript
var f = new Fraction("123.32");
console.log("Bam: " + f.div("33.6(567)"));
```

要自动制作像"0.123123"这样的数字到"0.123"这样的更友好的Fraction.js,我在10分钟内黑入了这个"0.(123)"的"小野蛮力算法". 欢迎改进...

```javascript
function formatDecimal(str) {

  var comma, pre, offset, pad, times, repeat;

  if (-1 === (comma = str.indexOf(".")))
    return str;

  pre = str.substr(0, comma + 1);
  str = str.substr(comma + 1);

  for (var i = 0; i < str.length; i++) {

    offset = str.substr(0, i);

    for (var j = 0; j < 5; j++) {

      pad = str.substr(i, j + 1);

      times = Math.ceil((str.length - offset.length) / pad.length);

      repeat = new Array(times + 1).join(pad); // Silly String.repeat hack

      if (0 === (offset + repeat).indexOf(str)) {
        return pre + offset + "(" + pad + ")";
      }
    }
  }
  return null;
}

var f, x = formatDecimal("13.0123123123"); // = 13.0(123)
if (x !== null) {
  f = new Fraction(x);
}
```

## 属性

分数对象允许直接访问数字,分母和签名属性. 确保只有标志属性才有标志信息,因此只需对照该属性进行标志比较即可.

```javascript
var f = new Fraction('-1/2');
console.log(f.n); // Numerator: 1
console.log(f.d); // Denominator: 2
console.log(f.s); // Sign: -1
```

## 职能

### 分数 abs ()

返回没有符号信息的实际数字

### 分数 neg ()

以翻转的标志返回实际数字,以便获得添加剂倒数

### 分数加法(n)

返回实际数字和参数n的总和

### 小数子(n)

返回实际数字与参数n的相差

### 分数 mul(n)

返回实际数字和参数n的产物

### 分数 div(n)

返回实际数字和参数n的商数

### 分数 pow( 实例)

返回实际数字的功率,升格为可能的理性表示. 如果结果变为不合理,函数返回 `null`。 。 。 .

### 小数日志( 基数)

将实际数字的对数返回到给定的合理基数。 如果结果变为不合理,函数返回 `null`。 。 。 .

### 小数模式(n)

返回实际对象和n(这个% n)的模数(除法的后缀)。 更准确一点 [fmod () (英语)](https://npmcn.com/package/fraction.js/#readme-fmod-impreciseness-circumvented) 如果你喜欢。 请注意: _模式( )_ 就像大多数编程语言的 modulo 操作员。 如果你想要一个数学正确的模组,看 [这里](https://npmcn.com/package/fraction.js/#readme-mathematical-correct-modulo)。 。 。 .

### 小数模式( )

返回实际对象(数字调分母)的模数(除法的后缀)

### 分数 gcd(n)

返回分数最大常见分数

### 分数lcm(n)

返回分数最小的常见倍数

### 小数头( \[位置=0-16\])

用 Math.ceil 返回一个合理数字的上限

### 小数层(\[位置=0-16\])

返回带有 Math.floor 的合理数字的下限

### 分数圆( \[位置=0-16\])

返回以 Math.round 为圆的理性数字

### 分数回合到( 多个)

将分数绕入另一分数中最接近的倍数.

### 分数倒数( )

返回实际数字的相乘倒数( n / d 为 d / n) 以获得对数

### 分数简化(\[eps=.001\])

在一定出错阈值下简化理性数. ex. (英语). `0.333` 将会是 `1/3` 与 `eps=0.001`

### 布尔等值(n)

检查两个合理数字是否相等

### 布尔 lt( n)

检查这个合理数字是否比另一个小

### 布尔lte(n)

检查此合理数字是否小于或等于另一个

### 布尔克特( n)

检查这个合理数字是否大于另一个

### 布尔克特( n)

检查此合理数字是否大于或等于另一个

### 英寸比较(n)

比较两个数字.

```
result < 0: n is greater than actual number
result > 0: n is smaller than actual number
result = 0: n is equal to the actual number
```

### 布尔分光度(n)

检查两个数字是否可分辨( n除以此)

### 双值 Of ()

返回该分数的小数代表

### 字符串到 String( \[小数点后位置=15\])

生成给定对象的精确字符串表示。 对于重复的小数位数,重复周期内的数位数被括号内,例如:, `1/3 = "0.(3)"`。对于其他数字,字符串将包含最多到指定的 `decimalPlaces` 数字,包括发生切换时的后缀零。 譬如说, `1/2` 将按 `"0.5"`,不添加后缀零.

**说明:** 由于两者 `valueOf()` 财务报告和审定财务报表 `toString()` 提供, `toString()` 只当对象在字符串上下文中被使用时,才会被隐含地引用。 例如,当使用加号运算符时 `"123" + new Fraction`, (中文(简体) ), `valueOf()` 将首先被称作,因为JavaScript试图先将原始人组合起来,然后将其相容,弦类型优先。 不过, `alert(new Fraction)` 或者说 `String(new Fraction)` 将如所愿。 为保证特定行为,明确调用任一 `toString()` 或者说 `valueOf()`。 。 。 .

### 字符串为Latex( 显示混合=虚假)

生成实际对象的精确的 LaTeX 表示. 你可以看到一个 [现场演示](https://raw.org/article/rational-numbers-in-javascript/) 在我的博客上.

可选布尔参数表示要显示混合分数。 "一一三"取而代之"四相"

### 字符串为 Fraction( 显示混合=虚假)

获得分数的字符串代表

可选布尔参数表示要显示混合分数。 "一一三"取而代之"四相"

### 继续排列( C)

获得分数的数组作为继续分数。 第一个元素总是包含整个部分.

```javascript
var f = new Fraction('88/33');
var c = f.toContinued(); // [2, 1, 2]
```

### 小数克隆( )

创建实际分数对象的副本

## 例外

如果发生真的硬错误( 解析错误, 除以 0) , _小数.js_ 抛出例外! 请确保你正确处理它们.

## 安装

您可以安装 `Fraction.js` 通过 npm :

```bash
npm install fraction.js
```

或用纱线:

```bash
yarn add fraction.js
```

或者,下载或复制存储器:

```bash
git clone https://github.com/rawify/Fraction.js
```

## 使用量

包含 `fraction.min.js` 在工程中的文件 :

```html
<script src="path/to/fraction.min.js"></script>
<script>
  var x = new Fraction("13/4");
</script>
```

或者在Node.js项目中:

```javascript
const Fraction = require('fraction.js');
```

或者说

```javascript
import Fraction from 'fraction.js';
```

## 编码样式

正如我所出版的每一个库一样,Finaction.js在用Google关闭编译器以高级模式进行压缩后,也会被建成尽可能小. 因此,编码样式对压缩速率进行一些优化。 请确保保持这种风格 如果你计划扩展库.

## 建设图书馆

克隆后 Git 仓库运行 :

```bash
npm install
npm run build
```

## 运行测试

对照运出测试套件对源进行测试,就如同

```bash
npm run test
```

## 版权和许可证发放

版权(c)2025, [罗伯特·艾瑟尔](https://raw.org/) 持有麻省理工学院执照.

## 常见问题

### fraction\.js 是什么？

RAW 合理数字库

### 如何安装 fraction\.js？

在项目目录运行 npm install fraction\.js，或使用 pnpm add / yarn add / bun add。

### fraction\.js 支持 TypeScript 吗？

支持。包内自带 TypeScript 类型声明（package\.json 声明了 types 入口），安装后即可获得类型提示，无需再安装 @types 包。

### fraction\.js 支持 ESM 还是 CommonJS？

同时提供 ES Module 与 CommonJS 入口，import 和 require\(\) 都可以使用，打包工具会自动选择合适的版本。

### fraction\.js 需要什么版本的 Node\.js？

package\.json 的 engines 字段要求 Node\.js \*。版本不符时 npm 默认只给出警告，开启 engine-strict 后会拒绝安装。

### fraction\.js 可以商用吗？

fraction\.js 使用 MIT 许可。宽松许可：允许商业使用、修改和再分发，通常只需在分发时保留原版权与许可声明。以上为概括，不构成法律意见，请以许可原文为准。

### fraction\.js 的下载量有多少？

根据 npm 官方下载统计，fraction\.js 在 2026/10/05 – 2026/11/03 这 30 天内被下载 220,801,944 次，日均约 7,360,065 次。下载量会把 CI 构建、镜像同步和作为其他包依赖的安装一并计入，适合横向比较热度，不能直接等同于使用人数。

### fraction\.js 还在维护吗？

最新版本 5\.3\.4 发布于 2025/08/22（1\.2 年前）；至今共发布 71 个版本，其中过去 12 个月发布了 0 个；首次发布于 2014/03/12。发布频率只是参考信号：功能稳定的工具可能很少需要更新，建议结合源码仓库的 issue 和提交记录判断。

