apply,call,bind的用法

摘要：在下例中的循环体内，我们创建了一个匿名函数，然后通过调用该函数的方法，将每个数组元素作为指定的执行了那个匿名函数。当然，这里不是必须得让数组元素作为值传入那个匿名函数，目的是为了演示的用法。

Function.prototype.apply()将会调用一个以this和数组形式的arguments为参数的方法。
m

fun.apply(thisArg,[argsArray])

每当要为一个新的对象添加一个方法时，有时不得不为其重写一个方法。而如果利用apply的话，只需要写一次方法，然后在这个新的对象中继承它即可，十分方便。
apply和call方法十分相似，仅仅只是参数不同而已，但正是因为这一点，我们在用apply时不必知道被调用的对象的具体参数，可以只穿arguments，如此一来，被调用的这个对象将负责handle触底的arguments。
1.我们可以像Java那样，利用apply为一个对象创建构造链。在下面的例子中，我们将创建一个名为construct的全局方法，这个方法可以不必让你传递一个一个的参数，取而代之的则是传递一个参数数组。当地一个参数为null时，指向的时window对象。

// Function.prototype.construct = function(aArgs) {
//   var oNew = Object.create(this.prototype);
//   this.apply(oNew, aArgs);
//   return oNew;
// };

//Function.prototype.construct = function(aArgs) {
//  var fConstructor = this, fNewConstr = function() { 
//    fConstructor.apply(this, aArgs); 
//  };
// fNewConstr.prototype = fConstructor.prototype;
//  return new fNewConstr();
//};

Function.prototype.construct = function (aArgs) {
  var fNewConstr = new Function("");
  fNewConstr.prototype = this.prototype;
  var oNew = new fNewConstr();
  this.apply(oNew, aArgs);
  return oNew;
};
function MyConstructor() {
  for (var nProp = 0; nProp < arguments.length; nProp++) {
    this["property" + nProp] = arguments[nProp];
  }
}
var myArray = [4, "Hello world!", false];
var myInstance = MyConstructor.construct(myArray);
console.log(myInstance.property1);                // logs "Hello world!"
console.log(myInstance instanceof MyConstructor); // logs "true"
console.log(myInstance.constructor);  

