Number

静态属性

静态方法

总览

Number() 函数将对象参数转换为表示对象值的数字。

• 如果该值无法转换为合法数字，则返回 NaN。
• 注释：如果参数是 Date 对象，则 Number() 函数返回自 UTC 1970 年 1 月 1 日午夜以来的毫秒数。

  x = true;           Number(x);        // 返回 1
  x = false;       Number(x);        // 返回 0
  x = new Date();  Number(x);        // 返回 1404568027739
  x = "10"         Number(x);        // 返回 10
  x = "10 20"      Number(x);        // 返回 NaN
  Number(new Date("2019-04-15"));    // 返回 1506729600000

  | 方法 | 描述 | | —- | —- | | Number.parseInt() | 将字符串转换成整型数字，和全局方法 parseInt() 作用一致。 | | Number.parseFloat() | 将字符串转换成浮点数，和全局方法 parseFloat()
  作用一致。 | | Number.isInteger() | 判断传递的参数是否为整数。 | | Number.isSafeInteger() | 判断传递的参数是否为安全整数。 | | Number.isFinite() | 判断传递的参数是否为有限数字。 | | Number.isNaN() | 判断传递的参数是否为 isNaN()。 |

parseInt/parseFloat

一般使用全局函数方式

parseInt() 解析一段字符串并返回数值。允许空格。只返回首个数字
parseFloat() 解析一段字符串并返回数值。允许空格。只返回首个数字

• 如果无法转换为数值，则返回 NaN ```javascript parseInt(“10”); // 返回 10 parseInt(“10.33”); // 返回 10 parseInt(“10 20 30”); // 返回 10 parseInt(“10 years”); // 返回 10 parseInt(“years 10”); // 返回 NaN

parseFloat(“10”); // 返回 10 parseFloat(“10.33”); // 返回 10.33 parseFloat(“10 20 30”); // 返回 10 parseFloat(“10 years”); // 返回 10 parseFloat(“years 10”); // 返回 NaN

<a name="VG3So"></a>
### 
<a name="x6kAp"></a>
### isInteger/isSafeInteger
Number.isInteger() 方法用来判断给定的参数是否为整数。<br />Number.isSafeInteger() 方法用来判断传入的参数值是否是一个“安全整数”
> 安全整数范围为 -(253 - 1)到 253 - 1 之间的整数，包含 -(253 - 1)和 253 - 1。
```javascript
Number.isInteger = Number.isInteger || function(value) {
    return typeof value === "number" &&
           isFinite(value) &&
           Math.floor(value) === value;
};
Number.isSafeInteger = Number.isSafeInteger || function (value) {
   return Number.isInteger(value) && Math.abs(value) <= Number.MAX_SAFE_INTEGER;
};

Number.isInteger(0);         // true
Number.isInteger(-100000);   // true
Number.isInteger(0.1);       // false
Number.isInteger(Infinity);  // false
Number.isInteger("10");      // false
Number.isInteger(true);      // false
Number.isInteger([1]);       // false
Number.isSafeInteger(Math.pow(2, 53))       // false
Number.isSafeInteger(Math.pow(2, 53) - 1)   // true

isFinite

Number.isFinite() 方法用来检测传入的参数是否是一个有穷数。

和全局的 isFinite() 函数相比，这个方法不会强制将一个非数值的参数转换成数值，这就意味着，只有数值类型的值，且是有穷的（finite），才返回 true。

if (Number.isFinite === undefined) Number.isFinite = function(value) {
    return typeof value === 'number' && isFinite(value);
}

Number.isFinite(Infinity);  // false
Number.isFinite(0);         // true
Number.isFinite('0');       // false

isNaN

Number.isNaN() 方法确定传递的值是否为 NaN。

和全局函数 isNaN() 相比，Number.isNaN() 不会自行将参数转换成数字，只有在参数是值为 NaN 的数字时，才会返回 true。 缺少Number.isNaN函数的情况下, 通过表达式(x != x) 来检测变量x是否是NaN会更加可靠。

isNaN = function(value) {
    var n = Number(value);
    return n !== n;
};
Number.isNaN = Number.isNaN || function(value) {
    return typeof value === "number" && isNaN(value);
}

isNaN(NaN);       // true
isNaN(undefined); // true
isNaN({});        // true
Number.isNaN(NaN);        // true
Number.isNaN(Number.NaN); // true
Number.isNaN(0 / 0)       // true
Number.isNaN("NaN");      // false

