摘要：在下例中的循環(huán)體內，我們創(chuàng)建了一個匿名函數(shù)，然后通過調用該函數(shù)的方法，將每個數(shù)組元素作為指定的執(zhí)行了那個匿名函數(shù)。當然，這里不是必須得讓數(shù)組元素作為值傳入那個匿名函數(shù)，目的是為了演示的用法。

Function.prototype.apply()將會調用一個以this和數(shù)組形式的arguments為參數(shù)的方法。
m

fun.apply(thisArg,[argsArray])

每當要為一個新的對象添加一個方法時，有時不得不為其重寫一個方法。而如果利用apply的話，只需要寫一次方法，然后在這個新的對象中繼承它即可，十分方便。
apply和call方法十分相似，僅僅只是參數(shù)不同而已，但正是因為這一點，我們在用apply時不必知道被調用的對象的具體參數(shù)，可以只穿arguments，如此一來，被調用的這個對象將負責handle觸底的arguments。
1.我們可以像Java那樣，利用apply為一個對象創(chuàng)建構造鏈。在下面的例子中，我們將創(chuàng)建一個名為construct的全局方法，這個方法可以不必讓你傳遞一個一個的參數(shù)，取而代之的則是傳遞一個參數(shù)數(shù)組。當?shù)匾粋€參數(shù)為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;  
    }  
    //創(chuàng)建一個學生類  
    var student=new Student("zhangsan",21,"一年級");  
    //測試  
    alert("name:"+student.name+"
"+"age:"+student.age+"
"+"grade:"+student.grade);  
call()
call()方法調用一個函數(shù)，其具體有一個指定的this值和分別地提供的參數(shù)。
注意：
該方法的作用和apply()方法類似，只有一個區(qū)別，就是call()方法接受的是若干個參數(shù)的列表，而apply()方法接受的是一個包含多個參數(shù)的數(shù)組。
fun.call(thisArg,arg1,arg2,...)
參數(shù)：
在fun函數(shù)運行時指定的是this值。需要注意的是，指定的this值并不一定是該函數(shù)執(zhí)行時真正的this值，如果這個函數(shù)處于非嚴格模式下，則指定為null和undefinde的this值會自動指向全局對象，同時值為原始值（數(shù)字，字符串，布爾值）的this會指向該原始值的自動包裝對象。
arg1，arg2指定的參數(shù)列表。
返回值：
返回值是你調用的方法的返回值，若該方法沒有返回值，則返回undefined。
call()允許為不同的對象分配和調用屬于一個對象的函數(shù)/方法。
可以讓call()中的對象調用當前對象所擁有的function。你剋以使用call()來實現(xiàn)繼承：寫一個方法，然后讓另一個新的對象來繼承它。
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
//在一個子勾走函數(shù)中，你可以通過調用父構造函數(shù)的call方法來實現(xiàn)繼承，類似于Java中的寫法。下例中，使用Food和Toy構造函數(shù)創(chuàng)建的對象示例都會擁有Product構造函數(shù)中添加的name屬性和price屬性，但category屬性是在各自的構造函數(shù)中定義的。
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方法調用匿名函數(shù)。
在下例中的for循環(huán)體內，我們創(chuàng)建了一個匿名函數(shù)，然后通過調用該函數(shù)的call方法，將每個數(shù)組元素作為指定的this執(zhí)行了那個匿名函數(shù)。這個匿名函數(shù)的主要目的是給每個數(shù)組元素對象添加一個print方法，這個print方法可以打印出各元素在數(shù)組中的正確索引號。當然，這里不是必須得讓數(shù)組元素作為this值傳入那個匿名函數(shù)，目的是為了演示call的用法。
var animals = [
    {species:"Lion",name:"King"},
    {species:"Whale",name:"Fail"}
];
for(var i=0;i
使用call方法調用函數(shù)并且指定上下文的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()方法創(chuàng)建一個新的函數(shù)，當這個新函數(shù)被調用時this鍵值為其提供的值，其參數(shù)列表前幾項值為創(chuàng)建時指定的參數(shù)序列。
語法：
fun.bind(thisArg[,arg1[,arg2[,...]]])
參數(shù)：
thisArg調用綁定函數(shù)時作為this參數(shù)傳遞給目標函數(shù)的值。如果使用new運算符構造綁定函數(shù)，則忽略該值。當使用bind在setTimeout中創(chuàng)建一個函數(shù)（作為回調提供）時，作為thisArg傳遞的任何原始值都將轉換為object。如果沒有提供綁定的參數(shù)，則執(zhí)行作用域的this被視為新函數(shù)的thisArg
arg1，arg2，...當綁定函數(shù)被調用時，這些參數(shù)將置于實參之前傳遞給被綁定的方法。
返回值：
返回由指定的this值和初始化參數(shù)改造的原函數(shù)拷貝。
    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"指向全局作用域

    // 創(chuàng)建一個新函數(shù)，將"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，這樣在內部嵌套的函數(shù)中能夠使用self訪問到對象o，否則仍使用this.value，內部嵌套函數(shù)的this此時指向的是全局作用域，最后的輸出將會是undefined。
但是，如果我們使用bind()函數(shù)，將fff函數(shù)的綁定在對象o中，即將fff()函數(shù)內部的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函數(shù)體的this，從第二個實參起，將依次傳遞給原始函數(shù)，因此{x:1}傳遞給this,2傳遞給形參y,m(3)調用時的3傳遞給形參z.