JavaScript中的原型链以及递归概念

原型链：（Person.prototype----->Object.prototype----->null）
每个构造函数都有原型对象// 创建一个构造函数 都会默认的创建一个 构造函数的原型
每个对象都有构造函数
每个构造函数的原型都是一个对象
那么这个原型对象也会有构造函数
那么这个原型对象的构造函数也有原型对象
这样就会形成一个链式结构，称之为 原型链

属性搜索原则：
1.当访问一个对象的成员的时候，会现在自身找有没有,如果找到直接使用，
2.如果没有找到，则去当前对象的原型对象中去查找，如果找到了直接使用，
3.如果没有找到，继续找原型对象的原型对象，如果找到了，直接使用
4.如果没有找到，则继续向上查找，直到Object.prototype，如果还是没有，就报错

原型继承概念：
通过修改原型链结构实现的继承，就叫做原型继承

函数进阶：
函数声明如果放在if—else中，在低版本浏览器中会出现问题
函数表达式可以解决这个问题

函数中this指向问题：
1.普通函数中的this指向的是window
2.定时器中的this指向的是window
3.构造函数中的this指向的是实例对象
4.对象中的方法中的this指向的也是实例对象
5.原型对象中的this指向的也是实例对象

严格模式的写法：在函数之前添加"use strict"
严格模式 其实 就是所有的函数 都必须使用对象调用
函数调用:
普通函数: 直接调用
构造函数: 通过new 关键字 目的创建对象
对象的方法: 对象名.方法名

函数是对象,对象不一定是函数
函数具备 prototype原型 以及 proto__对象
对象具备只有__proto
所有的函数实际上都是Function的构造函数创建出来的

递归：在程序中，所谓的递归，就是函数自己直接或间接的调用自己。
自己调用自己分两种：
1.直接调用自己
2.间接调用自己
递归最重要的是跳出结构,才会有结果

例题：

//1, 2, 3, 4, 5, ..., 100 求和
   //普通方法
   var num=0;
   for (var i=1;i<=100;i++) {
    num+=i
   }
   console.log(num)//5050
   //递归
   function digui(sum){
    //跳出递归条件
    if (sum==1) {
     return 1;
    }
    //递归条件
    return sum+digui(sum-1)
   }
   //变量接收
   var gui=digui(10)
   console.log(gui)//55

/*递归思想流程:
    * 传递数字10进入函数时：sum=10；返回结果：10+digui（10-1）；程序等待
    * 传递数字9进入函数时：sum=9；返回结果：9+digui（9-1）；程序等待
    * 传递数字8进入函数时：sum=8；返回结果：8+digui（8-1）；程序等待
    * 传递数字7进入函数时：sum=7；返回结果：7+digui（7-1）；程序等待
    * 传递数字6进入函数时：sum=6；返回结果：6+digui（6-1）；程序等待
    * 传递数字5进入函数时：sum=5；返回结果：5+digui（5-1）；程序等待
    * 传递数字4进入函数时：sum=4；返回结果：4+digui（4-1）；程序等待
    * 传递数字3进入函数时：sum=3；返回结果：3+digui（3-1）；程序等待
    * 传递数字2进入函数时：sum=2；返回结果：2+digui（2-1）；程序等待
    * 传递数字1进入函数时：sum=1；返回结果：1 ；
    * 传递数字2进入函数时：1+2
    * 传递数字3进入函数时：1+2+3
    * 传递数字4进入函数时：1+2+3+4
    * 传递数字5进入函数时：1+2+3+4+5
    * 传递数字6进入函数时：1+2+3+4+5+6
    * 传递数字7进入函数时：1+2+3+4+5+6+7
    * 传递数字8进入函数时：1+2+3+4+5+6+7+8
    * 传递数字9进入函数时：1+2+3+4+5+6+7+8+9
    * 传递数字10进入函数时：1+2+3+4+5+6+7+8+9+10
    */