function minOfArray(arr){
    var min = Infinity;
    var QUANTUM = 32768;
    var len=arr.length;
    for(var i=0;i
    function Person(name,age)  
    {  
        this.name=name;  
        this.age=age;  
    }  
    /*定义一个学生类*/  
    function Student(name,age,grade)  
    {  
        Person.apply(this,arguments);  
        this.grade=grade;  
    }  
    //创建一个学生类  
    var student=new Student("zhangsan",21,"一年级");  
    //测试  
    alert("name:"+student.name+"
"+"age:"+student.age+"
"+"grade:"+student.grade);  
call()
call()方法调用一个函数，其具体有一个指定的this值和分别地提供的参数。
注意：
该方法的作用和apply()方法类似，只有一个区别，就是call()方法接受的是若干个参数的列表，而apply()方法接受的是一个包含多个参数的数组。
fun.call(thisArg,arg1,arg2,...)
参数：
在fun函数运行时指定的是this值。需要注意的是，指定的this值并不一定是该函数执行时真正的this值，如果这个函数处于非严格模式下，则指定为null和undefinde的this值会自动指向全局对象，同时值为原始值（数字，字符串，布尔值）的this会指向该原始值的自动包装对象。
arg1，arg2指定的参数列表。
返回值：
返回值是你调用的方法的返回值，若该方法没有返回值，则返回undefined。
call()允许为不同的对象分配和调用属于一个对象的函数/方法。
可以让call()中的对象调用当前对象所拥有的function。你剋以使用call()来实现继承：写一个方法，然后让另一个新的对象来继承它。
function Product(name,price){
    this.name = name;
    this.price = price;
}
function Food(name,price){
    Product.call(this,name,price);
    this.category = "food"
}
console.log(new Food("cheese",5).name)//cheese
//在一个子勾走函数中，你可以通过调用父构造函数的call方法来实现继承，类似于Java中的写法。下例中，使用Food和Toy构造函数创建的对象示例都会拥有Product构造函数中添加的name属性和price属性，但category属性是在各自的构造函数中定义的。
function Food(name, price) {
  this.name = name;
  this.price = price;
  if (price < 0) {
    throw RangeError(
      "Cannot create product " + this.name + " with a negative price"
    );
  }

  this.category = "food";
}

//function Toy 同上
function Toy(name, price) {
  Product.call(this, name, price);
  this.category = "toy";
}

var cheese = new Food("feta", 5);
var fun = new Toy("robot", 40);
使用call方法调用匿名函数。
在下例中的for循环体内，我们创建了一个匿名函数，然后通过调用该函数的call方法，将每个数组元素作为指定的this执行了那个匿名函数。这个匿名函数的主要目的是给每个数组元素对象添加一个print方法，这个print方法可以打印出各元素在数组中的正确索引号。当然，这里不是必须得让数组元素作为this值传入那个匿名函数，目的是为了演示call的用法。
var animals = [
    {species:"Lion",name:"King"},
    {species:"Whale",name:"Fail"}
];
for(var i=0;i
使用call方法调用函数并且指定上下文的this
在下面的例子中，当调用greet方法的时候，该方法的this值会绑定到i对象。
function greet(){
    var reply = [this.person,"Is An Awesome",this.role].join("");
    console.log(reply);
}
var i = {
    person:"Douglas Crockford",
    role:"JavaScript DeveLoper"
}
greet.call(i);// Douglas Crockford Is An Awesome Javascript Developer
bind()
bind()方法创建一个新的函数，当这个新函数被调用时this键值为其提供的值，其参数列表前几项值为创建时指定的参数序列。
语法：
fun.bind(thisArg[,arg1[,arg2[,...]]])
参数：
thisArg调用绑定函数时作为this参数传递给目标函数的值。如果使用new运算符构造绑定函数，则忽略该值。当使用bind在setTimeout中创建一个函数（作为回调提供）时，作为thisArg传递的任何原始值都将转换为object。如果没有提供绑定的参数，则执行作用域的this被视为新函数的thisArg
arg1，arg2，...当绑定函数被调用时，这些参数将置于实参之前传递给被绑定的方法。
返回值：
返回由指定的this值和初始化参数改造的原函数拷贝。
    this.x = 9; 
    var module = {
        x: 81,
        getX: function() { return this.x; }
    };

    console.log(module.getX()); // 返回 81

    var retrieveX = module.getX.bind(module);
    console.log(retrieveX()); // 返回 9, 在这种情况下，"this"指向全局作用域

    // 创建一个新函数，将"this"绑定到module对象
    // 新手可能会被全局的x变量和module里的属性x所迷惑
    var boundGetX = retrieveX.bind(module);
    console.log(boundGetX()); // 返回 81
var o={
    f:function(){
        var self = this;
        var fff = function(){
            console.log(self.value)//此时this指向的是全局作用域，因此需要使用self指向对象o
        };
        fff();
    },
    value:"Hello World"
};
o.f()//Hello World!
上例子是我们常用了保持this上下文的方法，把this赋值给了中间变量self，这样在内部嵌套的函数中能够使用self访问到对象o，否则仍使用this.value，内部嵌套函数的this此时指向的是全局作用域，最后的输出将会是undefined。
但是，如果我们使用bind()函数，将fff函数的绑定在对象o中，即将fff()函数内部的this对象绑定为对象o，那么可以遇见此时this.value是存在的。代码如下：
var o={
    f:function(){
        var self = this;
        var fff = function(){
            console.log(this.value);
        }.bind(this);
        fff();
    }
    valeu:"Hello World!"
}
o.f()//Hello World!
更普通的使用情形：
function f(y,z){
    return this.x+y+z;
}
var m = f.bind({X;1},2);
console.log(m(3))
最后将输出6
这是因为bind()方法会把传入它的第一个实参绑定给f函数体的this，从第二个实参起，将依次传递给原始函数，因此{x:1}传递给this,2传递给形参y,m(3)调用时的3传递给形参z.