JS高级（2）——函数高级

function Fn() {

}
console.log(Fn.prototype);

var fn = new Fn();

console.log(fn.__proto__);

console.log(Fn.prototype===fn.__proto__);//true

Fn.prototype.test = function () {
  console.log("test()");
}

fn.test();

内存结构
总结：

函数的prototype属性：在定义函数的时候自动添加，默认值是一个空Object对象。
对象的__proto__属性：创建对象时自动添加，默认值为构造函数的prototype属性值。
程序员能直接操作显示原型，但不能直接操作隐式原型（ES6之前）

原型链

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

别名：隐式原型链。

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

函数的隐式原型指向的对象：默认是空Object实例对象（但Object不满足）
Function是它自身的实例（包含Function）
Object的原型对象是原型链的尽头。
属性问题：
- 读取对象的属性值时：会自动到原型链中查找，
- 设置对象的属性值时：不会查找原型链，如果当前对象没有此属性，直接添加此属性并设置其值。
- 方法一般定义在原型中，属性一般通过构造函数定义在对象本身上。

var fn1 = new Fn();
console.log(fn1.a);//xxx

var fn2 = new Fn();
fn2.a = "yyy";
console.log(fn1.a,fn2.a,fn2);//xxx yyy

探索instanceof：

instanceof是如何判断的？

表达式：A instanceof B

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

/*
案例一
*/
function Foo(){}
var f1 = new Foo();
console.log(f1 instanceof Foo);//true
console.log(f1 instanceof Object);//true

/*
案例二
 */
 console.log(Object instanceof Function);//true
 console.log(Object instanceof Object);//true
 console.log(Function instanceof Function);//true
 console.log(Function instanceof Object);//true

Function是通过new自己产生的实例。

执行上下文与执行上下文栈

变量提升与函数提升

变量声明提升：
- 通过var定义（声明）的变量，在定义语句之前就可以访问到
- 值：undefined

var a = 3;
function fn() {
  console.log(a);
  var a = 4;
}
fn();//undefined

函数声明提升：

通过function声明的函数，在之前就可以直接调用
值：函数定义（对象）

fn2();//可调用,函数提升

function fn2() {
	console.log("fn2()");
}

fn3();//不能调用，变量提升

var fn3 = function(){
  console.log("fn3()");
}

问题：变量提升和函数提升是如何产生的？

执行上下文

代码分类（位置）
- 全局代码
- 函数（局部）代码
全局执行上下文
- 在执行全局代码前将window确定为全局执行上下文
- 对全局数据进行预处理：
  - var定义的全局变量 ==> undefined，添加为window的属性
  - funnction声明的全局函数 ==> 赋值（fun），添加为window的方法
  - this ==> 赋值（window）
- 开始执行全局代码
函数执行上下文
- 在调用函数，准备执行函数体之前，创建对应的函数执行上下文对象（虚拟的，存在于栈中）
- 对局部数据进行预处理：
  - 形参变量 ==> 赋值（实参） ==> 添加为执行上下文的属性
  - arguments ==> 赋值（实参列表），添加为执行上下文的属性
  - var定义的局部变量 ==> undefined，添加为执行上下文的属性
  - function声明的函数 ==> 赋值（fun），添加为执行上下文的方法
  - this ==> 赋值（调用函数的对象）
- 开始执行函数体代码

执行山下文栈

在全局代码执行前，JS引擎就会传建一个栈来存储管理所有的执行上下文对象。
在全局执行上下文（window）确定后，将其添加到栈中（压栈）
在函数执行上下文创建后，将其添加到栈中（压栈）
当前函数执行完后，将栈顶的对象移除（出栈）
当所有的代码执行完后，栈中只剩下window。

测试：

console.log("global begin:"+i);
var i = 1;
foo(1);
function foo(i) {
  if (i == 4){
 	 return;
  }
  console.log("foo() begin:"+i);
  foo(i+1);//递归调用：在函数内部调用自己
  console.log("foo() end:"+i);
}
console.log("global end:"+i);

JS高级（2）——函数高级

<script type="text/javascript">
  function a() {

  }
  var a;
  console.log(typeof a);//"function"

  if(!(b in window)){
      var b = 1;
  }
  console.log(b);//undefined

  var c = 1;
  function c(c) {
    console.log(c);
  }
  c(2);//报错：c is not a function
