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）

五、闭包

六、面向对象

七、静态

八、私有

九、继承

十、原型伪造