精华内容
下载资源
问答
  • javascript之parseFloat函数
    2022-03-05 10:26:43

    1.忽略字符串开头的0,无论几个。

    parseFloat("00987");//987
    parseFloat('0980');//980

    2.第一个小数点有效,第二个之后小数点忽略,若第一个小数点后只有一个0,返回整数

    3.与parseInt类似,从位置0开始检测每个·字符,解析到字符串末尾或者解析到一个无效的浮数点为止。

    parseFloat("125abc");//123
    

    4.parseFloat只解析十进制数,因此不指定底数。

    string中字符串值若为十六进制,返回0;

    parseFloat('0xA');//0

    更多相关内容
  • 在Javascript中parseFloat()方法会产生精度问题 代码如下: [removed] var a = “0.11”; var b = “0.2801”; var c = “1.002”; var sum1 = parseFloat(a) + parseFloat(b) + parseFloat(c); var sum2 = ...
  • 用简单的小例子演示了parseInt和parseFloat区别,有需要的朋友可以参考一下
  • 详解js中Number()、parseInt()和parseFloat()的区别 详解JS转换数值函数Number()、parseInt()、parseFloat() 在项目开发中我们经常会用到转型方法,尤其是JS这种松散型的语言。其中比较常用的方法就是Number()方法和...
  • 今天在看jquery的时候里面用到了parseFloat(第一个参数,10),一直不懂第二个参数是什么意思,于是上网查了一下,怕以后忘记就记下来。 定义和用法:parseFloat() 函数可解析一个字符串,并返回一个浮点数。 语法:...
  • 转换函数: js提供了parseInt()和parseFloat()两个转换函数。前者把值转换成整数,后者把值转换成浮点数。只有对String类型调用这些方法,这两个函数才能正确运行;对其他类型返回的都是NaN(Not a Number)。 在判断...
  • js parsefloat parseint JavaScript提供了3个显式的类型转换函数,分别是eval()、parseInt()和parseFloat()。 eval()函数:将字符串表达式转换成数字值。例如,语句total=eval(“432.1*10”)...
  • JS中有三种函数可以将非数值转换成数值:Number()、parseInt()和parseFloat()。第一个函数,即转型函数Number()可以用于任何数据类型,而另外两个函数则专门用于把字符串转换成数值。这3个函数对于同样的输入会返回...
  • parseFloat用于逗号分隔的数字 安装 $ npm install parse-float --save 用法 var pf = require('parse-float'); pf('1,2'); // => 1.2 pf('1.000,2'); // => 1000.2 pf('1 000,2'); // => 1000.2 执照 此代码在 ...
  • 将数据类型转换为数字类型Number()、parseInt()、parseFloat的区别
  • javascript有两种数据类型的转换方法: (一)将整个值从一种类型转换为另一种数据类型(称作基本数据类型转换) (二)从一个值中提取另一种类型的值,并完成转换工作 基本数据类型转换的三种方法: 1....
  • parseInt() 和 parseFloat() 这两个常用API还是会踩坑的,本文以ECMA规范为主来表述其执行机制,并用WebKit源码加以辅助说明,以此文梳理一下。

    从ES规范和引擎细谈 js 中 parseInt 和 parseFloat 的执行机制

    parseInt()parseFloat()这两个常用 API 其实还是有很多“坑”的,以此文统一梳理一下。(本文比较适合常与数字打交道的 jser 或对这两 API 运作感兴趣的同学)

    (github:https://github.com/MichealWayne,个人博客地址:https://blog.michealwayne.cn/),转载可联系michealwayne@163.com

    执行检验

    在以前描述 js 数值时(Q3.说出以下转换数字数值转换的结果),有提到 parseIntparseFloat的运行机制,其实这两 API 还是有蛮多坑的,虽然平时不太会踩到。

    首先猜测以下的执行,自我检验一番:

    /* parseInt */
    parseInt('123.456.789');
    parseInt('+123.456.789');
    parseInt('123abc');
    parseInt('abc123');
    parseInt('1e6');
    parseInt('    1    ');
    parseInt('');
    parseInt('0');
    parseInt('0x');
    parseInt('0x11');
    parseInt(new String('123'));
    
    parseInt('a', 16);
    parseInt(123.456, -1);
    parseInt(123.456, 0);
    parseInt(123.456, 1);
    parseInt(123.456, 2);
    parseInt(123.456, 40);
    parseInt(123.456, 36);
    parseInt(1e6);
    parseInt(1n);
    parseInt();
    parseInt(null);
    parseInt(false);
    
    // 有几个“超纲”题
    parseInt(0.00000001);
    parseInt(123.456, -99999999999999999999999999);
    parseInt(123.456, 99999999999999999999999999);
    parseInt(123.456, 9999999999999999999999999);
    parseInt(9999999999999999);
    parseInt('11111111111111111');
    parseInt('11111111111111111111');
    parseInt(1e21);
    parseInt('123aef', 12);
    parseInt('123', NaN);
    parseInt('0xf', NaN);
    parseInt('123', Infinity);
    parseInt('111', 2 ** 32 + 2.1);
    parseInt(Symbol());
    parseInt(parseInt);
    const objTest1 = {};
    parseInt(objTest1);
    objTest1.toString = () => 123;
    parseInt(objTest1);
    
    /* parseFloat */
    parseFloat('123.456.789');
    parseFloat('123abc.456.789');
    parseFloat('    123abc    ');
    parseFloat('1e6');
    parseFloat('+Infinity');
    parseFloat(Infinity);
    parseFloat(123.456);
    parseFloat(1e6);
    parseFloat(0.00000001);
    parseFloat(0.1 + 0.2);
    parseFloat('0x1a');
    parseFloat(1n);
    parseFloat();
    parseFloat(null);
    parseFloat(false);
    
    // 有几个“超纲”题
    parseFloat(9999999999999999);
    parseFloat('11111111111111111');
    parseFloat('11111111111111111111');
    parseFloat(Symbol());
    parseFloat(parseFloat);
    const objTest2 = {};
    parseFloat(objTest2);
    objTest2.toString = () => 123;
    parseFloat(objTest2);
    

    ECMAScript 规范

    无论啥内核、浏览器或是 NodeJs,都会遵循 ECMA 的主要规范,因此要思考上列的执行结果,可以重点了解 ECMA 规范的执行描述。

    parseInt()

    语法:

    parseInt(string, radix)
    

    其中参数:

    • string:要被解析的值。如果参数不是一个字符串,则将其转换为字符串。标准输入:
      p-parseInt-input-string

    • radix可选,介于2~36之间的整数。告知parseInt()函数string(比如 11)是radix(比如 2)进制的表示,如果radix不存在,parseInt将固定返回string以十进制显示的数。

    另外:

    parseInt === Number.parseInt; // => true
    

    ECMAScript(6.0) 规范说明

    parseInt1

    简单翻译一下执行步骤:

    • 1.定义变量inputString,它是入参string执行 ToString(string) 的字符串结果。(ToString是一个内部 abstract operations、不对外,具体执行见文档或文末附录);
    • 2.执行出现异常则返回(ReturnIfAbrupt,关于ReturnIfAbrupt的执行其实还蛮复杂的,涉及 ECMA 规范的规格术语,本文不做描述);
    • 3.定义变量S,它是inputString创建的一个子字符串,它由第一个不是空白字符的代码单元和该代码单元之后的所有代码单元组成,即去除前置空格,也就是说parseInt('123')parseInt(' 123')效果相同。如果找不到这样的单元,则S为空字符串("");
    • 4.定义变量sign1
    • 5.如果变量S不为空并且S的第一个单元是0x002DHYPHEN-MINUS,即减号),变量sign改为-1
    • 6.如果变量S不为空并且S的第一个单元是0x002BPLUS SIGN,即加号) 或0x002D (HYPHEN-MINUS,即减号),去除S的第一个单元,即去除'+'/-符号;
    • 7.定义变量RToInt32(radix),即对进制声明进行ToInt32数字转换,也就是说parseInt('123', 8)parseInt('123', '8')效果相同;
    • 8.执行出现异常则返回(ReturnIfAbrupt);
    • 9.定义变量stripPrefixtrue
    • 10.如果变量R不等于0,则:
      • 如果变量R小于 2 或大于 36,直接返回NaN
      • 如果变量R不等于 16,变量stripPrefix 改为 false
    • 11.如果变量R等于0,则变量R改为10
    • 12.如果变量stripPrefix值为true,则:
      • 如果变量S字符串长度不小于 2 并且前两个字符单元是0x0X,则删除这两字符,且设置变量R16
    • 13.设置变量Z,如果变量S包含一个不是变量R数字的字符单元,则ZS的子字符串,且由第一个这样的字符单元之前的所有代码单元组成,即parseInt('789', 8)parseInt('7', 8)效果相同;否则,ZS
    • 14.如果变量Z为空,直接返回NaN
    • 15.设置变量mathInt为由Z以基数R进行表示的数学进制整数值,其中使用字母A-Za-z表示值为 10 ~ 35 的数字(如果R为 10,且Z包含 20 个以上的有效数字,则根据实现的选择,第 20 位之后的每个有效数字都可以替换为 0)
      ,如果 R 不是 2、4、8、10、16 或 32,则 mathInt 可能是对数学整数值的依赖实现的近似值,该值由 Z 以基数R 表示法表示。
    • 16.如果mathInt等于 0,则:
      • 如果sign等于-1,则返回-0
      • 否则返回+0
    • 17.设置变量numbermathInt的 Number 值;
    • 18.返回sign * number

    看起来有点复杂,画了个流程图:
    p-rule_parseInt

    parseInt() 只能将字符串的前导部分解释为整数值;它忽略任何不能被解释为整数符号的一部分的代码单元,并且没有给出任何此类代码单元被忽略的迹象。

    parseFloat()

    语法:

    parseFloat(string)
    

    其中参数:

    • string:要被解析的值。如果参数不是一个字符串,则将其转换为字符串。标准输入:
      p-parseFloat-input-string

    另外:

    parseFloat === Number.parseFloat; // => true
    

    ECMAScript(6.0) 规范

    官网描述:

    p-parseFloat-1

    执行步骤:

    • 1.定义变量inputString,它是入参string执行 ToString(string) 的字符串结果。;

    • 2.执行出现异常则返回(ReturnIfAbrupt);

    • 3.定义变量trimmedString,它是inputString创建的一个子字符串,它由第一个不是空白字符的代码单元和该代码单元之后的所有代码单元组成,即去除前置空格,也就是说parseFloat('123.456')parseFloat(' 123.456')效果相同。如果找不到这样的单元,边trimmedString为空字符串("");

    • 4.如果trimmedStringtrimmedString的任何前缀都不满足StrDecimalLiteral的语法,则返回NaN
      StrDecimalLiteral 语法:
      p-strDecimalLiteral.jpg

      文档不是很直观,画了张铁路图:
      p-strDecimalLiteral_rd

    • 5.定义变量numberString,它是trimmedString 的最长前缀(可能是trimmedString) 本身,numberString满足StrDecimalLiteral 的语法。

    • 6.定义变量mathFloat,它是 numberStringMV(mathematical value):从文字中导出MV,其次对这个值进行四舍五入(也有 20 位的阈值处理),这一步处理与parseInt()有很大的不同。至于具体 MV 基本就是大学里学的内容,可见文档

    • 7.如果mathFloat 等于 0,则:

      • 如果trimmedString的第一个字符等于"-",则返回-0
      • 否则返回+0
    • 8.返回mathFloat的 Number 值;

    也画了个流程图:
    p-rule_parseFloat

    parseFloat() 只能将字符串的前导部分解释为整数值;它忽略任何不能被解释为整数符号的一部分的代码单元,并且没有给出任何此类代码单元被忽略的迹象。

    ts

    声明文件(lib.es5.d.ts)很简单:

    /**
     * Converts a string to an integer.
     * @param string A string to convert into a number.
     * @param radix A value between 2 and 36 that specifies the base of the number in `string`.
     * If this argument is not supplied, strings with a prefix of '0x' are considered hexadecimal.
     * All other strings are considered decimal.
     */
    declare function parseInt(string: string, radix?: number): number;
    
    /**
     * Converts a string to a floating-point number.
     * @param string A string that contains a floating-point number.
     */
    declare function parseFloat(string: string): number;
    

    再次注意NaN也是"number"


    内核实现

    以典型的WebKit(依赖 v8)为例,可以看下parseInt()parseFloat的具体代码实现和单测内容(版本:tags/9.9.56

    parseInt 源码

    (主要文件:/Source/JavaScriptCore/runtime/ParseInt.h)

    主要代码:

    // 入口,方法定义
    ALWAYS_INLINE static double parseInt(StringView s, int radix)
    {
        if (s.is8Bit())
            return parseInt(s, s.characters8(), radix);
        return parseInt(s, s.characters16(), radix);
    }
    
    // ES5.1 15.1.2.2
    template <typename CharType>
    ALWAYS_INLINE
    static double parseInt(StringView s, const CharType* data, int radix)
    {
        // 1. Let inputString be ToString(string).
        // 2. Let S be a newly created substring of inputString consisting of the first character that is not a
        //    StrWhiteSpaceChar and all characters following that character. (In other words, remove leading white
        //    space.) If inputString does not contain any such characters, let S be the empty string.
        int length = s.length();
        int p = 0;
        while (p < length && isStrWhiteSpace(data[p]))
            ++p;
    
        // 3. Let sign be 1.
        // 4. If S is not empty and the first character of S is a minus sign -, let sign be -1.
        // 5. If S is not empty and the first character of S is a plus sign + or a minus sign -, then remove the first character from S.
        double sign = 1;
        if (p < length) {
            if (data[p] == '+')
                ++p;
            else if (data[p] == '-') {
                sign = -1;
                ++p;
            }
        }
    
        // 6. Let R = ToInt32(radix).
        // 7. Let stripPrefix be true.
        // 8. If R != 0,then
        //   b. If R != 16, let stripPrefix be false.
        // 9. Else, R == 0
        //   a. LetR = 10.
        // 10. If stripPrefix is true, then
        //   a. If the length of S is at least 2 and the first two characters of S are either ―0x or ―0X,
        //      then remove the first two characters from S and let R = 16.
        // 11. If S contains any character that is not a radix-R digit, then let Z be the substring of S
        //     consisting of all characters before the first such character; otherwise, let Z be S.
        if ((radix == 0 || radix == 16) && length - p >= 2 && data[p] == '0' && (data[p + 1] == 'x' || data[p + 1] == 'X')) {
            radix = 16;
            p += 2;
        } else if (radix == 0)
            radix = 10;
    
        // 8.a If R < 2 or R > 36, then return NaN.
        if (radix < 2 || radix > 36)
            return PNaN;
    
        // 13. Let mathInt be the mathematical integer value that is represented by Z in radix-R notation, using the letters
        //     A-Z and a-z for digits with values 10 through 35. (However, if R is 10 and Z contains more than 20 significant
        //     digits, every significant digit after the 20th may be replaced by a 0 digit, at the option of the implementation;
        //     and if R is not 2, 4, 8, 10, 16, or 32, then mathInt may be an implementation-dependent approximation to the
        //     mathematical integer value that is represented by Z in radix-R notation.)
        // 14. Let number be the Number value for mathInt.
        int firstDigitPosition = p;
        bool sawDigit = false;
        double number = 0;
        while (p < length) {
            int digit = parseDigit(data[p], radix);
            if (digit == -1)
                break;
            sawDigit = true;
            number *= radix;
            number += digit;
            ++p;
        }
    
        // 12. If Z is empty, return NaN.
        if (!sawDigit)
            return PNaN;
    
        // Alternate code path for certain large numbers.
        if (number >= mantissaOverflowLowerBound) {
            if (radix == 10) {
                size_t parsedLength;
                number = parseDouble(s.substring(firstDigitPosition, p - firstDigitPosition), parsedLength);
            } else if (radix == 2 || radix == 4 || radix == 8 || radix == 16 || radix == 32)
                number = parseIntOverflow(s.substring(firstDigitPosition, p - firstDigitPosition), radix);
        }
    
        // 15. Return sign x number.
        return sign * number;
    }
    

    代码中没有“骚”操作,从执行到备注都完全贴合规范。

    parseInt unit test

    (文件:chromium / v8 / v8 / 9.9.56 / . / test / webkit / parseInt-expected.txt

    PASS parseInt('123') is 123
    PASS parseInt('123x4') is 123
    PASS parseInt('-123') is -123
    PASS parseInt('0x123') is 0x123
    PASS parseInt('0x123x4') is 0x123
    PASS parseInt('-0x123x4') is -0x123
    PASS parseInt('-') is Number.NaN
    PASS parseInt('0x') is Number.NaN
    PASS parseInt('-0x') is Number.NaN
    PASS parseInt('123', undefined) is 123
    PASS parseInt('123', null) is 123
    PASS parseInt('123', 0) is 123
    PASS parseInt('123', 10) is 123
    PASS parseInt('123', 16) is 0x123
    PASS parseInt('0x123', undefined) is 0x123
    PASS parseInt('0x123', null) is 0x123
    PASS parseInt('0x123', 0) is 0x123
    PASS parseInt('0x123', 10) is 0
    PASS parseInt('0x123', 16) is 0x123
    PASS parseInt(Math.pow(10, 20)) is 100000000000000000000
    PASS parseInt(Math.pow(10, 21)) is 1
    PASS parseInt(Math.pow(10, -6)) is 0
    PASS parseInt(Math.pow(10, -7)) is 1
    PASS parseInt(-Math.pow(10, 20)) is -100000000000000000000
    PASS parseInt(-Math.pow(10, 21)) is -1
    PASS parseInt(-Math.pow(10, -6)) is -0
    PASS parseInt(-Math.pow(10, -7)) is -1
    PASS parseInt('0') is 0
    PASS parseInt('-0') is -0
    PASS parseInt(0) is 0
    PASS parseInt(-0) is 0
    PASS parseInt(2147483647) is 2147483647
    PASS parseInt(2147483648) is 2147483648
    PASS parseInt('2147483647') is 2147483647
    PASS parseInt('2147483648') is 2147483648
    PASS state = null; try { parseInt('123', throwingRadix); } catch (e) {} state; is "throwingRadix"
    PASS state = null; try { parseInt(throwingString, throwingRadix); } catch (e) {} state; is "throwingString"
    

    parseFloat 源码

    (主要文件:/Source/JavaScriptCore/runtime/JSGlobalObjectFunctions.cpp)

    static double parseFloat(StringView s)
    {
        unsigned size = s.length();
    
        if (size == 1) {
            UChar c = s[0];
            if (isASCIIDigit(c))
                return c - '0';
            return PNaN;
        }
    
        if (s.is8Bit()) {
            const LChar* data = s.characters8();
            const LChar* end = data + size;
    
            // Skip leading white space.
            for (; data < end; ++data) {
                if (!isStrWhiteSpace(*data))
                    break;
            }
    
            // Empty string.
            if (data == end)
                return PNaN;
    
            return jsStrDecimalLiteral(data, end);
        }
    
        const UChar* data = s.characters16();
        const UChar* end = data + size;
    
        // Skip leading white space.
        for (; data < end; ++data) {
            if (!isStrWhiteSpace(*data))
                break;
        }
    
        // Empty string.
        if (data == end)
            return PNaN;
    
        return jsStrDecimalLiteral(data, end);
    }
    
    
    // See ecma-262 6th 11.8.3
    template <typename CharType>
    static double jsStrDecimalLiteral(const CharType*& data, const CharType* end)
    {
        RELEASE_ASSERT(data < end);
    
        size_t parsedLength;
        double number = parseDouble(data, end - data, parsedLength);
        if (parsedLength) {
            data += parsedLength;
            return number;
        }
    
        // Check for [+-]?Infinity
        switch (*data) {
        case 'I':
            if (isInfinity(data, end)) {
                data += SizeOfInfinity;
                return std::numeric_limits<double>::infinity();
            }
            break;
    
        case '+':
            if (isInfinity(data + 1, end)) {
                data += SizeOfInfinity + 1;
                return std::numeric_limits<double>::infinity();
            }
            break;
    
        case '-':
            if (isInfinity(data + 1, end)) {
                data += SizeOfInfinity + 1;
                return -std::numeric_limits<double>::infinity();
            }
            break;
        }
    
        // Not a number.
        return PNaN;
    }
    

    相比之下,parseInt的注释要更为完善。

    parseFloat test

    (文件:chromium / v8 / v8 / 9.9.56 / . / test / webkit / parseFloat-expected.txt

    PASS parseFloat() is NaN
    PASS parseFloat('') is NaN
    PASS parseFloat(' ') is NaN
    PASS parseFloat(' 0') is 0
    PASS parseFloat('0 ') is 0
    PASS parseFloat('x0') is NaN
    PASS parseFloat('0x') is 0
    PASS parseFloat(' 1') is 1
    PASS parseFloat('1 ') is 1
    PASS parseFloat('x1') is NaN
    PASS parseFloat('1x') is 1
    PASS parseFloat(' 2.3') is 2.3
    PASS parseFloat('2.3 ') is 2.3
    PASS parseFloat('x2.3') is NaN
    PASS parseFloat('2.3x') is 2.3
    PASS parseFloat('0x2') is 0
    PASS parseFloat('1' + nonASCIINonSpaceCharacter) is 1
    PASS parseFloat(nonASCIINonSpaceCharacter + '1') is NaN
    PASS parseFloat('1' + illegalUTF16Sequence) is 1
    PASS parseFloat(illegalUTF16Sequence + '1') is NaN
    PASS parseFloat(tab + '1') is 1
    PASS parseFloat(nbsp + '1') is 1
    PASS parseFloat(ff + '1') is 1
    PASS parseFloat(vt + '1') is 1
    PASS parseFloat(cr + '1') is 1
    PASS parseFloat(lf + '1') is 1
    PASS parseFloat(ls + '1') is 1
    PASS parseFloat(ps + '1') is 1
    PASS parseFloat(oghamSpaceMark + '1') is 1
    PASS parseFloat(mongolianVowelSeparator + '1') is NaN
    PASS parseFloat(enQuad + '1') is 1
    PASS parseFloat(emQuad + '1') is 1
    PASS parseFloat(enSpace + '1') is 1
    PASS parseFloat(emSpace + '1') is 1
    PASS parseFloat(threePerEmSpace + '1') is 1
    PASS parseFloat(fourPerEmSpace + '1') is 1
    PASS parseFloat(sixPerEmSpace + '1') is 1
    PASS parseFloat(figureSpace + '1') is 1
    PASS parseFloat(punctuationSpace + '1') is 1
    PASS parseFloat(thinSpace + '1') is 1
    PASS parseFloat(hairSpace + '1') is 1
    PASS parseFloat(narrowNoBreakSpace + '1') is 1
    PASS parseFloat(mediumMathematicalSpace + '1') is 1
    PASS parseFloat(ideographicSpace + '1') is 1
    

    最后

    从 ECMA 规范和典型内核的代码实现中我们可以发现,parseFloatparseInt存在很多边界处理,这也是造成踩坑的主要原因。

    至此可以再回过头想想最初的那些执行问题,绝大部分都能得到解释。至于“超纲”题,有兴趣可以去看下 ECMA 规范中的数字及类型转换部分。


    附录

    tostring

    p-table12-tostring

    MV(mathematical value)

    p-mv

    parseFloat input string 格式

    Diagram(
      ZeroOrMore('Space'),
      Optional(
        Choice(0,
          '+',
          '-',
        ), 'skip'
      ),
      Choice(1,
        'Infinity',
        Sequence(
          Choice(0,
            Sequence(
              ZeroOrMore('0-9'),
              Optional('.', 'skip'),
              OneOrMore('0-9'),
            ),
          ),
          Optional(
            Sequence(
              Choice(0,
                'e',
                'E',
              ),
              Optional(
                Choice(0,
                  '+',
                  '-',
                ), 'skip'
              ),
              OneOrMore('0-9'),
            )
          , 'skip')
        )
      ),
      ZeroOrMore('Space'),
    )
    

    parseInt input string 格式

    Diagram(
      ZeroOrMore('Space'),
      Optional(
        Choice(0,
          '+',
          '-',
        ), 'skip'
      ),
      ZeroOrMore('0-R'),	// R 为进制最大值
      ZeroOrMore('Space'),
    )
    

    有建议或转载可 -> michealwayne@163.com

    相关链接

    展开全文
  • 一:Number() 如果是Boolean值,true和false值将分别被转换为1和0。 如果是数字值,只是简单的传入和返回。 如果是null值,返回0。 如果是undefined,返回NaN。 如果是字符串:  a.... b.... c.... d....
  • parseFloat()方法的定义和用法: parseFloat()方法可以解析一个字符串,并返回一个浮点数。 注:如果字符串中的第一个字符不能够转换成数字,此方法返回NaN。如果字符串中含有多个数字,但只会返回第一个数字。 点击可...
  • parseFloat详解

    千次阅读 2020-11-04 23:37:49
    parseFloat 转为浮点数(小数) boolean转为NaN 可以智能截取 字符串中只识别十进制 执行代码: <script> // boolean console.log(parseFloat(true)); // NaN console.log(parseFloat(false)); // ...

    parseFloat

    转为浮点数(小数)

    • boolean转为NaN
    • 可以智能截取
    • 字符串中只识别十进制

    执行代码:

    <script>
        // boolean
        console.log(parseFloat(true)); // NaN
        console.log(parseFloat(false)); // NaN
    
        // 数字: 舍去取整
        console.log(parseFloat(12.4)); // 12.4
        console.log(parseFloat(12.63)); // 12.63
    
        // 字符串
        console.log(parseFloat('12')); // 12
        console.log(parseFloat('12.4')); // 12.4
        console.log(parseFloat('12.3.4abc23')); // 12.3
        console.log(parseFloat('abc23.6')); // NaN
    
        // 数字的进制都识别
        console.log(parseFloat(0b101)); // 5
        console.log(parseFloat(011)); // 9
        console.log(parseFloat(0x11)); // 17
        // 字符串中只识别10进制
        console.log(parseFloat('0b101')); // 0
        console.log(parseFloat('011')); // 11
        console.log(parseFloat('0x11')); // 0
    </script>
    
    展开全文
  • 在js中举行以元为单元举行金额盘算时 使用parseFloat会发生精度问题var price = 10.99;var quantity = 7;var needPay = parseFloat(price * quantity);needPay的准确效果应该是76.93元 然则运行后发现needPay为76....

    在js中举行以元为单元举行金额盘算时 使用parseFloat会发生精度问题

    var price = 10.99;

    var quantity = 7;

    var needPay = parseFloat(price * quantity);

    needPay的准确效果应该是76.93元  然则运行后发现needPay为76.93000000000001 。此情形可通过 toFixed(n)  方式修正 然则这个方式对 js版本要求较高 不能兼容ie5

    另一个解决方案是: 将元为单元的金额乘以100换算为分举行盘算

    var price = 10.99

    var quantity = 7

    var needPay = Math.floor(parseFloat(price*100 * quantity))/100;

    parseFloat(price*100 * quantity)的盘算效果是7693.000000000001   使用Math.round()方式四舍五入,再除100  即为准确的效果

    PS:顺便学到了一点:Math.ceil() Math.floor() Math.round() 的区别

    Math.ceil() 是向上取整

    Math.floor()是向下取整

    Math.round()是四舍五入

    //保留两位小数

    //功效:将浮点数四舍五入,取小数点后2位

    function toDecimal(x) {

    var f = parseFloat(x);

    if (isNaN(f)) {

    return;

    }

    f = Math.round(x*100)/100;

    return f;

    }

    //制保留2位小数,如:2,会在2后面补上00.即2.00

    function toDecimal2(x) {

    var f = parseFloat(x);

    if (isNaN(f)) {

    return false;

    }

    var f = Math.round(x*100)/100;

    var s = f.toString();

    var rs = s.indexOf(‘.‘);

    if (rs < 0) {

    rs = s.length;

    s += ‘.‘;

    }

    while (s.length <= rs + 2) {

    s += ‘0‘;

    }

    return s;

    }

    function fomatFloat(src,pos){

    return Math.round(src*Math.pow(10, pos))/Math.pow(10, pos);

    }

    //四舍五入

    alert("保留2位小数:" + toDecimal(3.14159267));

    alert("强制保留2位小数:" + toDecimal2(3.14159267));

    alert("保留2位小数:" + toDecimal(3.14559267));

    alert("强制保留2位小数:" + toDecimal2(3.15159267));

    alert("保留2位小数:" + fomatFloat(3.14559267, 2));

    alert("保留1位小数:" + fomatFloat(3.15159267, 1));

    //五舍六入

    alert("保留2位小数:" + 1000.003.toFixed(2));

    alert("保留1位小数:" + 1000.08.toFixed(1));

    alert("保留1位小数:" + 1000.04.toFixed(1));

    alert("保留1位小数:" + 1000.05.toFixed(1));

    //科学计数

    alert(3.1415.toExponential(2));

    alert(3.1455.toExponential(2));

    alert(3.1445.toExponential(2));

    alert(3.1465.toExponential(2));

    alert(3.1665.toExponential(1));

    //正确到n位,不含n位

    alert("正确到小数点第2位" + 3.1415.toPrecision(2));

    alert("正确到小数点第3位" + 3.1465.toPrecision(3));

    alert("正确到小数点第2位" + 3.1415.toPrecision(2));

    alert("正确到小数点第2位" + 3.1455.toPrecision(2));

    alert("正确到小数点第5位" + 3.141592679287.toPrecision(5));

    思源资源网:分类流动

    1.阿里云: 本站现在使用的是阿里云主机,平安/可靠/稳固。点击领取2000元代金券、领会最新阿里云产物的种种优惠流动点击进入

    2.腾讯云: 提供云服务器、云数据库、云存储、视频与CDN、域名等服务。腾讯云各种产物的最新流动,优惠券领取点击进入

    3.广告同盟: 整理了现在主流的广告同盟平台,若是你有流量,可以作为参考选择适合你的平台点击进入

    链接: http://www.fly63.com/article/detial/1971

    展开全文
  • 一、Number() Number函数主要是用于将任何其他数据类型的值转化为数值类型。... console.log(parseFloat("10212")) //10212 console.log(parseFloat("0xA")) //0 console.log(parseFloat("0908.5")); //908.5
  • // NaN parseFloat()函数的工作方式跟 parseInt()函数类似,都是从位置 0 开始检测每个字符。同样, 它也是解析到字符串末尾或者解析到一个无效的浮点数值字符为止。这意味着第一次出现的小数点是有 效的,但第二次...
  • 没找到更好的解决办法,只能用字符串拼接的方式解决。 sum:function(){ debugger var n1 = "1234567890123.1000"; var n2 = "1234567890123.1000"; var precision = 4; var result = "";...
  • parsefloat 浮动类parseFloat()方法 (Float class parseFloat() method) parseFloat() method is available in java.lang package. parseFloat()方法在java.lang包中可用。 parseFloat() method is used to return ...
  • Float类parseFloat()方法parseFloat()方法在java.lang包中可用。parseFloat()方法用于返回与给定String表示形式相对应的float值,换句话说,我们可以说此方法用于将字符串值转换为float值。parseFloat()方法是一个...
  • 示例 // 普通字符串 parseFloat('1.234') // 1.234 parseFloat('.234') // 0.234 parseFloat('1.234.56') // 1.234 parseFloat('+1.234') // 1.234 parseFloat('-1.234') // -1.234 parseFloat(' 1.234abd') // 1....
  • parseFloat()函数 parseFloat 主要将首位是数字的字符串转换成浮点型数字。如果字符串不是以数字开头,就会返回NaN。 parseFloat(string) string :表示想要转换成浮点数字的字符串

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 81,308
精华内容 32,523
关键字:

parsefloat

友情链接: blocbew.rar