一、new function的用法

1.用法一

此种用法的跟运用{}的区别是：它比较天真，能够在内部定义变量、函数等

var obj = new function(){
   var a = 1; 
   var b = 2;
   this.total = a + b;
   return a + b; // 被疏忽
}

相当于：

 var obj = {
   total : 3
 }

2.用法二

此种用法就是闭包罢了

var test = new function(){

   var a = 1;
   var b = 2;

   return function(c){
      return a + b + c;
   }

}

test(3);//6

相当于：

var test = (function(){

   var a = 1;
   var b = 2;

   return function(c){
      return a + b + c;
   }

})();

test(3);//6

二、Function.prototype.apply.call的用法

function log(){
   if(window.console){
         // 第一个参数是apply要实行的函数，第二个参数为context，第三个参数为要实行函数的参数列表
         Function.prototype.apply.call(console.log,console,arguments);
         // Function.apply.call(console.log,console,arguments); // 也是能够的。
   }
}

三、组织函数中return

1.组织函数return基础范例的值

function Person(){

   var a = 2;

   this.a = a;

   return a;

}

var p = new Person();

console.dir(p); // 此时p的值并非2，而是一个有一个属性a其值为2的对象

2.组织函数return Object范例的值

function Person(){

    var a = 2

    return {

       name:"李彦峰",
       a : a

    }

}
var p = new Person();

console.dir(p); // 此时p为一个对象 {name:"李彦峰",a:2}

结论：

1. 在组织器中 return ，假如是基础范例的值，那末运用 new 操作符将会根据预期，返回一个对象，就相当于组织函数中的 return 语句不存在一样

2. 在组织器中假如 return 的是一个Object范例（function/基础范例的包装范例/Object范例），那末 new 操作符就相当于不存在一样，也就是说，js引擎会把 return 出去的援用值作为变量，而不会把 new 出来的新对象的援用赋值给响应的变量。。

四、函数的属性

• 函数的属性列表

  1. arguments

  2. caller

  3. length

  4. name

  5. prototype（这个属性先略过）

上述的属性都能够经由过程 函数名.属性来援用，length是形参的个数。假如是函数表达式的话，name是空串。

function outer(a,b,c){
    console.log(outer.arguments); // [1,2,3,4]
    console.log(outer.caller); // null
    console.log(outer.length); // 3
    console.log(outer.name); // outer
    function inner(){
        console.log(inner.arguments); // []
        console.log(inner.caller); // 打印出全部函数体
        console.log(inner.length); // 0
        console.log(inner.name); // inner
 
        // 内部函数接见外部函数的属性    
        console.log(arguments.callee.caller.arguments); // [1,2,3,4]
        // console.log(inner.caller.arguments);  // [1,2,3,4]
        console.log(arguments.callee.caller.caller); // null
        // console.log(inner.caller.caller); // null
        console.log(arguments.callee.caller.length); // 3
        // console.log(inner.caller.length); // 3
        console.log(arguments.callee.caller.name); // outer
        // console.log(inner.caller.name); // outer
    }
    inner();
}
outer(1,2,3,4);

五、部分变量

关于部分声明的反复变量，只要第一个声明有用，也就是说，js引擎会疏忽除了第一个以外的一切的声明

 
 // 第一种
 function test(){
   
     var name = "李彦峰";
     var name; 
     console.log(name); // 李彦峰

 }

 // 第二种
 function test(){
    
     var name;
     var name = "李彦峰";
     console.log(name); // 李彦峰
    
 }

注重：第二种彷佛不相符 关于部分声明的反复变量，只要第一个声明有用的说法，实在也是相符的，由于js引擎会对函数举行2轮处置惩罚，部分变量的声明在第1轮处置惩罚（变量声明提拔），所以第1轮会保证只要一个name被声明，第2轮才举行部分变量的初始化（代码实行到赋值语句才举行初始化），即会把第1轮声明的部分变量赋值。。

严厉形式下不能经由过程函数名.arguments的体式格局接见arguments对象，不能接见caller属性

六、arguments

arguments对象具有一个callee属性，该属性是一个指针，指向具有这个arguments对象的函数

arguments对象内部属性值是跟参数一一对应的，转变个中一个的值都邑影响别的一个。

看代码：

function test(a,b,c){
    console.log(arguments); // [1,2,4]
    a = 8;
    console.log(arguments); // [8,2,4]
    arguments[1] = 909;
    console.log(b); // 909
    console.log(arguments); // [8,909,4]
}
test(1,2,4);

注重：严厉形式下不能接见arguments对象的callee属性