原型方法

toString

toString方法可以接受一个参数，表示输出的进制。如果省略这个参数，默认将数值先转为十进制，再输出字符串。

(10).toString(2) // "1010"
(10).toString(8) // "12"
(10).toString(16) // "a"

toFixed

toFixed()方法先将一个数转为指定位数的小数，然后返回这个小数对应的字符串。

(10).toFixed(2) // "10.00"
//由于浮点数的原因，小数5的四舍五入是不确定
(10.055).toFixed(2) // 10.05
(10.005).toFixed(2) // 10.01

toPrecision

toPrecision()方法用于将一个数转为指定位数的有效数字。

(12.34).toPrecision(1) // "1e+1"
(12.34).toPrecision(2) // "12"
(12.34).toPrecision(3) // "12.3"
(12.34).toPrecision(4) // "12.34"
(12.34).toPrecision(5) // "12.340"

该方法用于四舍五入时不太可靠

toExponential

toExponential() 方法用于将一个数转为科学计数法形式，参数是小数点后有效数字的位数，默认情况下用尽可能多的位数来显示数字。

(10).toExponential()  // "1e+1"
(10).toExponential(1) // "1.0e+1"
(10).toExponential(2) // "1.00e+1"
(1234).toExponential()  // "1.234e+3"
(1234).toExponential(1) // "1.2e+3"
(1234).toExponential(2) // "1.23e+3"

Math

静态属性

静态方法

Math.abs(-1) // 1
Math.floor(3.2) // 3
Math.floor(-3.2) // -4
Math.ceil(3.2) // 4
Math.ceil(-3.2) // -3
Math.round(0.1) // 0
Math.round(0.5) // 1
Math.round(-1.1) // -1
Math.round(-1.5) // -1
Math.max(2, -1, 5) // 5
Math.min(2, -1, 5) // -1
Math.random() // 0.7151307314634323
Math.pow(2, 3) // 8
Math.sqrt(4) // 2
Math.log(Math.E) // 1

Math对象还提供一系列三角函数方法

• Math.sin()：返回参数的正弦（参数为弧度值）
• Math.cos()：返回参数的余弦（参数为弧度值）
• Math.tan()：返回参数的正切（参数为弧度值）
• Math.asin()：返回参数的反正弦（返回值为弧度值）
• Math.acos()：返回参数的反余弦（返回值为弧度值）
• Math.atan()：返回参数的反正切（返回值为弧度值）

Date

以下四种方法同样可以创建 Date 对象：

var d = new Date(); //Tue Dec 14 2021 22:52:09 GMT+0800 (中国标准时间)
var d = new Date(milliseconds); // 毫秒单位的时间戳
var d = new Date(dateString); // 要是能被Date.parse()方法解析的字符串，都可以当作参数。
var d = new Date(year, month, day, hours, minutes, seconds, milliseconds); 
// 年和月是不能省略的，其他参数都可以省略的
// 注意，月份从0开始计算，但是，日数从1开始计算。
// 另外，除了日数的默认值为1，小时、分钟、秒钟和毫秒的默认值都是0。
// 数如果超出了正常范围，会被自动折算,负数会扣去

Date实例有一个独特的地方。其他对象求值的时候，都是默认调用.valueOf()方法，但是Date实例求值的时候，默认调用的是toString()方法。这导致对Date实例求值，返回的是一个字符串，代表该实例对应的时间。

两个日期实例对象进行减法运算时，返回的是它们间隔的毫秒数；进行加法运算时，返回的是两个字符串连接而成的新字符串。

var d1 = new Date(2000, 2, 1);
var d2 = new Date(2000, 3, 1);
d2 - d1
// 2678400000
d2 + d1
// "Sat Apr 01 2000 00:00:00 GMT+0800 (CST)Wed Mar 01 2000 00:00:00 GMT+0800 (CST)"

静态方法

• Date.now() 返回毫秒值的时间戳
• Date.parse() 解析日期字符串，返回毫秒值的时间戳。字符串应该符合 RFC 2822 和 ISO 8061 这两个标准，如果解析失败，返回NaN。
• Date.UTC() Date.UTC(year,month,day,hours,minutes,seconds,millisec)返回 1970 年 1 月 1 日 到指定日期的毫秒数

  RFC2822 day-of-week DD month-name YYYY HH:mm:ss ±timezone (时区用4位数字表示) Sat Jul 21 2018 00:00:00 GMT+0800 ISO8601 YYYY-MM-DDTHH:mm:ss.sss±timezone（时区用HH:MM表示）Z为UTC 2018-07-20T00:00:00+08:00

