Javascript 根据大小将数字动态舍入到小数点后n位

我需要一个函数，它接受一个计算值（可以从非常小到非常大），并将其舍入到小数位数以供显示。小数位数应该取决于输入的大小，因此我不能只使用

.toFixed（n）

之类的东西，因为

n

是未知的

我提出了以下建议，但感觉有更好的方法：

function format_output(output) {
    if (output > 10000) {
        output = output.toFixed(0);
} else {
        if (output > 100 && output < 10000) {
        output = output.toFixed(1);
    } else {
            if (output>1 && output <100) {
                output = output.toFixed(3);
    } else {
        // repeat as necessary
    }
return output;
}

函数格式\u输出（输出）{
如果（输出>10000）{
输出=output.toFixed（0）；
}否则{
如果（输出>100&&输出<10000）{
输出=output.toFixed（1）；
}否则{
如果（输出>1&&output符合您的要求，您应该研究科学符号

output.toExponential();

如果您不想使用科学记数法，请尝试以下方法：

function format_output(output) {
    var n =  Math.log(output) / Math.LN10;
    var x = 4-n;
    if(x<0)
        x=0;
    output = output.toFixed(x);
    return output;
}

函数格式\u输出（输出）{
var n=Math.log（输出）/Math.LN10；
var x=4-n；
如果（x符合你的要求，你应该研究科学记数法

output.toExponential();

如果您不想使用科学记数法，请尝试以下方法：

function format_output(output) {
    var n =  Math.log(output) / Math.LN10;
    var x = 4-n;
    if(x<0)
        x=0;
    output = output.toFixed(x);
    return output;
}

函数格式\u输出（输出）{
var n=Math.log（输出）/Math.LN10；
var x=4-n；
如果（x您似乎希望将该值限制为5个有效数字。下面针对有限的值范围（99999到0.00001）执行此操作，您可以解决如何对其余值执行此操作。请注意，在某些旧浏览器中，某些值可能存在舍入错误

  <input onchange="
    var bits = this.value.split('.');
    var places = 5 - bits[0].length;

    if (places < 0) {
      places = 0;

    } else if (bits[0] == 0) {
      places = 5;
    }
    this.value = Number(this.value).toFixed(places); 
  ">

您似乎希望将该值限制为5个有效数字。以下内容针对有限的值范围（99999到0.00001）执行此操作，您可以解决如何对其余值执行此操作。请注意，某些旧浏览器中可能存在某些值的舍入错误

  <input onchange="
    var bits = this.value.split('.');
    var places = 5 - bits[0].length;

    if (places < 0) {
      places = 0;

    } else if (bits[0] == 0) {
      places = 5;
    }
    this.value = Number(this.value).toFixed(places); 
  ">

看起来您确实希望将精度限制在五个位置左右。这样做可能更明确：

var toPrecision = function(precision) {
    return function(nbr) {
        if (typeof nbr !== 'number') return 0; //???
        if (nbr === 0) return 0;
        var abs = Math.abs(nbr);
        var sign = nbr / abs;
        nbr = abs;
        var digits = Math.ceil(Math.log(nbr)/Math.LN10);
        var factor = Math.pow(10, precision - digits);
        var result = nbr * factor;
        result = Math.round(result, 0);
        return result / factor;
    };
};

var format_output = toPrecision(5);

format_output(1234567.89012); // 1234600
format_output(987.654321); // 987.65
format_output(-.00246813579); // -0.0024681

当然，如果愿意，您可以将它们组合成一个双参数函数：

var toPrecision = function(nbr, precision) {
    if (typeof nbr !== 'number') return 0; //???
    if (nbr === 0) return 0;
    var abs = Math.abs(nbr);
    var sign = nbr / abs;
    nbr = abs;
    var digits = Math.ceil(Math.log(nbr)/Math.LN10);
    var factor = Math.pow(10, precision - digits);
    var result = nbr * factor;
    result = Math.round(result, 0);
    return result / factor;
};

toPrecision(1234567.89012, 5); // 1234600

或者，如果这使您的船漂浮，您可以将其附加到数学对象：

Math.toPrecision = function(nbr, precision) {
    // ...
}

更新（2020年5月）
许多年后，随着ES6的普及，我会以不同的方式写这篇文章。它可能看起来像这样：

var toPrecision = (precision) => (nbr, _, __, powerOf10) => 
  nbr === 0
    ? 0
    : (
        powerOf10 = 10 ** (precision - Math .ceil (Math .log10 (Math .abs (nbr)))), 
        Math .round (nbr * powerOf10) / powerOf10
      )

您似乎希望将精度限制在大约五个位置。这样做可能更明确：

var toPrecision = function(precision) {
    return function(nbr) {
        if (typeof nbr !== 'number') return 0; //???
        if (nbr === 0) return 0;
        var abs = Math.abs(nbr);
        var sign = nbr / abs;
        nbr = abs;
        var digits = Math.ceil(Math.log(nbr)/Math.LN10);
        var factor = Math.pow(10, precision - digits);
        var result = nbr * factor;
        result = Math.round(result, 0);
        return result / factor;
    };
};

var format_output = toPrecision(5);

format_output(1234567.89012); // 1234600
format_output(987.654321); // 987.65
format_output(-.00246813579); // -0.0024681

当然，如果愿意，您可以将它们组合成一个双参数函数：

var toPrecision = function(nbr, precision) {
    if (typeof nbr !== 'number') return 0; //???
    if (nbr === 0) return 0;
    var abs = Math.abs(nbr);
    var sign = nbr / abs;
    nbr = abs;
    var digits = Math.ceil(Math.log(nbr)/Math.LN10);
    var factor = Math.pow(10, precision - digits);
    var result = nbr * factor;
    result = Math.round(result, 0);
    return result / factor;
};

toPrecision(1234567.89012, 5); // 1234600

或者，如果这使您的船漂浮，您可以将其附加到数学对象：

Math.toPrecision = function(nbr, precision) {
    // ...
}

更新（2020年5月）
许多年后，随着ES6的普及，我会以不同的方式写这篇文章。它可能看起来像这样：

var toPrecision = (precision) => (nbr, _, __, powerOf10) => 
  nbr === 0
    ? 0
    : (
        powerOf10 = 10 ** (precision - Math .ceil (Math .log10 (Math .abs (nbr)))), 
        Math .round (nbr * powerOf10) / powerOf10
      )

这是我在尝试解决相同问题时提出的一种方法，即如何动态取整，以便向最终用户显示非常大和非常小的数字

function get_exponent_value(num){
     value = num.toExponential();
     string_e_value = value.split('e')[1];
     return parseInt(string_e_value);
}

这将为您提供给定数字的指数值。然后，要使用它，请根据此数字进行四舍五入：

 var EValue = get_exponent_value(val);
 if (EValue <= -1)
       val = float_to_fixed(val, ((EValue * -1) + 3));
 else
       val = float_to_fixed(val);

var EValue=获取指数值（val）；
如果（EValue这是我在尝试解决同一问题时提出的一种方法，那么如何动态取整，以便向最终用户显示非常大和非常小的数字

function get_exponent_value(num){
     value = num.toExponential();
     string_e_value = value.split('e')[1];
     return parseInt(string_e_value);
}

这将为您提供给定数字的指数值。然后，要使用它，请根据此数字进行四舍五入：

 var EValue = get_exponent_value(val);
 if (EValue <= -1)
       val = float_to_fixed(val, ((EValue * -1) + 3));
 else
       val = float_to_fixed(val);

var EValue=获取指数值（val）；
if（EValue）这听起来似乎对用户提出的需求毫无帮助，可能是以合理的精度提供数据。谢谢，但输出是针对“非技术性”的人-我正在寻找一些可以显示数字的东西，比如0.0023、1.63、100.4和10000。在这种情况下，你不能记录数字，然后将其用于。toFixedI添加了另一个解决方案，只需观察边界条件。当传递0时，这会引发一个异常。这听起来似乎对requ的类型毫无帮助如果呈现，请提示用户，可能呈现的数据具有合理的精度。谢谢，但输出是针对“非技术性”的人们-我正在寻找一些显示数字的东西，如0.0023、1.63、100.4和10000。在这种情况下，您不能记录数字，然后将其用于。toFixedI添加了其他解决方案。只需观察边界条件。当传递0时，这会引发异常。您的上一个解决方案非常棒！谢谢。您的上一个解决方案是reall太好了！谢谢。