今天完成的事情：

明天计划的事情：

遇到的问题：

Angular8学习遇到阻碍，暂时先学习ES6、typescript、rxjs的一些东西，等师兄demo完指导我angular

收获：

记录下ES6中认为比较重要的知识点（阮一峰ES6标准入门）：

数值的扩展

Math.trunc()

Math.trunc 方法用于去除一个数的小数部分，返回整数部分。

Math.trunc(4.1) // 4

Math.trunc(4.9) // 4

Math.trunc(-4.1) // -4

Math.trunc(-4.9) // -4

Math.trunc(-0.1234) // -0

对于非数值， Math.trunc 内部使用 Number 方法将其先转为数值。

Math.trunc('123.456') // 123

Math.trunc(true) //1

Math.trunc(false) // 0

Math.trunc(null) // 0

对于空值和无法截取整数的值，返回 NaN 。

Math.trunc(NaN); // NaN

Math.trunc('foo'); // NaN

Math.trunc(); // NaN

Math.trunc(undefined) // NaN

对于没有部署这个方法的环境，可以用下面的代码模拟。

Math.trunc = Math.trunc || function(x) {

 return x < 0 ? Math.ceil(x) : Math.floor(x);

}

Math.sign()

Math.sign 方法用来判断一个数到底是正数、负数、还是零。对于非数值，会先将其转换为数值。

它会返回五种值。

参数为正数，返回 +1 ；

参数为负数，返回 -1 ；

参数为 0，返回 0 ；

参数为-0，返回 -0 ;

其他值，返回 NaN 。

Math.sign(-5) // -1

Math.sign(5) // +1

Math.sign(0) // +0

Math.sign(-0) // -0

Math.sign(NaN) // NaN

如果参数是非数值，会自动转为数值。对于那些无法转为数值的值，会返回 NaN 。

Math.sign('') // 0

Math.sign(true) // +1

Math.sign(false) // 0

Math.sign(null) // 0

Math.sign('9') // +1

Math.sign('foo') // NaN

Math.sign() // NaN

Math.sign(undefined) // NaN

Math.cbrt()

Math.cbrt 方法用于计算一个数的立方根。

Math.cbrt(-1) // -1

Math.cbrt(0) // 0

Math.cbrt(1) // 1

Math.cbrt(2) // 1.2599210498948734

对于非数值， Math.cbrt 方法内部也是先使用 Number 方法将其转为数值。

Math.cbrt('8') // 2

Math.cbrt('hello') // NaN

指数运算符

ES2016 新增了一个指数运算符（ ** ）。

2 ** 2 // 4

2 ** 3 // 8

指数运算符可以与等号结合，形成一个新的赋值运算符（ **= ）。

let a = 1.5;

a **= 2;

// 等同于 a = a * a;

let b = 4;

b **= 3;

// 等同于 b = b * b * b;

注意，在 V8 引擎中，指数运算符与 Math.pow 的实现不相同，对于特别大的运算结果，两者会有细微的差异。

 Integer 数据类型

JavaScript 所有数字都保存成 64 位浮点数，这决定了整数的精确程度只能到 53 个二进制位。大于这个范围的整数，JavaScript 是无法精确表示的，

这使得 JavaScript 不适合进行科学和金融方面的精确计算。

现在有一个提案，引入了新的数据类型 Integer（整数），来解决这个问题。整数类型的数据只用来表示整数，没有位数的限制，任何位数的整数都可以

精确表示。

为了与 Number 类型区别，Integer 类型的数据必须使用后缀 n 表示。

1n + 2n // 3n

二进制、八进制、十六进制的表示法，都要加上后缀 n 。

0b1101n // 二进制

0o777n // 八进制

0xFFn // 十六进制

typeof 运算符对于 Integer 类型的数据返回 integer 。

typeof 123n

// 'integer'

JavaScript 原生提供 Integer 对象，用来生成 Integer 类型的数值。转换规则基本与 Number() 一致。

Integer(123) // 123n

Integer('123') // 123n

Integer(false) // 0n

Integer(true) // 1n

以下的用法会报错。

new Integer() // TypeError

Integer(undefined) //TypeError

Integer(null) // TypeError

Integer('123n') // SyntaxError

Integer('abc') // SyntaxError

函数的扩展

1. 函数参数的默认值

ES6 之前，不能直接为函数的参数指定默认值，只能采用变通的方法。

function log(x, y) {

 y = y || 'World';

 console.log(x, y);

}

log('Hello') // Hello World

log('Hello', 'China') // Hello China

log('Hello', '') // Hello World

上面代码检查函数 log 的参数 y 有没有赋值，如果没有，则指定默认值为 World 。这种写法的缺点在于，如果参数 y 赋值了，但是对应的布尔值为

false ，则该赋值不起作用。就像上面代码的最后一行，参数 y 等于空字符，结果被改为默认值。为了避免这个问题，通常需要先判断一下参数 y 是否被赋值，如果没有，再等于默认值。

