>undefined与null的区别

undefined  代表已经定义，但未赋值

null  代表已经定义并且赋值，只是值为null

>什么时候给变量赋值为null

- 初始赋值，表明将要为一个变量赋值，使之成为一个对象

- 结束前，让某个变量指向的对象成为垃圾对象（被垃圾回收器回收）

>什么是函数？

- 实现特定功能的n条语句的封装体

- 只有函数是可以执行的，其他类型的数据不能执行

>为什么要用函数？

- 提高代码的复用

- 便于阅读交流

>如何定义函数？

- 函数声明 function fn (){}

- 表达式 var obj = function(){};

>如何调用（执行）函数？

- test()：直接调用

- obj.test()：通过对象调用

- new test()：new调用

- test.call/apply(obj)：临时让test成为obj的方法进行调用

>什么函数才是回调函数？

1).你定义的

2).你没有调用

3).但最终它执行了

>常见的回调函数

- dom事件回调函数（onclick 等等）

- 定时器回调函数  （延时定时器，循环定时器）

- ajax请求回调函数

- 生命周期回调函数

>什么叫IIFE

1）理解

立即执行函数表达式

2）作用

- 隐藏实现（可以将函数，变量声明放入其中，使其只在局部作用）

- 不会污染外部（全局）命名空间

( function( ){

        var obj = xxx;

} )( )

>函数中的this

1）this是什么？

- 任何函数本质上都是通过某个对象来调用的，如果没有直接指定就是window

- 所有函数内部都有一个变量this

- 它的值是调用函数的当前对象

2）如何确定thie的值？

- test( )： // window

- p.test( )： // p

- var p = new test( )：//新创建的对象p

- p.call(obj)： // obj

>函数的prototype属性

- 每个函数都有一个prototype属性，它默认指向一个Object空对象（即称为原型对象）

- 原型对象中有一个属性constructor，它指向函数对象

  给原型对象添加属性（一般都是方法）

- 作用：函数的所有实例对象自动拥有原型中的属性（方法）

function Fun ( ) {  } //声明一个Fun函数（构造函数）

Fun.prototype.test=function ( ) { //为Fun的原型对象添加test方法

console.log( " abc " );

};

var fun = new Fun( ); //新建一个Fun函数的实例

fun.test( ); //返回abc

>显式原型与隐式原型

- 每个函数function都有一个prototype，即显式原型（属性）

- 每个实例对象都有一个__proto__，成为隐式原型（属性）

- 对象的隐式原型的值为其对应构造函数的显式原型的值

- 内存结构（图）

- 总结

* 函数的prototype属性：在定义时自动添加的，默认值是一个空Object实例对象

* 对象的__proto__属性：创建对象时自动添加的，默认值为其构造函数的prototype属性值

* 程序员能直接操作显示原型，但不能直接操作隐式原型（ES6之前）

>原型链

* 访问一个对象属性时，先在自身属性中查找，找到返回，如果没有，再沿着__proto__这条链向上查找，找到返回，如果最终没有找到，返回undefined

* 别名：隐式原型连

* 作用：查找对象的属性（方法）

* 补充：

1）函数的显式原型指向的对象默认是空Object实例对象（但Object不满足）

2）所有函数都是Function的实例（包含Function也是其自身的实例）

3）Object的原型对象时原型链的尽头

* 原型链的属性问题

1）读取对象的属性值时，会自动到原型链中查找

2）设置对象的属性值时，不会查找原型链，如果当前对象没有此属性值，直接添加此属性并设置其值

3）方法一般定义在原型中，属性一般通过构造函数定义在对象本身上

>instanceof

- 如何判断

1）表达式：A instanceof B

2）如果B函数的显示原型对象，在A对象的原型链上，返回true，否则返回false

- Function是通过new自己产生的实例  （ var Function = new Function( ); ）

>变量提升与函数提升

- 变量声明提升

