前言#

最近在做题目LeetCode表示数值的字符串这道题的时候 对数值类型又有了新的认识 打算重新总结下

1. 整数、浮点数#

JavaScript 内部，所有数字都是以64位浮点数形式储存，即使整数也是如此。所以，1与1.0是相同的，是同一个数 1 === 1.0 // true

1
    var num = 2.446242342
2
    num = num.toFixed(2)     // 输出是字符串 需要用parseFloat或Number再转一下

1
    Math.floor(15.7784514000 * 100) / 100       // 15.77

2. 数值的进制#

• 十进制：没有前导0的数值

• 八进制：有前缀0o或0O的数值，或者有前导0、且只用到0-7的八个阿拉伯数字的数值

  1
  012  // 10
  2
  0o12 // 10
  3
  0O12 // 10
  4
  078  // 78   超出范围 无效的八进制 解析为十进制
  

• 十六进制：有前缀0x或0X的数值

  1
  0xA   // 10
  2
  0x12  // 18
  3
  0XAB  //171
  

• 二进制：有前缀0b或0B的数值

  1
  0b111 // 7
  2
  0B11  // 3
  

默认情况下，JavaScript 内部会自动将八进制、十六进制、二进制转为十进制

3. 进制之间的转换#

1
(12).toString()   // "12"   十进制转十进制
2
(012).toString()  // "10"     八进制转十进制
3
(10).toString(2)  // "1010"   十进制转二进制
4
(0b1010).toString(8)  // "12"  二进制转八进制

1
parseInt(111,2) // 3
2
parseInt(12,8)  // 10
3
parseInt(0xA)   // 10
4
parseInt(014)   // 12

4. Number() 函数#

在说NaN 之前先说下Number函数

Number() 函数是数值类型的构造函数 同时也可以将其他类型转为数值类型 如果无法转为数值 就返回NaN

Number()函数的转换规则如下

• Boolean false => 0 true => 1

• Number 直接返回

• null => 0

• undefined => NaN

• 字符串 1 空字符串转为0 2 只包含数字(包含前导正负号) 将其转为十进制 3 如果包含有效的进制格式 将转为相同大小的十进制 4 如果包含有效的浮点格式 将其转为对应的浮点数值 5 如果不符合以上条件 返回NaN

