blocks|key|2377637|text|不是的。删除逗号。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2377638|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

blocks|key|1450622|text|parseFloat(+theString.replace(/,/g,'')+);|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1450623|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>parseFloat( theString.replace(/,/g,'') );
</code></pre>

blocks|key|1450632|text|您可以使用字符串替换方法，但不能像regexp那样在单行程序中使用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1450633|while(str.indexOf(',')!=-1)str=+str.replace(',','');
parseFloat(str);|code-block|syntax|javascript|1450634|或者创建不带regexp=的单个表达式|1450635|return+parseFloat(str.split(',').join(''));|1450636|我会使用regexp。|1450637|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

You can use the string replace method, but not in a one liner as a regexp allows.

<pre><code>while(str.indexOf(',')!=-1)str= str.replace(',','');
parseFloat(str);
</code></pre>

Or to make a single expression without a regexp=

<pre><code>return parseFloat(str.split(',').join(''));
</code></pre>

I'd use the regexp.

blocks|key|705331|text|基于@kennebec的想法，如果你想确保逗号是正确的，并且你不想替换逗号，你可以尝试这样做：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|705332|function+myParse(num)+{
++var+n2+=+num.split(",")
++out+=+0
++for(var+i+=+0;+i+<+n2.length;+i%2B%2B)+{
++++out+*=+1000;
++++out+%2B=+parseFloat(n2[i])
++}
++return+out
}
alert(myParse("1,432,85"));
//+Returns+1432085,+as+the+comma+is+misplaced.|code-block|syntax|javascript|705333|它可能没有那么快，但您希望有其他选择:)|705334|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Building on the idea from @kennebec, if you want to make sure that the commas are correct, and you don't want to replace commas, you could try something like this:

<pre><code>function myParse(num) {
 var n2 = num.split(",")
 out = 0
 for(var i = 0; i &lt; n2.length; i++) {
 out *= 1000;
 out += parseFloat(n2[i])
 }
 return out
}
alert(myParse("1,432,85"));
// Returns 1432085, as the comma is misplaced.
</code></pre>

It may not be as fast, but you wanted alternatives :)

blocks|key|707187|text|用一个简单的函数来解决大多数常见问题怎么样？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|707188|function+getValue(obj)+{
++Value+=+parseFloat(+$(obj).val().replace(/,/g,'')+).toFixed(2);
++return+%2BValue;
}|code-block|syntax|javascript|707189|上面的函数从字段中获取值(使用jQuery)，假设输入的值是数字的(我宁愿在用户输入数据时验证字段，因此我确定字段内容是数字的)。|707190|对于浮点值，如果在字段中格式正确，该函数将正确返回浮点值。|707191|此函数远未完成，但它可以快速修复输入为1,234.56或1,234,567的值的"，“(comma)问题。只要内容是数字，它就会返回有效的数字。|offset|length|style|BOLD|707192|在return命令中，变量值前面的%2B+(%2B)符号是JavaScript中用来确保返回的变量内容是数字的“肮脏把戏”。|707193|可以很容易地将该函数修改为其他用途，例如，将字符串转换为数字值，以处理"，“(逗号)问题：|707194|function+parseValue(str)+{
++Value+=+parseFloat(+str.replace(/,/g,'')+).toFixed(2);
++return+%2BValue;
}|707195|这两个操作甚至可以组合在一个函数中。即：|707196|function+parseNumber(item,isField=false)+{
++Value+=+(isField)+?+parseFloat(+$(item).val().replace(/,/g,'')+).toFixed(2)+:+parseFloat(+item.replace(/,/g,'')+).toFixed(2)
++return+%2BValue;
}|707197|在这种情况下，如果函数名为result+=+parseNumber('12,092.98');，它会将值解析为字符串。但如果作为result+=+parseNumber('#MyField'，true);调用，它将尝试从‘#myField`获取值。|707198|正如我之前所说的，这样的功能还远远不完整，可以通过许多方式进行扩展。一种想法是检查给定参数(字符串)的第一个字符，并根据字符串格式决定从哪里获取要解析的值(如果第一个字符是=+'#'，则它是来自DOM对象的ID，否则，如果它以数字开头，则它必须是要解析的字符串)。|707199|试试看。祝你编码愉快。|707200|entityMap^0|0|0|0|0|15|1|18|5|0|1|6|D|1|H|1|K|1|0|10|1|13|2|0|0|0|0|D|Y|1S|12|32|A|0|2G|3|0|0^^$0|@$1|2|3|4|5|6|7|18|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|19|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|1A|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|1B|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|1C|8|@$M|1D|N|1E|O|P]|$M|1F|N|1G|O|P]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1H|8|@$M|1I|N|1J|O|P]|$M|1K|N|1L|O|P]|$M|1M|N|1N|O|P]|$M|1O|N|1P|O|P]]|9|@]|A|$]]|$1|S|3|T|5|6|7|1Q|8|@$M|1R|N|1S|O|P]|$M|1T|N|1U|O|P]]|9|@]|A|$]]|$1|U|3|V|5|D|7|1V|8|@]|9|@]|A|$E|F]]|$1|W|3|X|5|6|7|1W|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|D|7|1X|8|@]|9|@]|A|$E|F]]|$1|10|3|11|5|6|7|1Y|8|@$M|1Z|N|20|O|P]|$M|21|N|22|O|P]|$M|23|N|24|O|P]]|9|@]|A|$]]|$1|12|3|13|5|6|7|25|8|@$M|26|N|27|O|P]]|9|@]|A|$]]|$1|14|3|15|5|6|7|28|8|@]|9|@]|A|$]]|$1|16|3|-4|5|6|7|29|8|@]|9|@]|A|$]]]|17|$]]