* 通过var定义（声明）的变量，在定义语句之前就可以访问到

* 值：undefined

- 函数声明提升

* 通过function声明的函数，在之前就可以直接调用

* 值：函数定义（对象）

>执行上下文

- 代码分类（位置）

* 全局代码

* 函数（局部）代码

- 全局执行上下文

* 在执行全局代码前将window确定为全局执行上下文

* 对全局数据进行预处理

1）var 定义的全局变量 ==>undefined，添加为window的属性

2）function声明的全局函数==>赋值（fun），添加为window的方法

3）this==>赋值（window）

* 开始执行全局代码

- 函数执行上下文

* 在调用函数，准备执行函数体之前，创建对应的函数执行上下文对象

* 对局部数据进行预处理

1）形参变量==>赋值（实参）==>添加为执行上下文的属性

2）arguments==>赋值（实参列表），添加为执行上下文的属性

3）var 定义的局部变量==>undefined，添加为执行上下文的属性

4）function声明的函数==>赋值（fun），添加为执行上下文的方法

5）this==>赋值（调用函数的对象）

* 开始执行函数体代码

>执行上下文栈

* 在全局代码执行前，JS引擎就会创建一个栈来存储管理所有的执行上下文对象

* 在全局执行上下文（window）确定后，将其添加到栈中（压栈）

* 在函数执行上下文创建后，将其添加到栈中（压栈）

* 在当前函数执行完后，将栈顶的对象移除（出栈）

* 当所有的代码执行完后，栈中只剩下window

>作用域与作用域链

- 理解： * 就是一块“地盘”，一个代码段所在的区域

* 它是静态的（相对于上下文对象），在编写代码的时候就确定了

- 分类： * 全局作用域

* 函数作用域

* 没有块作用域（ES6有了）

- 作用：隔离变量，不同作用域下同名变量不会有冲突

- 区别：

1）区别1

* 全局作用域外，每个函数都会创建自己的作用域，作用域在定义函数的时候就已经确定了，而不是在函数调用时

* 全局执行上下文环境是在全局作用域确定之后，JS代码马上执行之前创建

* 函数执行上下文时在调用函数时，函数体代码执行之前创建

2）区别2

* 作用域是静态的，只要函数定义好了就一直存在，且不会再变化

* 执行上下文是动态的，调用函数时创建，函数调用结束时上下文环境就会自动释放

3）联系

* 执行上下文（对象）是从属于所在的作用域

* 全局上下文环境==>全局作用域

* 函数上下文环境==>对应的函数作用域

>闭包

1）如何产生闭包

* 当一个嵌套的内部（子）函数引用了嵌套的外部（父）函数的变量（函数）时，就产生了闭包

2）闭包到底是什么？

* 使用chrome调试查看

* 理解一：闭包时嵌套的内部数据（绝大部分人）

* 理解二：包含被引用变量（函数）的对象（极少数人）

* 注意：闭包存在于嵌套的内部函数中

3）产生闭包的条件？

* 函数嵌套

* 内部引用了外部函数的数据（变量/函数）

* 调用了外部函数

4）闭包的作用

* 使函数内部的变量在函数执行完之后，仍然存活在内存中（延长了局部变量的生命周期）

* 让函数外部可以操作（读写）到函数内部的数据（变量/函数）

5）问题

* 函数执行完后，函数内部声明的局部变量是否还存在？

答：一般是不存在，存在于闭包中的变量才可能存在

* 在函数外部能直接访问函数内部的局部变量吗？

答：不能，但我们可以通过闭包让外部操作它

>闭包的生命周期

- 产生：在嵌套内部函数定义执行完成时就产生了（不是在调用，仅仅是定义）

- 死亡：在嵌套的内部函数成为垃圾对象时

>闭包的应用

- 定义JS模块

* 具有特定功能的JS文件

* 将所有的数据和功能都封装在一个函数内部（私有的）