Date.now()  //1639494741518
Date.parse('Aug 9, 1995')
Date.parse('January 26, 2011 13:51:50')
Date.parse('Mon, 25 Dec 1995 13:30:00 GMT')
Date.parse('Mon, 25 Dec 1995 13:30:00 +0430')
Date.parse('2011-10-10')
Date.parse('2011-10-10T14:48:00')
Date.UTC(2012,02,30) //1333065600000
Date.UTC(1970,0,1) // 0

实例方法

Date的实例对象，有几十个自己的方法，除了valueOf和toString，可以分为以下三类。

• to类：从Date对象返回一个字符串，表示指定的时间。
• get类：获取Date对象的日期和时间。
• set类：设置Date对象的日期和时间。

  valueOf 方法返回实例对象距离时间零点（1970年1月1日00:00:00 UTC）对应的毫秒数，该方法等同于getTime，预期为数值的场合，Date实例会自动调用该方法

to类

get 类

所有这些get*方法返回的都是整数，不同方法返回值的范围不一样。

set类

这些方法基本是跟get*方法一一对应的，但是没有setDay方法，因为星期几是计算出来的，而不是设置的。

JSON

1. 复合类型的值只能是数组或对象，不能是函数、正则表达式对象、日期对象。
2. 原始类型的值只有四种：字符串、数值（必须以十进制表示）、布尔值和null（不能使用NaN, Infinity, -Infinity和undefined）。
3. 字符串必须使用双引号表示，不能使用单引号。
4. 对象的键名必须放在双引号里面。
5. 数组或对象最后一个成员的后面，不能加逗号。

JSON.stringify()

JSON.stringify()方法用于将一个值转为 JSON 字符串。该字符串符合 JSON 格式，并且可以被JSON.parse()方法还原。

JSON.stringify('abc') // ""abc""
JSON.stringify(1) // "1"
JSON.stringify(false) // "false"
JSON.stringify([]) // "[]"
JSON.stringify({}) // "{}"
JSON.stringify([1, "false", false]) // '[1,"false",false]'
JSON.stringify({ name: "张三" }) // '{"name":"张三"}'

第2个参数

JSON.stringify()方法还可以接受一个数组，作为第二个参数，指定参数对象的哪些属性需要转成字符串。

var obj = {
  'prop1': 'value1',
  'prop2': 'value2',
  'prop3': 'value3'
};
var selectedProperties = ['prop1', 'prop2'];
JSON.stringify(obj, selectedProperties) // "{"prop1":"value1","prop2":"value2"}"

第二个参数还可以是一个函数，用来更改JSON.stringify()的返回值。
注意，这个处理函数是递归处理所有的键。递归处理中，每一次处理的对象，都是前一次返回的值。
如果处理函数返回undefined或没有返回值，则该属性会被忽略。

function f(key, value) {
  if (typeof value === "number") {
    value = 2 * value;
  }
  return value;
}
JSON.stringify({ a: 1, b: 2 }, f)
// '{"a": 2,"b": 4}'

第3个参数

默认返回的是单行字符串，对于大型的 JSON 对象，可读性非常差。第三个参数使得每个属性单独占据一行，并且将每个属性前面添加指定的前缀。

// 默认输出
JSON.stringify({ p1: 1, p2: 2 })
// JSON.stringify({ p1: 1, p2: 2 })
// 分行输出
JSON.stringify({ p1: 1, p2: 2 }, null, '\t')
// {
//     "p1": 1,
//     "p2": 2
// }

第三个属性如果是一个数字，则表示每个属性前面添加的空格。

JSON.parse()

JSON.parse()方法用于将 JSON 字符串转换成对应的值。如果传入的字符串不是有效的 JSON 格式，JSON.parse()方法将报错。
为了处理解析错误，可以将JSON.parse()方法放在try…catch代码块中。

try {
  JSON.parse("'String'");
} catch(e) {
  console.log('parsing error');
}

JSON.parse()方法可以接受一个处理函数，作为第二个参数，用法与JSON.stringify()方法类似。