将十进制数转换为javascript中的分数或最接近的分数

所以我想把任何十进制数转换成分数。在两种形式中，例如没有余数的形式：

3/5

或有余数的形式：

3 1/4

我所做的是

假设我有电话号码3435

• 计算小数后的位数
• 用数字前的量的幂乘以10
• 然后以某种方式找到最大的共同因素

现在我不知道如何找到GCF。我也不知道如何实现逻辑，找到表示一个数字的分数，或者在不存在精确分数的情况下，以余数形式

到目前为止我已经完成的代码：（测试）

---

你的前两个步骤是合理的

但是你应该做的是，让分子和分母计算出，然后用这个除数除以分子和分母，得到你想要的分数

GCD很容易计算。这是：

编辑

---

我添加了一个完全有效的库。

除非您愿意自己开发一些东西，否则我建议您使用一个已经有人投入精力的库，例如

Javascript

var frac = new Fraction(0.3435);

console.log(frac.toString());

输出

687/2000

---

在

上，您可以对不同的分母使用蛮力测试，并保留误差最小的结果

下面的算法是一个示例，说明了如何进行此操作，但是，它效率低下，并且仅限于搜索高达10000的分母

函数find\u rational（值，最大值）{
console.clear（）；
console.log（“查找：+value”）；
设best={分子：1，分母：1，错误：Math.abs（值-1）}
如果（！maxdenom）maxdenom=10000；
对于（让分母=1；best.error>0&&分母=best.error）继续；
最佳。分子=分子；
最佳分母=分母；
best.error=错误；
日志（“中间结果：”
+最佳。分子+“/”+最佳。分母
+（“+（最佳分子/最佳分母）
+“错误”+最佳错误+”）；
}
log（“最终结果：+JSON.stringify（最佳））；
回报最好；
}
函数计算（）{
const value=parseFloat（$（“#myInput”）.val（）；
如果（isNaN（值））{
$（“myResult”）.val（“NaN”）；
返回；
}
const rational=find_rational（值，10000）；
$（“#myResult”）.val（rational.numerator
+“/”+有理分母
+“（错误：“+rational.Error+”）；
}
计算（）


输入十进制数：





结果理性：



棘手的一点是不让浮点运算失控
将数字转换为字符串会限制尾随数字

特别是当你有一个带整数的小数点时，比如1.0625

您可以通过传递精度参数来舍入笨拙的分数

通常，您希望强制向上取整一个值，因此第三个参数可以指定该值

（例如，如果使用的精度为1/64，则非零数的最小返回值将为1/64，而不是0。）

数学圆分数（.3435,64）；值：（字符串）11/32
使用查找最大公约数

function reduce(numerator,denominator){
  var gcd = function gcd(a,b){
    return b ? gcd(b, a%b) : a;
  };
  gcd = gcd(numerator,denominator);
  return [numerator/gcd, denominator/gcd];
}

这将在控制台上为您提供以下结果

reduce(2,4);
// [1,2]

reduce(13427,3413358);
// [463,117702]

所以通过继续你已经拥有的

var x = 34/35;
var a = x - x.toFixed();
var tens = Math.pow(10,a.toString().length - 2);

var numerator = tens * x;
var denominator = tens;

reduce(numerator,denominator);

资料来源：
我16次提出这个

function getfract(theNum){
    var input=theNum.toString();
    var whole = input.split(".")[0];
    var rem = input.split(".")[1] * .1;
    return(whole + " " + Math.round(rem * 16) + "/16");
}

我使用GCD方法得到的结果很差。我使用迭代方法得到了更好的结果

例如，这里有一个非常粗糙的方法，将小数点的分数归零：

function toFraction(x, tolerance) {
    if (x == 0) return [0, 1];
    if (x < 0) x = -x;
    if (!tolerance) tolerance = 0.0001;
    var num = 1, den = 1;

    function iterate() {
        var R = num/den;
        if (Math.abs((R-x)/x) < tolerance) return;

        if (R < x) num++;
        else den++;
        iterate();
    }

    iterate();
    return [num, den];
}

