js高级

一、js作用域

 如果有多层函数嵌套，优先在自己所在函数内查找所需变量，如果查不到，再去上层可以调到全局去找 例如：

<script>var t = 3;function t1(){ var t = 4; function t2() {   t = 5;   alert(t); }   t3();   alert(t);}t2();//5</script>

var此处声明一个变量。一个动作。
不加var只是对他的赋值，只是操作变量

二、词法分析

js在代码执行前，有一个代码的分析过程，这个过程叫词法分析
一个变量。

（一）、函数来源：

 1、参数 2、var 3、函数声明

（二）、分析过程：

每个函数会形成一个自己的ao（active object）对象，函数所有变量都存在ao属性上，
1、第一步：
先分析函数中的参数

t(a,b,c){}

这时它内部会形成：
ao.a
ao.b
ao.c
由于他的内部还没有分析有没有赋值，，因此这里他们都等于undefined
2、第二步：
分析var声明

  var A = 3

3、第三步：分析函数声明

function  X（）{}

ao上会立即生成ao.x = function(){}
之前如果有ao.x已经存存在，那么这将会被后者覆盖。
ao分析完毕，函数内变量都在ao中找，假如没找到就会在上层函数找，这样形成一个链，就叫“作用域链”。

实例：

var foo = 1;function  t(){    console.log(foo);//1.undefined    var foo = 2;    console.log(foo);//2}t()/*分析：tao = {}1.首先分析参数：没有2.分析var 声明，tAO.foo = undefined;3.分析函数声明过程，无*/

function  t(a,b){   function a(){        alert(b);   }   alert(a);}t(1,3);/*tAO = {}tao.a = undifined;tao.b = undifined;/*分析：tao = {}1.首先分析参数：2.分析var 声明  没有3.分析函数声明，  tao.a= function()  并立即输出*/

x();var x = fuction(){    alert('y');}//报错/////////////x()function x(){    alert('y')；}//弹出y//原因：第一个var声明了一个变量，没有调用这个x函数// 第二个声明了一个函数，ao上会立即形成一个ao.x=function(){}// 相当于立即执行函数，弹出 y

arguments

js中的不定参数：

函数内部的arguments是一个对象,包含着所有的实参
arguments.length 属性 代表实参的数量
arguments.callee 属性 代表当前函数

// 不定参数function t(a) {    console.log(a);    console.log(arguments);}t(); /*// 分析期tAO.a = undefined;//执行期, 没传参tAO.a = undefined;*/t(1,2,3);/*// 分析期  tAO.a = undefined;//执行期 tAO.a = 1;*/ 

callee 代表正在执行的函数，可以用于递归

/*这是一个普通的递归function sum (n) {    if(n>1) {        return n + sum(n-1);    } else if(n==1) {        return 1;    }} alert(sum(5));*//* 这是立即执行函数表达式（匿名函数）(function () {    alert(1);})();*///我们将第一个递归函数改造成一个匿名闭包函数alert( (function (n) {    if(n>1) {        return n + arguments.callee(n-1);        //argument.callee 代表正在执行的函数    } else if(n==1) {        return 1;    }})(100) );

caller 是函数自身的一个属性,代表”谁调用的他”;

function t() {    function x() {        alert(x.caller);    }    x();}t();

四、js中的this

this 始终代表方法的引用来源(通过哪个对象的属性代表的函数,函数的this就指那个对象)

var bark = function() {    console.log(this.uname);}var cat = {uname : '加肥'};var dog = {uname : '哮天'};cat.bark = bark;cat.bark(); // 加肥dog.bark = cat.bark;dog.bark(); // 哮天var uname = 'js全局动物';//bark();(cat.bark = dog.bark)(); // 

原生类型：3,5，hello等

假如：var a=3;
var b =a;
那么此时a在内存中的值等于3，而b则把 a的值也抄过来一份放 在内存，b也等于三

引用类型：对象、函数

假如：有个function（）{
this
}
有几个变量a,b,c
将function的值赋给a，a指向这个function的值，而
var b =a（把a赋给b）

五、闭包

六、面向对象

七、静态

八、私有

九、继承

十、原型伪造