if (typeof y === 'undefined') {

 y = 'World';

}

ES6 允许为函数的参数设置默认值，即直接写在参数定义的后面。

function log(x, y = 'World') {

 console.log(x, y);

}

log('Hello') // Hello World

log('Hello', 'China') // Hello China

log('Hello', '') // Hello

2、

函数的 length 属性

指定了默认值以后，函数的 length 属性，将返回没有指定默认值的参数个数。也就是说，指定了默认值后， length 属性将失真。

(function (a) {}).length // 1

(function (a = 5) {}).length // 0

(function (a, b, c = 5) {}).length // 2

上面代码中， length 属性的返回值，等于函数的参数个数减去指定了默认值的参数个数。比如，上面最后一个函数，定义了 3 个参数，其中有一个参数 c

指定了默认值，因此 length 属性等于 3 减去 1 ，最后得到 2 。

这是因为 length 属性的含义是，该函数预期传入的参数个数。某个参数指定默认值以后，预期传入的参数个数就不包括这个参数了。同理，后文的 rest

参数也不会计入 length 属性

3、

作用域

一旦设置了参数的默认值，函数进行声明初始化时，参数会形成一个单独的作用域（context）。等到初始化结束，这个作用域就会消失。这种语法行为，

在不设置参数默认值时，是不会出现的。

var x = 1;

function f(x, y = x) {

 console.log(y);

}

f(2) // 2

上面代码中，参数 y 的默认值等于变量 x 。调用函数 f 时，参数形成一个单独的作用域。在这个作用域里面，默认值变量 x 指向第一个参数 x ，而不是全局

变量 x ，所以输出是 2 。

let x = 1;

function f(y = x) {

 let x = 2;

 console.log(y);

}

f() // 1

上面代码中，函数 f 调用时，参数 y = x 形成一个单独的作用域。这个作用域里面，变量 x 本身没有定义，所以指向外层的全局变量 x 。函数调用时，函

数体内部的局部变量 x 影响不到默认值变量 x 。

如果此时，全局变量 x 不存在，就会报错。

function f(y = x) {

 let x = 2;

 console.log(y);

}

f() // ReferenceError: x is not defined

4、

箭头函数

基本用法

ES6 允许使用“箭头”（ => ）定义函数。

var f = v => v;

上面的箭头函数等同于：

var f = function(v) {

 return v;

};

如果箭头函数不需要参数或需要多个参数，就使用一个圆括号代表参数部分。

var f = () => 5;

// 等同于

var f = function () { return 5 };

var sum = (num1, num2) => num1 + num2;

// 等同于

var sum = function(num1, num2) {

 return num1 + num2;

};

如果箭头函数的代码块部分多于一条语句，就要使用大括号将它们括起来，并且使用 return 语句返回。

var sum = (num1, num2) => { return num1 + num2; }

由于大括号被解释为代码块，所以如果箭头函数直接返回一个对象，必须在对象外面加上括号，否则会报错。

// 报错

let getTempItem = id => { id: id, name: "Temp" };

// 不报错

let getTempItem = id => ({ id: id, name: "Temp" });

如果箭头函数只有一行语句，且不需要返回值，可以采用下面的写法，就不用写大括号了。

let fn = () => void doesNotReturn();

箭头函数可以与变量解构结合使用。

const full = ({ first, last }) => first + ' ' + last;

// 等同于

function full(person) {

 return person.first + ' ' + person.last;

}

箭头函数使得表达更加简洁。

const isEven = n => n % 2 == 0;

const square = n => n * n;

上面代码只用了两行，就定义了两个简单的工具函数。如果不用箭头函数，可能就要占用多行，而且还不如现在这样写醒目。

箭头函数的一个用处是简化回调函数。 

// 正常函数写法

[1,2,3].map(function (x) {

 return x * x;

});

// 箭头函数写法

[1,2,3].map(x => x * x);

箭头函数有几个使用注意点。

（1）函数体内的 this 对象，就是定义时所在的对象，而不是使用时所在的对象。

（2）不可以当作构造函数，也就是说，不可以使用 new 命令，否则会抛出一个错误。

（3）不可以使用 arguments 对象，该对象在函数体内不存在。如果要用，可以用 rest 参数代替。

（4）不可以使用 yield 命令，因此箭头函数不能用作 Generator 函数。

上面四点中，第一点尤其值得注意。 this 对象的指向是可变的，但是在箭头函数中，它是固定的。

function foo() {

 setTimeout(() => {

 console.log('id:', this.id);

 }, 100);

}

var id = 21;

foo.call({ id: 42 });

// id: 42

上面代码中， setTimeout 的参数是一个箭头函数，这个箭头函数的定义生效是在 foo 函数生成时，而它的真正执行要等到 100 毫秒后。如果是普通函

数，执行时 this 应该指向全局对象 window ，这时应该输出 21 。但是，箭头函数导致 this 总是指向函数定义生效时所在的对象（本例是 {id: 42} ），所

以输出的是 42 。