caller 属性是函数对象本身的一个成员属性。

• caller 属性是帮助我们在当前函数里获取调用当前函数的某个未知函数，之所以称 未知函数 ，是因为我们在写一个函数时，很可能根本不知道哪个函数会调用到我们的这个函数。

• 全局环境中调用函数是不会生成此 caller 属性

   

  function callerDemo() { 
    if (callerDemo.caller){ 
             var a = callerDemo.caller.toString(); 
              console.log(a);  
            } else { console.log("this is a top function"); } } 
  function handleCaller() { callerDemo();} 
  handleCaller(); //"function handleCaller() { callerDemo(); }" 
  callerDemo(); //"this is a top function"

  对当前函数对象的一个引用

  function calleeDemo() { console.log(arguments.callee); }

  • callee 属性隶属于Function的一个隐藏对象—— arguments 中，这个 arguments 对象大家应该不陌生，表示的就是当前函数传入的参数，一般用于函数不限制参数数量的传参。

  • 与 caller 属性一样，也是要在当前函数的内部（上下文环境）才有效。

  • 可配合 caller 属性一起使用： arguments.callee.caller ，这样就可以完全忽略到具体的函数名了。

  • 函数递归时用起来比用函数名调用函数更带感！

     

    3.apply / call 方法：这俩方法性质一样，只是用法稍有不同

    function type(obj) {
      return Object.prototype.toString.call(obj).slice(8, -1);    //换成用apply方法亦可
    }

    • apply / call 方法的意义在于 借用 其它对象的成员方法来对目标对象执行操作。
      语法：call([thisObj[,arg1[, arg2[,   [,.argN]]]]]) 
      语法：apply([thisObj[,argArray]]) 
      在 借用 的过程中， apply / call 方法会改变被借用的成员方法的上下文环境：把 this 这一与上下文环境高度相关的变量指向目标对象，而非原来的对象。看下面的这段代码：

    function Point(x, y){
        this.x = x;
        this.y = y;
    }
    Point.prototype.move = function(x, y) {
        this.x += x;
        this.y += y;
    }
    var p = new Point(0,0);
    var circle = {x:1, y:1, r:1};    //只是一个普通的Object对象
    p.move.call(circle, 2, 1);    // 这个例子中的意思就是用 p.move来替换 circle，p.move.call(circle, 2, 1)== p.move(2,1)  ，p.move.apply(circle, [2, 1]); 等价于p.move.call(circle, 2, 1);  运得后的circle = {x:3, y:2, r:1};

    这里的circle只是一个普通的Object对象，不含任何自定义的成员方法，但通过 apply / call 方法，可以借用Point类对象定义的move方法来帮助circle达到目的（本例其实是圆心在坐标轴上的移动）。在 借用 Point类对象的move方法时，move方法中的this就不再指向p，而是指向circle了，达到了上下文环境改变的效果。

    另外，从代码里也可以看出， call 方法与 apply 方法的区别仅在于： call 方法直接把需要传入的参数列在目标对象其后，而 apply 方法则以数组的形式整体传入。

    bind 方法

    bind 方法与 apply / call 方法也非常类似，相当于稍微再封装了一下，仍以上述DEMO作为案例：

    function Point(x, y){
        this.x = x;
        this.y = y;
    }
    Point.prototype.move = function(x, y) {
        this.x += x;
        this.y += y;
    }
    var p = new Point(0,0);
    var circle = {x:1, y:1, r:1};
    // p.move.call(circle, 2, 1);
    // p.move.apply(circle, [2, 1]);
    var circleMove = p.move.bind(circle, 2, 1);    //此时并不执行move方法
    circleMove();    //此时才执行

    从上面这段DEMO可以看出， bind 方法其实是给 apply / call 方法缓了一下，也可以说是封装了一下方便后续调用，其实质上相当于下面的这段代码：

    function circleMove() {
        p.move.call(circle, 2, 1);
    }
    circleMove();

    bind 方法兼容性适应

    bind 方法，即 Function.prototype.bind ，属于 ECMAScript 5 ，从 IE 10 版本才开始支持，那怎么做兼容性适应呢？

    if(typeof Function.prototype.bind !== 'function') {
      Function.prototype.bind = function() {
        var thatFunc = this;
        var args = [];
        for(var i = 0; i < arguments.length; i++) {
          args[i] = arguments[i];
        }
    
        return function() {
          var context = args.shift();
          thatFunc.apply(context, args);
        }
      }
    }

    easing,localScroll,lightbox,preload
    
     javascript的方法可以分为三类：a 类方法、b 对象方法、c 原型方法 
    function People(name) { this.name=name; //对象方法 this.Introduce=function(){ alert("My name is "+this.name); } } //类方法 People.Run=function(){ alert("I can run"); } //原型方法 People.prototype.IntroduceChinese=function(){ alert("我的名字是"+this.name); } //测试 var p1=new People("Windking"); p1.Introduce(); People.Run(); p1.IntroduceChinese();
    
     

    prototype

    每一个函数对象都有一个显示的prototype属性，它代表了对象的原型，更明确的说是代表了同函数对象（构造函数）所创建出来的对象的原型。

    函数 （对象）

    函数传遵递的参数：数字、字符串、布尔、函数、对象、未定义。函数以参数的形式传给函数时，函数不用加（），加（）就直接执行了，函数就会有返回值，如果函数里面没有返回值就会返回undifine。

    fun( fun1) // function fun1(){...}

    1.函数的定义

    函数挂载在一个对象上，作为对象的一个属性，就称它为对象的方法。

    用于初始化一个新创建的对象的函数称为构造函数。

     

    var tensquared=(function(x){return x*x}(10));    //函数表达式在定义后产立即调用

     

    函数定义包括函数语句和表达式两种方式，表达式方式定义的函数无法在定义之前使用，函数表达式也可以作为参数传给其它 函数

    var square = function(x){return x*x}  //函数表达式定义时可以包涵名称也可以不包涵

    var f = function fact(x) {if(x<=1) return 1;else return x*fact(x-1);}

     

    2.函数的调用

    函数调用有4种方法：

    1.作为函数；

    2.作为方法；

    3.作为构造函数：方法调用之前带关键字new,凡是没有形参的构造函数定义都是可以省略圆括号的，如：var o=new Object(); var o =new Object;

                           构造函数调用创建一个新的空对象，这个对象继承自构造函数的prototype属性。

    4通过call()和apply()方法间接调用

    3.作用域

    只要遇到域都会发生域解析，域包括： <script></script>、函数

    onclick事件以参数的形式传进去：oDom.onclikc等价于 oDom[evt]  

    window.onload=function(){
    var el=document.getElementById("btn-add");
    function fun(oBtn,evt) //evt是传进来的参数如：onclick onmouseover
    {
    oBtn[evt]=function(){alert("success");}
    }
    fun(el,"onclick")
    }

    表达式：=、 + 、-、*、%、++、--、Number()、参数

    js预解析：预解析var 、function、参数。变量返回undifine,遇到重名的只留下一个， 变量和函数重名的时候，留下函数；js逐行读取时：表达式可以修改预解析的值

    alert(a); //function a(){alert(4)}
    var a=1; alert(a); //1
    function a(){alert(2)}alert(a)//1
    var a=3;alert(a);//3
    function a(){alert(4)}

     

    函数内部不能读取到函数外部的变量，参数a相当于一个 var a

    var a =2; function fun(){ alert (a); var a=3; } fun(); //undifine alert(a); //2

    var a =2; function fun(){ alert (a); a=3; } fun(); //2 alert(a) //3

    var a =2; function fun(a){ //a==var a 预解析undifine alert (a); a=3; } fun(a); //2 alert(a) //2

     

    if、for不是作用域，所以定义在里面和定义在外面的变量都是一样的. Firfox浏览器不能预解析{ }里面的代码；

     

    “use strict" //在严格模式下

    object

    1.1 new构造函数法

    var person =new object();
    person.name="wang";

    person.sex="男";

    1.2 对象字面量

    var person={

    name:"wang",

    sex:"男"

    }

    函数调用时的括号

    简单点说，带括号的是函数调用，直接执行函数；不带括号的是绑定事件，事件触发再执行。

    复杂点说，带括号的是把返回值赋值给事件，不带括号的是把函数体所在地址位置赋值给事件。

    function cc(ele){
    var a=document.getElementById("a");
    a.style.color="red";
    alert(ele);
    }
    function change(){
    var ip=document.getElementById("ip");
    // ip.onclick=cc("hello"); //正常绑定事件，onclick触发执行
    // ip.onclick=cc; //调用cc时,才执行
    ip.onclick=function(){cc("hello")}(); //调用cc,直接执行，有参数的情况
    }
    change(); //调用change,直接执行

    checkbox

    $('[name="msgOrderCheckbox"]').is(":checked")是否选中返回true/false
    
    

    ~~作用

    其实是一种利用符号进行的类型转换,转换成数字类型
    
    ~~true == 1
    ~~false == 0
    ~~"" == 0
    ~~[] == 0
    ~~undefined ==0
    ~~!undefined == 1
    ~~null == 0
    ~~!null == 1

    window.location.hash属性介绍

     

    location是javascript里边管理地址栏的内置对象，比如location.href就管理页面的url，用location.href=url就可以直接将页面重定向url。而location.hash则可以用来获取或设置页面的标签值。比如http://domain/#admin的location.hash="#admin"。

    对于Ajax页面想将它收藏起来，可是地址只有一个呀。浏览器上的“前进”“后退”按钮也会失效，这于很多习惯了传统页面的用户来说，是一个很大的使用障碍。

    用location.hash来解决这两个问题呢。

    比如，我的作者管理系统，主要功能有三个：普通搜索、高级搜索、后台管理，我分别给它们分配一个hash值：#search、#advsearch、#admin，在页面初始化的时候，通过window.location.hash来判断用户需要访问的页面，然后通过javascript来调整显示页面。比如：

    var hash; 
    hash=(!window.location.hash)?"#search":window.location.hash; 
    window.location.hash=hash; 
      //调整地址栏地址，使前进、后退按钮能使用 
    switch(hash){   
    case "#search":  
        selectPanel("pnlSearch");   //显示普通搜索面板  
        break;    
    case "#advsearch":    
          
    case "#admin":  
         
    }

    通过window.location.hash=hash这个语句来调整地址栏的地址，使得浏览器里边的“前进”、“后退”按钮能正常使用（实质上欺骗了浏览器）。然后再根据hash值的不同来显示不同的面板（用户可以收藏对应的面板了），这就使得Ajax页面的浏览趋于传统化了。