《你不知道的JavaScript-上卷》笔记

这段时间看了《你不知道的JavaScript》上卷，对很多知识有了重新的认识，所以在这里罗列一些知识点作为巩固。　

作用域和闭包

词法作用域

变量赋值操作会执行的两个动作

　　答：编译器会在当前作用域中声明一个变量，前提是之前没有声明过。运行时引擎会在内存中查找该变量然后为它赋值。

RHS 和 LHS 查询

　　答：查找容器用LHS查找，查找相应值用RHS查找

在作用域顶层无法找到目标变量，在严格模式和非严格模式下有什么结果？

　　答：非严格模式会创建一个全局变量，严格模式不会并且会报错。

with的副作用

　　答：将变量泄露到全局上

1 function foo( obj ) {
2   with( obj ) {
3     a = 2;
4   }
5 }
6 var obj = { b: 3 };
7 foo( obj );
8 console.log( obj.a ); // undefined
9 console.log( a ); // 2 -------> a泄露到了全局上

匿名函数的三个缺点

　　答：1、不利于调试

　　　　2、降低可读性

　　　　3、在递归时容易出错，由于递归是调用自身，匿名函数无法用函数名调用自身。

IIFE是什么

　　答：自执行函数，有两种形式：

1 (function(xx) {...})();
2 (function(xx) {...}());

JS的块作用域以及如何隐式模拟块作用域？

　　答：js没有强类型语言那样的块作用域，可以用let声明变量达到块作用域实现的效果。

let 和 var 在变量声明有什么区别？

　　答：let声明的变量不会提升，var会。

提升（变量、函数有什么区别）

　　答：函数比变量更早提升。

闭包

闭包产生的原理

1 function foo() {
2     function bar() {};
3      /*...*/
4 }

当函数可以记住并且访问所在的词法作用域时，就产生了闭包，即使函数是在当前词法作用域之外执行。
bar对foo内部作用域的引用就叫做闭包。

闭包遇上for循环，问题、机制、解决办法（考虑let）

　　答：详情参见我前面关于闭包的博客。

模块的两个必要条件

　　答：1、要有一个外部嵌套函数。

　　　　2、封闭函数必须返回至少一个内部函数。

import 和 module 的区别

　　答：import会导入模块中的一个或多个API分别绑定在一个变量上，module将整个模块的API导入并绑定到一个变量上。

this和对象原型

this

胖箭头 => 的作用原理

　　答：用当前词法作用域覆盖了this本来的值。

this是运行时绑定还是编译时绑定？

　　答：运行时。

this的四个绑定及其原理

　　答：1、默认绑定：默认绑定全局变量window。

　　　　2、隐式绑定

　　　　3、显式绑定：使用call()、apply()

　　　　4、new绑定：函数创建对象时用new

绑定的优先级

　　答：new、显式 > 隐式 > 默认

为什么setTimeout()中的this会默认绑定到window?

　　答：setTimeout是一个定义在全局中的函数，所以该函数的this默认为window。

写一个硬绑定bind(obj, target);

1 function bind(fn, target) {
2   return function() {
3     return fn.apply(target, arguments);
4   };
5 }

硬绑定的优势

　　答：任由外部如何变动，内部的this绑定对象不会改变。

使用new调用函数时会发生的四个步骤？

　　答：1、创建一个全新的对象。

　　　　2、对这个新对象执行[prototype]链接。
　　　　3、这个新对象会被绑定到函数调用的this。

　　　　4、如果函数没有返回值，那么new表达式中的函数调用会自动返回这个新对象，否则返回函数返回值。

对象

js中的六个基本类型、六个内置对象

　　答：六个基本类型：null、string、number、boolean、undefined、object

　　　　六个内置对象：String、Number、Boolean、Object、Function、Array

函数从来不会属于某一个对象

对象中内置的get函数的函数名和函数值分别代表什么？

　　答：函数名------->对象属性名，函数值------->对象属性值

in 和 hasOwnPrototype 的区别

　　答：in会在对象中以及原型链中查找对象是否含有该属性，而hasOwnPrototype只会在该对象中查找。

for...in 的特点？为什么说数组的遍历尽量不用 for...in？

　　答：会遍历对象所有可枚举的属性，并且不一定按照顺序遍历。

类

类的继承其实就是复制，js不能复制

隐式混入和显式混入的区别

　　答：前者直接全部“复制”过来，后者用call、apply

原型

原型链上存在隐式屏蔽

Foo.prototype的 .constructor 属性是一直存在的吗？

　　答：不是，它是默认的。当你的prototype对象改变了，这个属性就不存在了除非你手动添加。

var b = Object.create(a);的作用机制

　　答：创建一个对象b并关联到a。

行为委托

一句话概括

　　答：函数的继承，对象的委托

委托的两个原则

　　答：1、状态保存在委托者，而不是委托目标。

　　　　2、避免在[prototype]链上的不同位置使用相同的命名

委托的实质？

　　答：某些对象找不到方法或者属性的引用时可以把请求委托给另一个对象。

根据下面函数继承写出相应的行为委托

函数继承：

1 function A(name) {
2   this.name = name;
3 }
4 A.prototype.sayName = function() {
5   console.log(this.name);
6 };
7 function B(name) {
8   A.call(this, name);
9 }
10 B.prototype = Object.create(A.prototype);
11 var b = new B('Nic');
12 b.sayName(); //Nic

行为委托：

1 var A = {
2   init: function(name) { this.name = name; },
3   sayName: function() { console.log(this.name); }
4 };
5 var B = Object.create(A);
6 B.init('Nic');
7 B.sayName() //Nic

怎么改变的：

将函数封装对象

将构造函数内部的变量定义封装成一个函数

将prototype对象的函数逐一封装进该对象

将两个对象关联

此时没有继承的说法了，关联不是上下级的关系，而是任意的

关联后可以自定义或者封装新对象的一些属性及方法

注意：尽量避免暴露委托

class

class不能声明属性只能声明方法

1 class A {
2   constructor(name, age) {
3     this.name = name;
4     this.age = age;
5   }
6   sayName() {
7     console.log('hello, my name is: '+this.name);
8   }
9 }
10 var a = new A('wind', 20);
11 a.sayName(); //hello, my name is: wind

API设计原则

最小特权原则：最小限度的暴露必要内容，而将其他内容都“隐藏”起来（将变量声明在某个作用域内尽量不在全局作用域中）

尽量避免匿名函数

关联关系中尽量避免函数名重复，会引发屏蔽覆盖的副作用

内部委托（在内部调用）比直接委托（直接使用）可以让API接口更加清晰

委托最好在内部实现，不要轻易的暴露出去