下面的代码对我来说很好:

num.toString().match(/.\*\\..{0,2}|.\*/)[0];

Gumbo的第二个解决方案，使用正则表达式，可以工作，但由于使用正则表达式，速度较慢。由于浮点数不精确，Gumbo的第一个解决方案在某些情况下会失败。有关演示和基准测试，请参阅JSFiddle。在我目前使用的3.30 GHz Intel酷睿i5-2500 CPU系统上，第二个解决方案每次调用大约需要1636纳秒。

我所编写的解决方案包括添加一个小的补偿来处理浮点的不精确性。它基本上是瞬时的，即在纳秒的数量级上。我每次调用的时间是2纳秒，但JavaScript计时器不是非常精确或粒度。下面是JS的Fiddle和代码。

function toFixedWithoutRounding (value, precision)
{
    var factorError = Math.pow(10, 14);
    var factorTruncate = Math.pow(10, 14 - precision);
    var factorDecimal = Math.pow(10, precision);
    return Math.floor(Math.floor(value * factorError + 1) / factorTruncate) / factorDecimal;
}

var values = [1.1299999999, 1.13, 1.139999999, 1.14, 1.14000000001, 1.13 * 100];

for (var i = 0; i < values.length; i++)
{
    var value = values[i];
    console.log(value + " --> " + toFixedWithoutRounding(value, 2));
}

for (var i = 0; i < values.length; i++)
{
    var value = values[i];
    console.log(value + " --> " + toFixedWithoutRounding(value, 4));
}

console.log("type of result is " + typeof toFixedWithoutRounding(1.13 * 100 / 100, 2));

// Benchmark
var value = 1.13 * 100;
var startTime = new Date();
var numRun = 1000000;
var nanosecondsPerMilliseconds = 1000000;

for (var run = 0; run < numRun; run++)
    toFixedWithoutRounding(value, 2);

var endTime = new Date();
var timeDiffNs = nanosecondsPerMilliseconds * (endTime - startTime);
var timePerCallNs = timeDiffNs / numRun;
console.log("Time per call (nanoseconds): " + timePerCallNs);

谢谢，Martin Varmus

function floorFigure(figure, decimals){
     if (!decimals) decimals = 2;
     var d = Math.pow(10,decimals);
     return ((figure*d)/d).toFixed(decimals);
};

floorFigure(123.5999)    =>   "123.59"
floorFigure(123.5999, 3) =>   "123.599"

我做了一个简单的更新，我得到了适当的舍入。更新如下

return ((figure*d)/d).toFixed(decimals);

删除parseInt()函数

综合前面所有答案的知识，

这就是我想到的解决办法:

function toFixedWithoutRounding(num, fractionDigits) {
  if ((num > 0 && num < 0.000001) || (num < 0 && num > -0.000001)) {
    // HACK: below this js starts to turn numbers into exponential form like 1e-7.
    // This gives wrong results so we are just changing the original number to 0 here
    // as we don't need such small numbers anyway.
    num = 0;
  }
  const re = new RegExp('^-?\\d+(?:\.\\d{0,' + (fractionDigits || -1) + '})?');
  return Number(num.toString().match(re)[0]).toFixed(fractionDigits);
}

下面是另一个保存.toFixed([digits])函数而不舍入浮点变量的变体:

Number.prototype.toRealFixed = function(digits) {
    return Math.floor(this.valueOf() * Math.pow(10, digits)) / Math.pow(10, digits);
};

和要求:

var float_var = 0.02209062;
float_var.toRealFixed();

function FixWithoutRounding(number, digits) {
  var gbZero = '0000000000';
  var subNumber = number.toString().split('.');

  if (subNumber.length === 1)
    return [subNumber[0], '.', '0000'].join('');

  var result = '';
  if (subNumber[1].length > digits) {
    result = subNumber[1].substring(0, digits);
  } else {
    result = subNumber[1] + gbZero.substring(0, digits - subNumber[1].length);
  }

  return [subNumber[0], '.', result].join('');

}