功能牵引（x，公差）{
如果（x==0）返回[0，1]；
如果（x<0）x=-x；
如果（！公差）公差=0.0001；
var num=1，den=1；
函数iterate（）{
var R=数量/单位；
if（数学绝对值（（R-x）/x）<公差）返回；
if（R

其思想是，如果低于该值，则增加分子；如果高于该值，则增加分母。
一种快速简便的方法是

getFraction = (decimal) => {
  for(var denominator = 1; (decimal * denominator) % 1 !== 0; denominator++);
  return {numerator: decimal * denominator, denominator: denominator};
}

我已经研究了整个网站，我把所有的代码合并成一个，给你

function fra_to_dec(num){
    var test=(String(num).split('.')[1] || []).length;
    var num=(num*(10**Number(test)))
    var den=(10**Number(test))
    function reduce(numerator,denominator){
        var gcd = function gcd(a,b) {
            return b ? gcd(b, a%b) : a;
        };
        gcd = gcd(numerator,denominator);
        return [numerator/gcd, denominator/gcd];
    }
    return (reduce(num,den)[0]+"/"+reduce(num,den)[1])
}

这段代码很容易使用！您甚至可以在此函数中输入数字
 这是我买的最快的。没有GCD。适用于至少5个尾随小数

function decToFrac(n)
{
    let rcp = (n%1 == 0) ? 1: 1/(n%1);
    let den = rcp;
    const lim = 10;
    for (let i = 0; i < lim && Number.isInteger(Math.round(rcp * 10**(lim-i)) / 10**(lim-i)) != true; i++)
    {
        rcp = 1/(rcp%1);
        den *= rcp;
    }
    return [Math.round(n*den), Math.round(den)];
}

function impToProp(n, d)
{
    return [Math.floor(n/d), (n%d), d];
}

var dec = 3.141592;
var frac = decToFrac(dec); // improper
var prop = impToProp(frac[0], frac[1]); // proper

函数decToFrac（n）
{
设rcp=（n%1==0）？1:1/（n%1）；
设den=rcp；
常数lim=10；
对于（设i=0；i
然后看一看，您将面临的主要问题是浮点数无法准确处理值（除非所述值恰好是二的幂或二的和）。值得一看吗？0.3435得到了什么？@Xotic750:很明显，分数的本质决定了需要进行极限检查。类似于
if（b<0.0000001）的东西返回agetFraction = (decimal) => {
  for(var denominator = 1; (decimal * denominator) % 1 !== 0; denominator++);
  return {numerator: decimal * denominator, denominator: denominator};
}

function fra_to_dec(num){
    var test=(String(num).split('.')[1] || []).length;
    var num=(num*(10**Number(test)))
    var den=(10**Number(test))
    function reduce(numerator,denominator){
        var gcd = function gcd(a,b) {
            return b ? gcd(b, a%b) : a;
        };
        gcd = gcd(numerator,denominator);
        return [numerator/gcd, denominator/gcd];
    }
    return (reduce(num,den)[0]+"/"+reduce(num,den)[1])
}

function decToFrac(n)
{
    let rcp = (n%1 == 0) ? 1: 1/(n%1);
    let den = rcp;
    const lim = 10;
    for (let i = 0; i < lim && Number.isInteger(Math.round(rcp * 10**(lim-i)) / 10**(lim-i)) != true; i++)
    {
        rcp = 1/(rcp%1);
        den *= rcp;
    }
    return [Math.round(n*den), Math.round(den)];
}

function impToProp(n, d)
{
    return [Math.floor(n/d), (n%d), d];
}

var dec = 3.141592;
var frac = decToFrac(dec); // improper
var prop = impToProp(frac[0], frac[1]); // proper