* 只向外暴露一个包含n个方法的对象或函数

* 模块的使用者，只需要通过模块暴露的对象调用方法来实现对应的功能

>闭包的缺点

1）缺点：

* 函数执行完后，函数内的局部变量没有释放，占用内存时间会变长

* 容易造成内存泄漏

2）解决：

* 能不用闭包就不用闭包（很难不会去用到闭包，所以及时释放就好）

* 及时释放

>内存溢出与内存泄漏

1）内存溢出：

* 一种程序运行出现的错误

* 当程序员需要的内存超过了剩余的内存时，就出现内存溢出的错误

2）内存泄漏：

* 占用的内存没有及时释放

* 内存泄漏积累多了就容易导致内存溢出

* 常见的内存泄漏：

- 意外的全局变量（例如函数中声明的变量没有带 var ）

- 没有及时清理的计时器或回调函数

- 闭包

>对象创建模式

1）Object构造函数模式

* 套路：先创建空Object对象，再动态添加属性/方法

* 适用场景：起始时不确定对象内部数据

* 问题：语句太多

例：

var p = new Object( );

p.name = "tom";

p.age = 12;

p.setName = function( ){

this.name = name

}

2）对象字面量模式：

* 套路：使用{ }创建对象，同时制定属性/方法

* 适用场景：起始时对象内部数据是确定的

* 问题：如果创建多个对象，有重复代码

例：

var p = {

name : "tom",

age: 12,

setName : function( name ){

this.name = name;

}

}

3）工厂模式：

* 套路：通过工厂函数动态创建对象并返回

* 适用场景：需要创建多个对象

* 问题：对象没有一个具体的类型，都是Object类型

例：

function createPerson( name , age ){

var obj = {

name : name,

age : age,

setName : function ( name ){

this.name = name;

}

}

return obj;

}

createPerson( "jack","12");

createPerson("bob","18");

4）自定义构造函数模式

5）构造函数+原型的组合模式

>线程与进程

1）进程：

* 程序的一次执行，它占有一片独有的内存空间

* 可以通过windows任务管理器查看进程

2）线程：

* 是进程内的一个独立执行单元

* 是程序执行的一个完整流程

* 是CPU的最小调度单元

3）关系：

* 一个进程至少有一个线程（主线程）

* 程序是在某个进程中的某个线程执行的

>浏览器内核模块组成

1）主线程

* js引擎模块：负责js程序的编译与运行

* html,css文档解析模块：负责页面文本的解析

* DOM/CSS模块：负责dom/css在内存中的相关处理

* 布局和渲染模块：负责页面的布局和效果的绘制（内存中的对象）

2）分线程

* 定时器模块：负责定时器的管理

* 事件响应模块：负责时间的管理

* 网络请求模块：Ajax请求

>js线程

* js是单线程执行的（回调函数也是在主线程）

* H5提出了实现多线程的方法：Web Workers

* 只能是主线程更新界面

>定时器问题

* 定时器并不真正完全定时

* 如果在主线程执行了一个长时间的操作，可能导致延时才处理

>事件处理机制（图）

- 代码分类

* 初始化执行代码：包含绑定dom事件监听，设置定时器，发送ajax请求的代码

* 回调执行代码：处理回调逻辑

- js引擎执行代码的基本流程

* 初始化代码===>回调代码

- 模型的2个重要组成部分：

* 事件的管理模块

* 回调队列

- 模型的运转流程

* 执行初始化代码，将事件回调函数交给对应的模块管理

* 当事件发生时，管理模块会将回调函数及其数据添加到回到队列中

* 只有当初始化代码执行完成（可能需要一定的时间），才会遍历读取回调队列中的回调函数并执行

>H5 Web Workers

* 可以让js在分线程执行

* Worker

* 问题

- worker内代码不能操作DOM更新UI

- 不是每个浏览器都支持这个新特性

- 不能跨域加载JS