</script>

作用域与作用域链

作用域

理解
- 就是一块”地盘”，一个代码段所在的区域
- 它是静态的（相对与上下文对象），在编写代码时就确定了
分类
- 全局作用域
- 函数作用域
- 没有块作用域（ES6有了）
作用
- 隔离变量，不同作用域下同名变量不会有冲突

与执行上下文关系

区别一：
- 全局作用域之外，每个函数都会出创建自己的作用域，作用域在函数定义时就已经确定了。而不是在函数调用时。
- 全局执行上下文是在全局作用域确定之后，JS代码执行之前创建。
- 函数执行上下文是在调用函数时，函数体代码执行之前创建的。
区别二：
- 作用域是静态的，只要函数定义好了就一直存在，且不会再发生变化。
- 执行上下文是动态的，调用函数时创建，函数调用结束时上下文环境就会自动释放。
联系：
- 上下文是从属于所在的作用域
- 全局上下文 ==> 全局作用域
- 函数上下文 ==> 对应的函数作用域

作用域链

理解
- 多个上下级关系的作用域形成链，它的方向是从下向上的（从内到外）
- 查找变量时就是沿着作用域链来查找的
查找一个变量的查找规则
- 在当前作用域下的执行上下文中查找对应的属性，如果有直接返回，否则进入下一步。
- 在上一级作用域的执行上下文中查找对应的属性，如果有则直接返回，否则进入下一步。
- 再次执行上一步的相同操作，直到全局作用域，如果还找不到就抛出找不到的异常。

闭包

实例（利用闭包），需求：点击某个按钮，提示：“点击的是第n个按钮”。

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>06_闭包</title>
</head>
<body>

<button>测试1</button>
<button>测试2</button>
<button>测试3</button>
<!--
    需求：点击某个按钮，提示："点击的是第n个按钮"
-->

<script type="text/javascript">
    var btns = document.getElementsByTagName('button');


    //遍历加监听

    // for (var i = 0,length = btns.length; i < length; i++) {
    //     var btn = btns[i];
    //     //将btn所对应的下标保存在btn上
    //     btn.index = i;
    //     btn.onclick = function () {
    //       alert("第"+(this.index+1)+"个");
    //     }
    // }


    //利用闭包
    for (var i = 0,length=btns.length; i < length; i++) {
        (function (i) {
          var btn = btns[i];
          btn.onclick = function () {
            alert("第"+(i+1)+"个");
          }
        })(i);

    }

    // //1.将函数作为另一个函数的返回值
    // function fn1() {
    //   var a = 2;
    //   function fn2() {
    //     a++;
    //     console.log(a);
    //   }
    //   return fn2;
    //
    // }
    // var f = fn1();
    // f();//3
    // f();//4
		//f = null;//闭包死亡

    //2.将函数作为实参传递给另一个函数调用
    function showDelay(msg,time) {
      setTimeout(function () {
        alert(msg);//产生闭包msg
      },time);
    }
    showDelay("aniu",2000);
</script>
</body>
</html>

如何产生闭包？
- 当一个嵌套的内部（子）函数引用了嵌套外部（父）函数的变量时，就产生了闭包。
闭包到底是什么？
- 使用chrome调试查看
- 理解一：闭包是嵌套的内部函数（绝大部分人）
- 理解二：包含被引用变量（函数）的对象（极少数人）
- 注意：闭包存在于嵌套的内部函数中。
产生闭包的条件？
- 函数嵌套
- 内部函数引用了外部函数的数据（变量/数据）
闭包的作用：
1. 使用函数内部的变量在函数执行完后，仍然存货在内存中（延长了局部变量的生命周期）
2. 让函数外部可以操作（读写）到函数内部的数据（变量/函数）
闭包的生命周期：
- 产生：在嵌套内部函数定义执行完时就产生了（不是在调用）
- 死亡：在嵌套内部函数称为垃圾对象时。
闭包的应用：定义JS模块
- 具有特定功能的JS文件
- 将所有的数据和功能都封装在一个函数内部（私有的）
- 只向外暴露一个包含n个方法的对象或函数
- 模块的使用者，只需要通过模块暴露的对象调用方法来实现对对应的功能