What about a simple function to solve most of the common problems?

<pre><code>function getValue(obj) {
 Value = parseFloat( $(obj).val().replace(/,/g,'') ).toFixed(2);
 return +Value;
}
</code></pre>

The above function gets values from fields (using jQuery) assuming the entered values are numeric (I rather validate fields while user is entering data, so I know for sure field content is numeric).

In case of floating point values, if well formatted in the field, the function will return a float point value correctly. 

This function is far from complete, but it quickly fix the "," (comma) issue for values entered as 1,234.56 or 1,234,567. It will return valid number as far the content is numeric.

The + (plus) sign in front of the variable Value in the return command is a "dirty trick" used in JavaScript to assure the variable content returned will be numeric. 

it is easy to modify the function to other purposes, such as (for instance), convert strings to numeric values taking care of the "," (comma) issue:

<pre><code>function parseValue(str) {
 Value = parseFloat( str.replace(/,/g,'') ).toFixed(2);
 return +Value;
}
</code></pre>

Both operations can even be combined in one function. I.e.:

<pre><code>function parseNumber(item,isField=false) {
 Value = (isField) ? parseFloat( $(item).val().replace(/,/g,'') ).toFixed(2) : parseFloat( item.replace(/,/g,'') ).toFixed(2)
 return +Value;
}
</code></pre>

In such case, if function is called result = parseNumber('12,092.98'); it will parse the value as it is a String. But if called as result = parseNumber('#MyField', true); it will try to obtain the value from '#MyField'.

As I said before, such functions are far from complete, and can be expanded in many ways. One idea is to check the first character of the given parameter (string) and decide based on the string format where to obtain the value to be parsed (if 1st character is = '#' then it is an ID from a DOM object, otherwise, if it begins with a number, it must be a string to be parsed).

Try it... Happy coding.

blocks|key|1453745|text|我不知道为什么没有人提出这样的说法-|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1453746|parseFloat(+theString.replace(/[%5E\d\.]/g,'')+);|code-block|syntax|javascript|1453747|删除除句点外的所有非数字字符。你也不需要定制函数/循环来实现这一点，这太夸张了。|1453748|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I don't know why no one has suggested this expression-

<pre><code>parseFloat( theString.replace(/[^\d\.]/g,'') );
</code></pre>

Removes any non-numeric characters except for periods. You don't need custom functions/loops for this either, that's just overkill.

blocks|key|707228|text|我没有足够的名气来添加评论，但如果任何人想知道正则表达式与拆分/连接的性能，这里有一个快速小提琴：https://jsfiddle.net/uh3mmgru/|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|707229|var+test+=+"1,123,214.19";

var+t0+=+performance.now();
for+(var+i+=+0;+i+<+1000000;+i%2B%2B)
{
++++var+a+=+parseFloat(test.replace(/,/g,''));
}
var+t1+=+performance.now();
document.write('Regex+took:+'+%2B+(t1+-+t0)+%2B+'+ms');
document.write(' ')

var+t0+=+performance.now();
for+(var+i+=+0;+i+<+1000000;+i%2B%2B)
{
++++var+b+=+parseFloat(test.split(',').join(''));
}
var+t1+=+performance.now();
document.write('Split/join+took:+'+%2B+(t1+-+t0)+%2B+'+ms');|code-block|syntax|javascript|707230|我得到的结果是(每个循环100万次)：|707231|正则表达式:+263.335毫秒|707232|拆分/加入:+1035.875毫秒|707233|因此，我认为可以肯定地说，正则表达式在这种情况下是可行的|707234|entityMap|0|LINK|mutability|MUTABLE|url|https://jsfiddle.net/uh3mmgru/^0|1D|U|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@$A|Z|B|10|1|11]]|C|$]]|$1|D|3|E|5|F|7|12|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|13|8|@]|9|@]|C|$]]|$1|K|3|L|5|6|7|14|8|@]|9|@]|C|$]]|$1|M|3|N|5|6|7|15|8|@]|9|@]|C|$]]|$1|O|3|P|5|6|7|16|8|@]|9|@]|C|$]]|$1|Q|3|-4|5|6|7|17|8|@]|9|@]|C|$]]]|R|$S|$5|T|U|V|C|$W|X]]]]

I don't have enough reputation to add a comment, but for anyone wondering on the performance for regex vs split/join, here's a quick fiddle: <a href="https://jsfiddle.net/uh3mmgru/" rel="nofollow">https://jsfiddle.net/uh3mmgru/</a>

<pre><code>var test = "1,123,214.19";

var t0 = performance.now();
for (var i = 0; i &lt; 1000000; i++)
{
 var a = parseFloat(test.replace(/,/g,''));
}
var t1 = performance.now();
document.write('Regex took: ' + (t1 - t0) + ' ms');
document.write('&lt;br&gt;')

var t0 = performance.now();
for (var i = 0; i &lt; 1000000; i++)
{
 var b = parseFloat(test.split(',').join(''));
}
var t1 = performance.now();
document.write('Split/join took: ' + (t1 - t0) + ' ms');
</code></pre>

The results I get are (for 1 million loops each):

Regex: 263.335 ms 
Split/join: 1035.875 ms

So I think its safe to say that regex is the way to go in this scenario

How would it be a nice way of handling this?

I already thought on removing the comma and then parsing to float. 

Do you know a better/cleaner way?

Thanks

javascript parseFloat '500,000' returns 500 when I need 500000

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

这是如何处理这件事的好方法呢？我已经考虑过删除逗号，然后解析为浮点型。你知道更好/更干净的方法吗？谢谢

问当我需要500000的时候，javascript parseFloat ' 500 ,000‘返回500
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问当我需要500000的时候，javascript parseFloat ' 500 ,000‘返回500EN