摘要：構造函數需要通過運算符調用并產生一個新的對象作為其接受者。使用方法定義高階函數允許使用者給回掉函數指定接收者。當給高階函數傳遞對象方法時使用匿名函數在適當的接受者上調用該方法。通常情況下應該避免使用函數對象的方法。

這部分比較簡單，直接看代碼吧：

function hello() {
    console.log("Hello, World");
}
// 函數的調用
hello(); // Hello, World

var obj = {
    welcome: function() {
        console.log("Hello, " + this.name);
    },
    name: "dreamapple"
};
// 方法調用
obj.welcome(); // Hello, dreamapple

function Student(name, age) {
    this.name = name;
    this.age = age;
    console.log("My name is " + this.name + ", and my age is " + this.age);
}
// 構造函數的調用
var s = new Student("dreamapple", 23); // My name is dreamapple, and my age is 23

注意 ：

函數調用將全局對象(處于嚴格模式下則為undefined)作為接收者。一般很少使用函數調用語法來調用方法。

方法調用將被查找方法屬性的對象作為調用接受者。

構造函數需要通過new運算符調用,并產生一個新的對象作為其接受者。

JavaScript中將函數作為參數或返回值的函數被稱為高階函數，下面介紹一些常用的JS內置高階函數

sort 函數需要使用者傳入一個排序規則，如下：

var arr = [1, 9, 3, 4, 2];
// 返回一個排序的結果
var arr1 = arr.sort(function(x, y) {return x>y?1:-1});
console.log(arr1); // [ 1, 2, 3, 4, 9 ]

使用 map 可以簡化對數組的遍歷操作，其參數為一個函數，如下：

var arr = [1, 9, 3, 4, 2];
var arr2 = arr.map(function(x) {
    return x * 2 + 1;
});
console.log(arr2); // [ 3, 5, 7, 9, 19 ]

var arr3 = [1.4,1.5,3.2,3.6]
arr3 = arr3.map(Math.ceil)
console.log(arr3)//[2, 2, 4, 4]

使用call方法自定義接受者來調用函數。

使用call方法可以調用在給定的對象中不存在的方法。

使用call方法定義高階函數允許使用者給回掉函數指定接收者。

// 使用call
var obj1 = {
    sayHello: function(msg) {
        console.log("Hello," + this.name + " " + msg);
    },
    name: "dreamapple"
};

var obj2 = {
    name: "dream"
};


// 第一個參數是方法的調用者,剩余的參數就是原函數的參數
obj1.sayHello.call(obj2, "haha"); // Hello,dream haha

// 高階函數使用call
function compute(arg) {
    var sum = 0;
    for(var i = 0; i < arg.length; i++) {
        sum += arg[i];
    }
    return sum;
}

function highFunc() {
    return compute.call(null, arguments);
}

console.log(highFunc(1, 2, 3, 4, 5)); // 15

var arr = [1,2,3,4,5];
console.log(highFunc(arr)); // 錯誤

JavaScript給每個函數都隱式地提供了一個局部變量 arguments

使用隱式的arguments對象實現可變參數的函數。

考慮對可變參數的函數提供一個額外的固定元數的版本,從而使使用者無需借助apply方法。

// 多參數函數
function multArgsFunc() {
      console.log(arguments); //[1, 2, 3, 4, 5]
    var sum = 0;
    for(var i = 0; i < arguments.length; i++) {
        sum += arguments[i];
    }
    return sum;
}

console.log(multArgsFunc(1, 2, 3, 4)); // 10
console.log(multArgsFunc(1, 2, 3, 4, 5)); // 15

注意：

永遠不要直接修改arguments對象

arguments 是一個對象，不是數組，可以通過 [].slice.call(arguments) 將其復制到一個真正的數組中再進行操作

當使用 arguments 時當心函數嵌套，通常應該使用變量保存 arguments 的引用

使用apply方法指定一個可計算的的參數數組來調用可變參數的函數。

使用apply方法的第一個參數給可變參數的的方法提供一個接收者。

注意：
apply的用法和call類似，唯一的區別在于call不接受參數數組，而apply可以接受參數數組，即使參數個數固定只有一個或兩個，使用apply時也需要將參數用 [] 包裹起來，例子如下：

 // 使用apply
function compute() {
    var sum = 0;
    for(var i = 0; i < arguments.length; i++) {
        sum += arguments[i];
    }
    return sum;
}

function wrapper(arr) {
    return compute.apply(null, arr); // 給compute函數傳遞多個參數
}

var arr = [1, 2, 3, 4, 5];
console.log(wrapper(arr)); // 15

使用 bind 來提取具有確定接受者的方法

要注意, 提取一個方法不會將方法的接受者綁定到該方法的對象上。

當給高階函數傳遞對象方法時,使用匿名函數在適當的接受者上調用該方法。

使用bind方法創建綁定到適當接收者的函數。

調用 f.bind(someObject) 會產生一個新的函數對象。在這個新的函數對象中，this被永久綁定到了bind的第一個參數上面，無論后期這個新的函數被如何使用。

示例如下：

function f(){
    return this.a;
}

var g = f.bind({a:"jack"});
console.log(g()); // jack

var o = {a:37, f:f, g:g};
console.log(o.f(), o.g()); // 37, jack


function Person(name){
 this.nickname = name;
 this.distractedGreeting = function() {
 
   setTimeout(function(){
     console.log("Hello, my name is " + this.nickname);
   }, 500);
 }
}
 
var alice = new Person("Alice");
alice.distractedGreeting();
//Hello, my name is undefined


function Person(name){
  this.nickname = name;
  this.distractedGreeting = function() {
    setTimeout(function(){
      console.log("Hello, my name is " + this.nickname);
    }.bind(this), 500); // <-- this line!
  }
}
 
var alice = new Person("Alice");
alice.distractedGreeting();
// after 500ms logs "Hello, my name is Alice"


this.x = 9; 
var module = {
  x: 81,
  getX: function() { return this.x; }
};
 
module.getX(); // 81
 
var getX = module.getX;
getX(); // 9, 因為在這個例子中，"this"指向全局對象
 
// 創建一個"this"綁定到module的函數
var boundGetX = getX.bind(module);
boundGetX(); // 81

當調用函數的toString方法時,并沒有要求JavaScript引擎能夠精確地獲取到函數的源代碼。

由于在不同的引擎下調用toString方法的結果可能不同,所以絕對不要信賴函數源代碼的詳細細節。

toString方法的執行結果并不會暴露存儲在閉包中的局部變量值。

通常情況下,應該避免使用函數對象的toString方法。

(function(x) {
    return x + 1;
}).toString();
/*
 * 輸出結果
 * function (x) {
 *  return x + 1;
 * }
 * */

(function(x) {
    return x + 1;
}).bind(10).toString();
/*
 * 由于使用了宿主環境的內置庫提供的函數，JavaScript引擎會視圖提供該函數的源代碼的真實表示
 * 而宿主環境中bind通常是其他語言（如C++）提供的是一個編譯后的函數
 * function (x) { [native code] }
 * */

(function(x) {
    return function(y) {
        return x + y;
    }
}).bind(20).toString();
/*
 * function () { [native code] }
 * */