第一种方式：

function myModule() {
    //私有数据
  var msg = "My js";
  function doSomething() {
    console.log("doSomething()"+msg.toUpperCase());
  }
  function doOtherthing() {
    console.log("doOtherthing()"+msg.toLowerCase());
  }
    //向外暴露对象（给外部使用的方法）
  return {
      doSomething:doSomething,
      doOtherthing:doOtherthing
  };
}

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>06_闭包</title>
</head>
<body>
<script type="text/javascript" src="myModule.js"></script>
<script type="text/javascript">
   var module = myModule();
   module.doSomething();
   module.doOtherthing();
</script>
</body>
</html>

第二种方式：

(function (window) {
    //私有数据
    var msg = "My js";
    function doSomething() {
        console.log("doSomething()"+msg.toUpperCase());
    }
    function doOtherthing() {
        console.log("doOtherthing()"+msg.toLowerCase());
    }

    window.myModule2 = {
        doSomething:doSomething,
        doOtherthing:doOtherthing
    }
})(window)

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>06_闭包</title>
</head>
<body>
<script type="text/javascript" src="myModule2.js"></script>
<script type="text/javascript">
   myModule2.doSomething();
   myModule2.doOtherthing();
</script>
</body>
</html>

闭包的缺点和解决
- 缺点：函数执行完后，函数内的局部变量没有释放，占用内存会变长。容易造成内存泄露。
- 解决：能不用闭包就不用闭包。及时释放。

function fn1() {
  var arr = new Array[100000];
  function fn2() {
    console.log(arr.length);
  }
  return fn2;
}
var f = fn1();
f();

f = null;//让内部函数称为垃圾对象 --> 回收闭包

内存溢出和内存泄露
- 内存溢出：一种程序运行出现的错误，当程序运行需要的内存超过了剩余的内存时，就会抛出内存溢出的错误。
- 内存泄露：占用的内存没有及时释放，内存泄露累积多了就容易导致内存溢出，常见的内存泄露：意外的全局变量、没有及时清理的计时器或回调函数、闭包。
闭包题目：

<script type="text/javascript">

    function fun(n,o) {
        console.log(o);
        return {
            fun:function (m) {
              return fun(m,n);
            }
        }
    }

    var a = fun(0);//undefined
    a.fun(1);//0
    a.fun(2);//0
    a.fun(3);//0

    var b = fun(0).fun(1).fun(2).fun(3);//undefined,0,1,2

    var c = fun(0).fun(1);//undefined,0
    c.fun(2);//1
    c.fun(3);//1

</script>

JS高级（2）——函数高级

文章目录

函数高级

原型与原型链

原型链

执行上下文与执行上下文栈

执行上下文

执行山下文栈

作用域与作用域链

作用域

与执行上下文关系

作用域链

闭包

js高级第四天

JS高级（2）——函数高级

js高级03

MySQL高级特性之集合函数(1)

photoshop学习网站 PHP学习mysql课件高级篇第1/2页

JavaScript高级程序设计（第3版）学习笔记10 再访js对象_基础知识

前端攻城狮---js对象的高级使用(2)

JS高级---识别正则表达式是否匹配

python中的内置函数max()和min()及mas()函数的高级用法

JavaScript高级程序设计阅读笔记（二十） js错误处理_javascript技巧

JS高级（2）——函数高级

文章目录

函数高级

原型与原型链

原型链

执行上下文与执行上下文栈

执行上下文

执行山下文栈

作用域与作用域链

作用域

与执行上下文关系

作用域链

闭包

js高级第四天

JS高级（2）——函数高级

js高级03

MySQL高级特性之集合函数(1)

photoshop学习网站 PHP学习mysql课件 高级篇第1/2页

JavaScript高级程序设计（第3版）学习笔记10 再访js对象_基础知识

前端攻城狮---js对象的高级使用(2)

JS高级---识别正则表达式是否匹配

python中的内置函数max()和min()及mas()函数的高级用法

JavaScript高级程序设计 阅读笔记（二十） js错误处理_javascript技巧

photoshop学习网站 PHP学习mysql课件高级篇第1/2页

JavaScript高级程序设计阅读笔记（二十） js错误处理_javascript技巧