我需要删除任何尾随零，但至少保留2个小数，包括任何零。我正在使用的数字是6个十进制数字字符串，由. tofixed(6)生成。

预期结果:

var numstra = 12345.000010 // should return 12345.00001
var numstrb = 12345.100000 // should return 12345.10
var numstrc = 12345.000000 // should return 12345.00
var numstrd = 12345.123000 // should return 12345.123

解决方案:

var numstr = 12345.100000

while (numstr[numstr.length-1] === "0") {           
    numstr = numstr.slice(0, -1)
    if (numstr[numstr.length-1] !== "0") {break;}
    if (numstr[numstr.length-3] === ".") {break;}
}

console.log(numstr) // 12345.10

逻辑:

如果字符串的最后一个字符为零，则运行循环函数。 删除最后一个字符并更新字符串变量。 如果更新后的字符串最后一个字符不是零，则结束循环。 如果更新的字符串倒数第三个字符是浮点数，则结束循环。

如果我们有一个数字的s字符串表示形式，例如我们可以使用number的.toFixed(digits)方法(或任何其他方法)来获得，那么为了从s字符串中删除不重要的末尾零，我们可以使用:

s.replace(/(\.0*|(?<=(\..*))0*)$/, '')

/**********************************
 * Results for various values of s:
 **********************************
 *
 * "0" => 0
 * "0.000" => 0
 * 
 * "10" => 10
 * "100" => 100
 * 
 * "0.100" => 0.1
 * "0.010" => 0.01
 * 
 * "1.101" => 1.101
 * "1.100" => 1.1
 * "1.100010" => 1.10001
 * 
 * "100.11" => 100.11
 * "100.10" => 100.1
 */

replace()中使用的正则表达式解释如下:

In the first place please pay the attention to the | operator inside the regular expression, which stands for "OR", so, the replace() method will remove from s two possible kinds of substring, matched either by the (\.0*)$ part OR by the ((?<=(\..*))0*)$ part. The (\.0*)$ part of regex matches a dot symbol followed by all the zeros and nothing else till to the end of the s. This might be for example 0.0 (.0 is matched & removed), 1.0 (.0 is matched & removed), 0.000 (.000 is matched & removed) or any similar string with all the zeros after the dot, so, all the trailing zeros and the dot itself will be removed if this part of regex will match. The ((?<=(\..*))0*)$ part matches only the trailing zeros (which are located after a dot symbol followed by any number of any symbol before start of the consecutive trailing zeros). This might be for example 0.100 (trailing 00 is matched & removed), 0.010 (last 0 is matched & removed, note that 0.01 part do NOT get matched at all thanks to the "Positive Lookbehind Assertion", i.e. (?<=(\..*)), which is in front of 0* in this part of regex), 1.100010 (last 0 is matched & removed), etc. If neither of the two parts of expression will match, nothing gets removed. This might be for example 100 or 100.11, etc. So, if an input does not have any trailing zeros then it stays unchanged.

更多使用.toFixed(数字)的例子(在下面的例子中使用了字面值“1000.1010”，但我们可以假设变量):

let digits = 0; // Get `digits` from somewhere, for example: user input, some sort of config, etc.

(+"1000.1010").toFixed(digits).replace(/(\.0*|(?<=(\..*))0*)$/, '');
// Result: '1000'

(+"1000.1010").toFixed(digits = 1).replace(/(\.0*|(?<=(\..*))0*)$/, '');
// Result: '1000.1'


(+"1000.1010").toFixed(digits = 2).replace(/(\.0*|(?<=(\..*))0*)$/, '');
// Result: '1000.1'


(+"1000.1010").toFixed(digits = 3).replace(/(\.0*|(?<=(\..*))0*)$/, '');
// Result: '1000.101'


(+"1000.1010").toFixed(digits = 4).replace(/(\.0*|(?<=(\..*))0*)$/, '');
// Result: '1000.101'


(+"1000.1010").toFixed(digits = 5).replace(/(\.0*|(?<=(\..*))0*)$/, '');
// Result: '1000.101'