• 对象 调用对用的valueOf()方法 然后按照前面的规则进行转换 如果转换的结果是NaN 则调用对象的toString()方法，然后再依照前面的规则进行转换

  1
  Number(false)      // 0 布尔值false对应0
  2
  Number(123)        // 123 数值类型直接返回
  3
  Number(null)       // 0
  4
  Number(undefined)  // NaN
  5
  Number('')         // 0
  6
  Number('abc')      // NaN 'abc' 不能被转为数字
  7
  Number('123')      // 123  '123' 可以被转为数字
  8
  Number('123a)      // NaN  '123a' 不是只包含数字不能被转换
  9
  Number('0x12')     // 18    0x12是有效的进制格式 站位10进制
  10
  Number('1.1')      // 1.1   有效的浮点格式 转为相应的浮点格式
  11
  
  12
  Number([])        // 0   因为[].toString() ==> ''  Number('') ==> 0
  13
  Number([2])       // 2   因为[2].toString() ==> '2' Number('2') ==> 2
  14
  Number([1,2,3])   // NaN  [1,2,3].toString() ==> '1,2,3' 不能转为数值
  15
  
  16
  Number({})        // NaN   ({}).toString() ==> "[object Object]"  不能转为数值
  

所以对于leetCode 这道题我们可以利用Number()函数对于字符串的转换规则 如果结果是NaN 就不符合条件 否则就是可以转为数值的字符串

1
    var isNumber = function (s) {
2
      s = s.trim()
3
      if (s == '') return false  // 因为 Number('') === 0 所以需要做特殊判断
4
      return !isNaN(Number(s))
5
    }

5. NaN#

NaN 表示“非数字”（Not a Number） 是一个特殊的数值 数据类型依然属于Number

• 主要出现在将字符串解析成数字出错的场合
• 一些数学函数的运算结果会出现NaN 比如 0除以0也会得到NaN
• NaN不等于任何值，包括它本身

针对NaN的特性 ES定义了isNaN()函数 该函数接受一个参数 可以为任何类型 isNaN()会尝试将这个参数转为数值 转换规则与Number()函数一致 所以isNaN方法可以用来判断一个值是否 “不是数值”

1
    NaN === NaN  // false
2
    isNaN(NaN)   // true
3
    isNaN(123)   // false
4

5
    // isNaN()只对数值有效，如果传入其他值，会先转成数值类型
6
    isNaN('')             // false
7
    isNaN('hello')        // true
8
    //相当于
9
    isNaN(Number('hello')) //true
10

11
    isNaN(false)           // false  false会转为0
12
    isNaN({})              //true
13
    isNaN([1,2])           //true
14
    // 所以isNaN() 为true的时候，有可能是一个字符串，或对象或数组
15
    // 所以使用isNaN()时，需要先判断下数据类型
16
    // 但是当数组为空，或数组长度为1时返回false
17
    isNaN([]) //false
18
    isNaN([1]) //false

由于isNaN()函数会对参数进行转换 那这题又可以直接写为

1
    var isNumber = function (s) {
2
      s = s.trim()
3
      if (s == '') return false  // 因为 Number('') === 0 所以需要做特殊判断
4
      return !isNaN(s)
5
    }

6. parseInt()#

parseInt()解析一个字符串并返回指定基数的十进制整数， radix 是2-36之间的整数，表示被解析字符串的基数。 如果不能解析的话返回NaN

1
parseInt(110,2)  // 6 二进制110 转为十进制是 6
2
parseInt(123,8)  // 83 八进制的123 转为十进制是83
3
parseInt(89,8)   // NaN 不是合法的八进制
4
parseInt('014')  // 14  被当做十进制解析
5
parseInt(014)    // 12  因为(014).toString() => 12

1
["1", "2", "3"].map(parseInt)  // [1,NaN,NaN]
2
// 相当于parseInt(1,0)  => 1 string不以任何其他值开头 radix为十进制 parseInt(1,10) => 1
3
// parseInt(2,1) => NaN  1进制不合法 所以返回NaN
4
// parseInt(3,2) => NaN  3 是不合法的二进制 所以返回NaN

1
parseInt('123a',2) // 1 因为符合二进制的只有1
2
parseInt('1123110',2)  // 3  符合二进制的只有前面的11 找到2不符合 会忽略后面的字符 解析为十进制为3
3
parseInt('123abc')     // 123 这通常用来在字符串中提取前面的数值

7. parseFloat()#

parseFloat() 函数解析一个参数（必要时先转换为字符串）并返回一个浮点数。

• 如果 parseFloat 在解析过程中遇到了正号（+）、负号（- U+002D HYPHEN-MINUS）、数字（0-9）、小数点（.）、或者科学记数法中的指数（e 或 E）以外的字符，则它会忽略该字符以及之后的所有字符，返回当前已经解析到的浮点数。
• 第二个小数点的出现也会使解析停止（在这之前的字符都会被解析）。
• 参数首位和末位的空白符会被忽略。
• 如果参数字符串的第一个字符不能被解析成为数字,则 parseFloat 返回 NaN。
• parseFloat 也可以解析并返回 Infinity。
• parseFloat解析 BigInt 为 Numbers, 丢失精度。因为末位 n 字符被丢弃。

1
// 以下的栗子全部返回3.14
2
parseFloat(3.14);
3
parseFloat('3.14');
4
parseFloat('  3.14  ');
5
parseFloat('314e-2');
6
parseFloat('0.0314E+2');
7
parseFloat('3.14some non-digit characters');
8
parseFloat({ toString: function() { return "3.14" } });

8. 其他类型转换为数值类型#

有三个函数可以将非数值转为数值类型: Number() parseInt() parseFloat() 这三个函数对于同样的输入会返回不同的类型

1
    Number('1') // 1
2
    Number('1.123') // 1.123
3
    Number('1.abc') // NaN
4
    Number('')    // 0
5
    Number(true)  // 1
6
    Number(false) // 0
7
    Number(null) // 0
8
    Number(undefined) // NaN
9
    Number({a:1})  // NaN

1
    parseInt('1') //1
2
    parseInt('1.23') // 1
3
    parseInt('  123') // 123
4
    parseInt('1234abc')  // 1234
5
    parseInt('abc') // NaN
6
    parseInt('a567bc') // NaN
7
    parseInt(true) // NaN
8
    parseInt(null) // NaN
9
    parseInt(undefined) // NaN
10
    parseInt({a:1}) // NaN
11
    parseInt([1,2,3]) // 1

1
    parseFloat('3.14') // 3.14
2
    parseFloat('314e-2') // 3.14
3
    parseFloat('0.0314E+2') // 3.14
4
    // 其他与parseInt()结果相同

1
    '1' - 0 // 1
2
    '1.23' - 0  // 1.23
3
    '1.abc' -0 // NaN
4
    '' - 0  // 0
5
    true -0 // 1
6
    false - 0  // 0
7
    null - 0 // 0
8
    undefined - 0 // NaN
9
    ({a:1}) - 0

1
    + '1' // 1
2
    + '1.23' // 1.23
3
    + '1.abc' // NaN
4
    + '' // 0
5
    + true // 1
6
    + false // 0
7
    + null // 0
8
    + undefined // NaN
9
    + {a:1} // NaN

9. 补充一个比较运算符的坑#

1
' ' >= 0 && ' ' <= 9  // true 因为空字符串会转为0
2
'a' >= 0 || 'a' <= 9  // false  'a' 转为数值 NaN
3
'123a' >= '123'       // false '123a'也会转为NaN

1
'2' > '12'   // true
2
'2020-6-8' > '2020-6-14'  // true 因为 '8' > '14'
3
// 所以时间格式比较日期格式要yyyy-MM-dd去比较
4
'2020-06-08' > '2020-06-14' // false  '08' < '14'