(+"1000.1010").toFixed(digits = 10).replace(/(\.0*|(?<=(\..*))0*)$/, '');
// Result: '1000.101'

要使用replace()中使用的上述正则表达式，我们可以访问:https://regex101.com/r/owj9fz/1

纯正则表达式的答案

n.replace(/(\.[0-9]*[1-9])0+$|\.0*$/,'$1');

我想知道为什么没有人给我一个!

当Django在文本字段中显示十进制类型的值时，我也需要解决这个问题。例如，当'1'是值时。它会显示“1.00000000”。如果'1.23'是值，它将显示'1.23000000'(在'decimal_places'设置为8的情况下)

使用parseFloat对我来说不是一个选项，因为它可能不会返回完全相同的值。toFixed不是一个选项，因为我不想四舍五入任何东西，所以我创建了一个函数:

function removeTrailingZeros(value) {
    value = value.toString();

    # if not containing a dot, we do not need to do anything
    if (value.indexOf('.') === -1) {
        return value;
    }

    # as long as the last character is a 0 or a dot, remove it
    while((value.slice(-1) === '0' || value.slice(-1) === '.') && value.indexOf('.') !== -1) {
        value = value.substr(0, value.length - 1);
    }
    return value;
}

我写这个正则表达式是为了从包含数字的字符串的开头和结尾删除无关紧要的0、小数和空格:

const rxInsignificant = /^[\s0]+|(?<=\..*）[\s0.]+$|\.0+$|\.$/gm; 设 ary = [ "001.230", "2.", "3.00", "1000", " 0000000000000010000.10000000000000000000000 "]; ary.forEach（（str）=> { console.log（'“${str}” 变为 “${str.replace（rxInsignificant ，''）}”'）; });

不幸的是，Safari仍然不支持2018年的规范，该规范为我们提供了正则表达式的回溯。自07-28-2017以来，此问题一直有一个开放的错误报告。

好消息是，在Firefox和所有Chromium衍生产品中，向后查找功能确实有效。希望Safari能收到更多的要求，并尽快实现这个标准。

与此同时，我写了这个函数来完成同样的任务，而不需要回顾:

function createRemoveInsignificantFunction() { const rxLeadingZeros = /^[\s0]+/; const rxEndingZeros = /[\s0]+$/; function removeInsignificant(str) { str = str.replace(rxLeadingZeros,''); let ary = str.split('.'); if (ary.length > 1) { ary[1] = ary[1].replace(rxEndingZeros,''); if (ary[1].length === 0) { return ary[0]; } else { return ary[0] + '.' + ary[1]; } } return str; } return removeInsignificant; } let removeInsignificant = createRemoveInsignificantFunction(); let ary = [ "001.230", "2.", "3.00", "1000", " 0000000000000010000.10000000000000000000000 "]; ary.forEach((str)=> { console.log(`"${str}" becomes "${removeInsignificant(str)}"`); });

当我有更多的时间时，我想弄清楚如何用一个正则表达式来完成这个任务，而不需要在其中查找。欢迎你在下面的评论中打败我。

我首先使用了matti-lyra和gary的答案的组合:

r=(+n).toFixed(4).replace(/\.0+$/,'')

结果:

1234870.98762341:“1234870.9876” 1230009100:“1230009100” 0.0012234:“0.0012” 0.1200234:“0.12” 0.000001231:“0” 0.10001:“0.1000” "asdf": "NaN"(所以没有运行时错误)

有点问题的情况是0.10001。我最终使用了这个更长的版本:

    r = (+n).toFixed(4);
    if (r.match(/\./)) {
      r = r.replace(/\.?0+$/, '');
    }

1234870.98762341:“1234870.9876” 1230009100:“1230009100” 0.0012234:“0.0012” 0.1200234:“0.12” 0.000001231:“0” 0.10001:“0.1” "asdf": "NaN"(所以没有运行时错误)

更新:这是加里的新版本(见评论):

r=(+n).toFixed(4).replace(/([0-9]+(\.[0-9]+[1-9])?)(\.?0+$)/,'$1')

这将得到与上面相同的结果。