在编程中，函数是一个可重复使用的代码块，当它被调用时执行某种功能。

函数是每一种编程语言的组成部分，因为它们有助于使你的代码更加模块化和可重复使用。

在这篇文章中，我将向你展示如何在 Python 中定义一个函数并调用它，这样你就可以把你的 Python 应用程序的代码分解成更小的块。

我还将向你展示参数和 return 关键字在 Python 函数中是如何工作的。

在 Python 中定义一个函数的基本语法

在 Python 中，你用 def 关键字定义一个函数，然后写上函数标识符（名称），后面是括号和冒号。

接下来你要做的是确保按 Tab 键或 4 个空格缩进，然后指定你希望这个函数为你做什么。

def functionName():
    # 让函数做什么

Python 中函数的基本示例

按照上面的基本语法，一个向终端打印 “Hello World” 的基本 Python 函数示例如下所示：

def myfunction():
    print("Hello World")

要调用这个函数，请写出函数的名称，后面加括号：

myfunction()

接下来，通过输入 python filename.py 在终端运行你的代码，以显示你希望函数做什么：

另一个两个数字相减的基本例子是这样的：

def subtractNum():
    print(34 - 4)

subtractNum()
# 输出：30

Python 函数中的参数

在 Python 中定义一个函数时，你可以通过把参数放在括号内将它们传入函数。

基本语法如下所示：

def functionName(arg1, arg2):
    # 用函数做什么
    

调用函数时，你需要为参数指定一个值：

functionName(valueForArg1, valueForArg2)

这是 Python 函数中的参数示例：

def addNum(num1, num2):
    print(num1 + num2)
addNum(2, 4)

# 输出：6

在上面的例子中：

• 我向名为 addNum 的函数传递了两个参数
• 我告诉它要把两个参数的和打印到终端上
• 然后我用指定的两个参数的值来调用它

注意：你可以指定任意多的参数。

如何在 Python 中使用 Return 关键字

在 Python 中，你可以使用 return 关键字来退出一个函数，这样它就回到了被调用的地方。也就是说，从函数中送出一些东西。

一旦函数被调用，return 语句可以包含一个要执行的表达式。

下面的例子演示了 return 关键字在 Python 中的作用：

def multiplyNum(num1):
    return num1 * 8

result = multiplyNum(8)
print(result)

# 输出：64

上面的代码在做什么？

我定义了一个名为 multiplyNum 的函数，并将 num1 作为一个参数传给它

在该函数中，我使用了 return 关键字来指定我希望 num1 被乘以 8。

之后，我调用了该函数，将 8 作为参数 num1 的值传给它，并将该函数调用分配给一个名为 result 的变量。

有了这个变量，我就可以把我想用这个函数做的事情打印到终端。

总结

在这篇文章中，你学会了如何在 Python 中定义和调用函数。你还学会了如何将参数传入函数并使用 return 关键字，这样你就可以更有创意地编写函数了。

如果你觉得这篇文章有帮助，不要犹豫，与你的朋友和家人分享它。

本文将简要介绍 JavaScript 编程语言中回调函数的概念和用法。

函数是对象

我们需要知道的第一件事是，在 JavaScript 中，函数是第一类对象。因此，我们可以用处理其他对象的方式来处理它们，比如把它们分配给变量，并把它们作为参数传给其他函数。这一点很重要，因为正是第二个方式使我们能够在应用程序中扩展功能。

回调函数

回调函数是一个被作为参数传递给另一个函数的函数，以便在稍后时间被“回调”。一个接受其他函数作为参数的函数被称为高阶函数，它包含回调函数何时被执行的逻辑。正是这两者的结合，使我们能够扩展应用的功能。

为了说明回调，让我们从一个简单的例子开始。

function createQuote(quote, callback){ 
  var myQuote = "Like I always say, " + quote;
  callback(myQuote); // 2
}

function logQuote(quote){
  console.log(quote);
}

createQuote("eat your vegetables!", logQuote); // 1

// 控制台的结果： 
// Like I always say, eat your vegetables!

在上面的例子中，createQuote 是高阶函数，它接受两个参数，第二个参数是回调。logQuote 函数被用来作为我们的回调函数传入。当我们执行 createQuote 函数（1）时，注意到当我们把 logQuote 作为参数传入时，没有给它加上括号。这是因为我们并不想立即执行回调函数，只是想把函数定义传递给高阶函数，以便以后可以执行。

另外，我们需要确保，如果我们传入的回调函数期望有参数，那么在执行回调时要提供这些参数。在上面的例子中，这将是 callback(myQuote); 语句，因为我们知道 logQuote 期望传入一句引言。

此外，我们可以将匿名函数作为回调传入。下面对 createQuote 的调用将产生与上述例子相同的结果。

createQuote("eat your vegetables!", function(quote){ 
  console.log(quote); 
});

顺便说一下，你不必用“回调”这个词作为参数的名称，JavaScript 只需要知道这是一个正确的参数名称。基于上面的例子，下面的函数将以完全相同的方式表现出来。

function createQuote(quote, functionToCall) { 
  var myQuote = "Like I always say, " + quote;
  functionToCall(myQuote);
}

为什么使用回调函数

大多数时候，我们创建的程序和应用都是以同步方式运行的。换句话说，我们的一些操作只有在前面的操作完成后才会开始。通常情况下，当我们从其他来源（如外部 API）请求数据时，我们并不总是知道数据何时会被传递回来。在这种情况下，我们希望等待响应，但我们并不总是希望整个应用程序在获取数据时停顿下来。这些情况就是回调函数的用武之地。

让我们来看看一个模拟向服务器发出请求的例子。

function serverRequest(query, callback){
  setTimeout(function(){
    var response = query + "full!";
    callback(response);
  },5000);
}

function getResults(results){
  console.log("Response from the server: " + results);
}

serverRequest("The glass is half ", getResults);

// 延迟 5 秒后，在控制台中显示：
// 服务器的响应：The glass is half full!

在上面的例子中，我们向一个服务器发出了一个模拟请求。5 秒过后，响应被修改，然后我们的回调函数 getResults 被执行。要查看这个过程，你可以将上述代码复制/粘贴到你的浏览器的开发工具中并执行。

另外，如果你已经熟悉 setTimeout，那么你就一直在使用回调函数。传入上述例子的 setTimeout 函数调用中的匿名函数参数也是一个回调函数! 所以这个例子的原始回调实际上是由另一个回调执行的。如果可以的话，请注意不要嵌套太多的回调，因为这可能会导致所谓的“回调地狱”！正如它的名字所暗示的那样，处理这个问题比较麻烦。

1、介绍回调函数, promises, async/await

2、开发实例--货币转换器，从两个 API 异步获取数据

在开始正文之前

在写这篇文章的同时，我还录制了一个相关的视频，你可以边看视频边敲代码，我建议你先看下视频，然后再以这篇文章为引导自己练习下代码。

简介

Async/Await 是一种建立在 promises 基础上的，书写异步代码的新方式，所以它也是非阻塞的。

与我们之前异步编程所使用到的回调函数和 promises 相比较，最大的区别就是 Async/Await 使我们的异步代码看起来就像同步代码一样，这也正是它的厉害之处。

使用回调函数

setTimeout(() => {  console.log('This runs after 1000 milliseconds.');}, 1000);

回调函数最典型的问题——回调地狱

在回调函数中嵌套回调函数，看起来就像这样：

回调地狱

指的是回调函数被嵌套在另一个回调函数中，嵌套层级有多层，使我们的代码可读性和可维护性变得非常差。

使用 Promise

const promiseFunction = new Promise((resolve, reject) => {  const add = (a, b) => a + b;  resolve(add(2, 2));});promiseFunction.then((response) => {  console.log(response);}).catch((error) => {  console.log(error);});

promiseFunction 这个函数返回一个表示函数运行过程的 Promise 对象， resolve 函数表示任务已经完成。

然后，我们就可以在 promiseFunction 函数的基础上调用 then() 和 catch() 方法。

then: Promise 成功后执行的回调函数。
catch: 当遇到了错误后执行的回调函数。

Async 函数

Async 函数为我们提供了简洁的语法，我们可以通过它实现与 Promise 相同的效果，但是代码量会减少很多。其实底层原理上，async 不过是 promises 的语法糖而已。

在普通的函数声明前加上 async 关键字，我们就创建了一个 async 函数：

const asyncFunction = async () => {  // Code}

异步函数使用 Await 表达式可以暂停函数的执行，Await 关键字只能在 Async 函数中使用，它会返回 Promise 对象的处理结果。

promises 和 Async/Await 的区别：

// Async/Awaitconst asyncGreeting = async () => 'Greetings';// Promisesconst promiseGreeting = () => new Promise(((resolve) => {  resolve('Greetings');}));asyncGreeting().then(result => console.log(result));promiseGreeting().then(result => console.log(result));

Async/Await 更易于我们理解，因为它看起来像同步代码。

前面我们已经介绍过这些基础知识了，现在我们来看看在现实开发中怎么使用！

货币转换器

项目说明和初始化

在下面的教程中，我们将创建一个简单实用，而且很有学习意义的应用程序，相信会加深你对 Async/Await 理解。

这个程序会接收到我们想要把什么货币转换成什么货币，以及货币金额，然后会调用相关的 API，显示正确的汇率。

在这个程序中，我们将从以下两个 API 异步获取数据：

1. Currency Layer —— https://currencylayer.com - 你需要先免费注册账号，才能获取 API Access Key。这个 API 为我们提供了 计算货币间汇率所需的数据。
2. Rest Countries —— http://restcountries.eu/ - 这个 API 为我们提供了给定一种货币，返回该货币在哪些国家流通。

首先，创建一个新目录并运行 npm init 初始化项目，接下里我们选择默认值，跳过所有步骤，然后再输入 npm i——save axios 安装 axios。在当前文件夹内创建一个 currency-convert .js 的文件。

在 currency-convert .js 文件中，我们先通过 require 语法引入 axios。

const axios = require(‘axios’);`

深入理解 Async/Await

这个程序中，我们需要三个异步函数，第一个函数用来获取关于货币的数据；第二个函数用来获取关于国家的数据；第三个函数用来将所有信息集中起来并展示给用户看

第一个函数——异步获取有关货币的数据

我们创建一个接收两个参数（fromCurrency 和 toCurrency）的异步函数：

const getExchangeRate = async (fromCurrency, toCurrency) => {}

现在我们获取数据，然后通过使用 Async/Await，可以直接将我们想要的数据赋值给变量。调用接口之前别忘了要注册账号，才能获得 API access key。

const getExchangeRate = async (fromCurrency, toCurrency) => {  const response = await axios.get('http://data.fixer.io/api/latest?    access_key=[yourAccessKey]&format=1');}

我们可以通过 response.data.rates 来提取我们想要的数据，然后我们将它赋值给一个变量 rate：

const rate = response.data.rates;

因为所有的数据都是从欧元转换过来的，我们可以创建一个变量 euro，它的值等于：

const euro = 1 / rate[fromCurrency];

最后，我们可以用欧元乘以我们要兑换的货币来得到汇率：

const exchangeRate = euro * rate[toCurrency];

最终的函数看起来像这样：

第二个函数——异步获取国家数据

创建一个异步函数，接收 currencyCode 作为参数：

const getCountries = async (currencyCode) => {}

和之前一样，获取数据，然后将其赋值给一个变量：

const response = await axios.get(`https://restcountries.eu/rest/v2/currency/${currencyCode}`);

然后通过数组 map 方法将 country.name 提取出来，映射为一个新的数组：

return response.data.map(country => country.name);

最终代码：

最后一个函数——将前面的函数组合起来

创建一个异步函数，接收 fromCurrency, toCurrency, amount 三个参数：

const convert = async (fromCurrency, toCurrency, amount) => {}

第一步，获取货币数据：

const exchangeRate = await getExchangeRate(fromCurrency, toCurrency);

第二步，获取国家数据：

const countries = await getCountries(toCurrency);

第三步，将转换后的金额赋值给一个变量：

const convertedAmount = (amount * exchangeRate).toFixed(2);

最后，将数据输出给用户

return `${amount} ${fromCurrency} is worth ${convertedAmount} ${toCurrency}. You can spend these in the following countries: ${countries}`;

最后完整的代码：

使用 try/catch 来处理错误

我们将程序的逻辑用 try 语句包裹起来，如果出现错误，用 catch 语句捕捉：

const getExchangeRate = async (fromCurrency, toCurrency) => {  try {    const response = await       axios.get('http://data.fixer.io/api/latest?access_key=f68b13604ac8e570a00f7d8fe7f25e1b&format=1');    const rate = response.data.rates;    const euro = 1 / rate[fromCurrency];    const exchangeRate = euro * rate[toCurrency];    return exchangeRate;  } catch (error) {    throw new Error(`Unable to get currency ${fromCurrency} and  ${toCurrency}`);  }};

同样第二个函数也这样处理：

const getCountries = async (currencyCode) => {  try {    const response = await axios.get(`https://restcountries.eu/rest/v2/currency/${currencyCode}`);return response.data.map(country => country.name);  } catch (error) {    throw new Error(`Unable to get countries that use ${currencyCode}`);  }};

因为第三个函数只是处理第一个和第二个函数的结果，所以我们不需要对它进行错误捕获。

最后，我们调用函数来接收数据：

convertCurrency('USD', 'HRK', 20)  .then((message) => {    console.log(message);  }).catch((error) => {    console.log(error.message);  });

你会看到下面的结果：

很不错，你坚持到了最后！如果在学习过程中遇到了困惑的地方，你可以参考这个仓库的代码。如果你有任何问题，可以在下面留言。

原文链接：How To Master Async/Await With This Real World Example，作者：Adrian Hajdin

因为开发过大大大大大大量的 Restful API ，越来越厌烦那种一成不变的代码组织方式。

以 egg为例，要增加一个接口，需要经历繁琐的操作

[路由里注册] ---> [编写 controller] ---> [编写 service] 

哪怕我只是想实现一个 a+b => c！

除此以外，我还调研过某几个比较大的 函数计算 服务商，看看有没有什么好的途径，可以更简便地进行简单接口开发。

让人很失望，天下技术一大抄，它们无一例外都是这样的开发模型：

function(event, context, callback) {}
或者
function(event, context) {}

于是你不得不这样写你的代码

// 举例
function(event, context, callback) {
  const { a, b } = event.arguments; 
  callback(a+b);
}

这算个什么鬼函数？！

你必须改变第一直觉，严格按照厂商的要求来写你的代码，并且寄希望于有人站出来要求它们统一event、context这些旁系知识的实现细节。

并且！

你很难进行本地测试！

你要构造奇奇怪怪的对象作为参数。哪怕只是测试两数相加.

OK! 如果你说，稍微学习一下，其实还是可以用的吧。

可以用就是我们的追求吗？要 应然 还是 实然 ？

难倒我们期望的样子，不应该是这样吗？

// 🔥🔥
function (a, b) {
	return a+b;
}

正文开始：

所以，如果我需要实现一个 a+b => c 的接口，

我期望我的代码是这样的：

export default (a: number, b: number): number => {
  return a + b;
}

我期望我的测试是这样的：

describe('sum', () => {
  it('1+1 is 2', () => {
    assert.equal(sum(1,1), 2);
  });
});

十分明显好吗！

它并不受制于具体平台实现；

它并不需要你学习其他旁系知识，只关注你的功能本身；

它方便测试，因为它就是一个不能再普通的函数；

它可复用！

多说无益，直接动手

export default (a: number, b: number): number => {
  return a + b;
}

有过上一篇的基础，我们直奔抽象语法树：

// 由于只有一行代码，结构就简单多了
{
	type: 'ExportDefaultDeclaration',
	declaration: {
		type: 'ArrowFunctionExpression',
		params: [ 下文展开 ],
		body: { 不重要 },
		returnType: { 下文展开 }
	}
}

我们还是从整体上先看一下，上面这个结构充分表达了源代码的意图：

• 这是一个 export default声明 (ExportDefaultDeclaration )
• 声明的内容是一个箭头函数 (ArrowFunctionExpression )

考虑到，我们希望从这一行代码里面，生成提供HTTP服务的基础代码，

那么我们的主要任务就是，从以上有限的信息当中，提取出Restful API需要的基础信息：

• Method
• Path
• 请求参数

🤖 我们一个一个来解决：

1. HTTP Method

   首选是要确定这个接口，最终通过什么 Method对外服务，在这里源代码并不能提供任何有效信息。

   那么我们就默认用 GET 好了

   🔥其他的 Method，会在文末提及

2. Path， 或者叫 URL

   对于一个接口来说，这也是十分关键的信息，这里我们有两种解决方案

   • 使用函数名，如果有的话
   • 使用当前文件名

   我们姑且把 URL 定为 /sum 好了

   🔥 笔者的一个实验性项目里，使用的是文件名

3. 请求参数

   如果说前面两点都是基于约定，或者一些简单的手段，

   那么在请求参数这个环节，我们必须上价值了，要让 ast 发挥作用！

   我们先展开一下上面 ast 里关于函数参数的部分：

   // params 部分
   [
   	{
   		name: 'a',
   		typeAnnotation: { type: 'TSNumberKeyword' }
   	},
   	{
   		name: 'b',
   		typeAnnotation: { type: 'TSNumberKeyword' }
   	},
   ]
   

   好家伙，可以拿到参数名 a 和 b 了

   结合 TSNumberKeyword 信息，我们甚至能笃定这两个参数是数字类型。

   知道类型，就可以做参数校验！

   🔥通过原始函数定义的参数类型生成 http 参数校验逻辑，比起手工编写 Joi 配置要可靠得多。

   等等，还有一个问题没解决

   参数名和参数类型都有了，缺的就是参数位置以及 content-type 。

   约定大法好，根据多年开发总结得出：

   总所周知， GET 请求的参数就放在 queryString 里吧。

   至于 content-type 统一使用 application/json 不接受反驳

齐活了

结合上面收集到的信息，我们可以想象最终的场景是：

• step 1 : 按上面的方式，编写一个不能再普通的函数
• step 2: 使用我们编写好的工具，运行这个函数
• step 3: 可以通过 http://127.0.0.1:3000/sum?a=11&b=22 来访问这个接口，并且得到结果 33

通过这个截图可知，虽然实现细节比较多，但是可行性是没问题的。

并且笔者已经做出了一个实验性项目。

如果对这种模式比较感兴趣，欢迎前来讨论，在这里就不打广告了。

FAQ 环节

• 更多的 HTTP_METHOD 怎么办？总不能都用 GET 吧

  目前我选能用的方案是，如果没有声明，就用一个默认的 GET，

  因为要尽量选一个能覆盖 90% 情况的作为默认值。

  当我需要使用其他 Method ，我的方案是显式指定，比如

  export const method = 'POST';
  
  export default (a: number, b: number): number => {
    return a + b;
  }
  

  这个方案可以使信息更紧凑，同时不影响函数逻辑跑本地单元测试。

• 上面提到的入参参数位置，什么时候在 queryString，什么时候在其他？

  遵从大多数的案例，GET 的情况下使用 queryString， 其他情况下在 body

  当然还有完全自定义的方案，为避广告嫌疑就不展开了，基本原则还是不影响函数核心逻辑和单元测试。

• 上面提到的 入参参数类型 ，有什么应用场景？

  有了这个信息，如果你喜欢 Joi， 应该能很容易生成参数校验的代码了。

  或者有自己想法的话，和我一样，自己实现一套 validator 也不是什么难事。

在这篇文章里，我会通过一些例子帮助你理解什么是回调函数，如何在 JavaScript 中使用它们。

什么是回调函数？

在 JavaScript 中，函数即对象。我们可以将对象作为参数传递给函数吗？答案是“可以”。

所以，我们可以将函数作为参数传递给其他函数，在外部函数中调用它。听起来有点复杂？我们看一下下面的例子：

function print(callback) {  
    callback();
}

print( ) 函数将另一个函数作为参数，并在函数体内部调用它。在 JavaScript 里，我们叫它“回调”。所以，被传递给另一个函数作为参数的函数叫作回调函数。

为什么需要回调函数？

JavaScript 按从上到下的顺序运行代码。但是，在有些情况下，必须在某些情况发生之后，代码才能运行（或者说必须运行），这就不是按顺序运行了。这是异步编程。

回调函数确保：函数在某个任务完成之前不运行，在任务完成之后立即运行。它帮助我们编写异步 JavaScript 代码，避免问题和错误。

在 JavaScript 里创建回调函数的方法是将它作为参数传递给另一个函数，然后当某个任务完成之后，立即调用它。

如何创建回调函数

我们通过一个简单的例子来理解上面的内容。我们想在控制台打印一条消息（message），它在 3 秒之后显示。

const message = function() {  
    console.log("This message is shown after 3 seconds");
}
 
setTimeout(message, 3000);

JavaScript 有一个内建方法叫作 “setTimeout”，它会在给定的时间段（以毫秒为单位）后调用函数或计算表达式。因此，在这里，经过 3 秒后将调用 message 函数（1 秒= 1000 毫秒） 。

换句话说，message 函数是在发生某事之后（在本示例中为 3 秒之后），而不是在此之前被调用。因此，message 函数就是一个回调函数

什么是匿名函数？

此外，我们可以直接在另一个函数内定义一个函数，而不是调用它，比如：

setTimeout(function() {  
    console.log("This message is shown after 3 seconds");
}, 3000);

我们可以看到，这里的回调函数没有名称。在 JavaScript 里，一个没有名称的函数叫作“匿名函数”。这个例子和上面的例子执行的任务一样。

用箭头函数写回调函数

你也可以用 ES6 箭头函数写回调函数。箭头函数是 JavaScript 里的一种新的函数形式。

setTimeout(() => { 
    console.log("This message is shown after 3 seconds");
}, 3000);

什么是事件？

JavaScript 是一种事件驱动的编程语言。我们还将回调函数用于事件声明。例如，假设我们希望用户单击按钮：

<button id="callback-btn">Click here</button>

这次，只有当用户单击按钮时，我们才会在控制台上看到一条消息：

document.queryselector("#callback-btn")
    .addEventListener("click", function() {    
      console.log("User has clicked on the button!");
});

因此，在这里我们首先通过 ID 选择按钮，然后使用 addEventListener 方法添加一个事件监听器。它有 2 个参数。第一个是其类型，即“click（单击）”，第二个参数是回调函数，该函数记录单击按钮时的消息。

所以，回调函数也用于 JavaScript 中的事件声明。

总结

回调函数在 JavaScript 编程中比较常用。我希望这篇文章可以帮助你理解它是如何运行的，以及如何更好地使用它。接下来，可以学习另一个主题：JavaScript Promises。

谢谢阅读！

原文：JavaScript Callback Functions – What are Callbacks in JS and How to Use Them，作者：Cem Eygi

附上之前写文章写过的一段话：已经有很多关于this的文章，为什么自己还要写一遍呢。学习就好比是座大山，人们沿着不同的路登山，分享着自己看到的风景。你不一定能看到别人看到的风景，体会到别人的心情。只有自己去登山，才能看到不一样的风景，体会才更加深刻。

函数的this在调用时绑定的，完全取决于函数的调用位置（也就是函数的调用方法）。为了搞清楚this的指向是什么，必须知道相关函数是如何调用的。

全局上下文

非严格模式和严格模式中this都是指向顶层对象（浏览器中是window）。

this === window // true
'use strict'
this === window;
this.name = '若川';
console.log(this.name); // 若川

函数上下文

普通函数调用模式

// 非严格模式
var name = 'window';
var doSth = function(){
    console.log(this.name);
}
doSth(); // 'window'

你可能会误以为window.doSth()是调用的，所以是指向window。虽然本例中window.doSth确实等于doSth。name等于window.name。上面代码中这是因为在ES5中，全局变量是挂载在顶层对象（浏览器是window）中。 事实上，并不是如此。

// 非严格模式
let name2 = 'window2';
let doSth2 = function(){
    console.log(this === window);
    console.log(this.name2);
}
doSth2() // true, undefined

这个例子中let没有给顶层对象中（浏览器是window）添加属性，window.name2和window.doSth都是undefined。

严格模式中，普通函数中的this则表现不同，表现为undefined。

// 严格模式
'use strict'
var name = 'window';
var doSth = function(){
    console.log(typeof this === 'undefined');
    console.log(this.name);
}
doSth(); // true，// 报错，因为this是undefined

看过的《你不知道的JavaScript》上卷的读者，应该知道书上将这种叫做默认绑定。 对call，apply熟悉的读者会类比为：

doSth.call(undefined);
doSth.apply(undefined);

效果是一样的，call，apply作用之一就是用来修改函数中的this指向为第一个参数的。 第一个参数是undefined或者null，非严格模式下，是指向window。严格模式下，就是指向第一个参数。后文详细解释。
经常有这类代码（回调函数），其实也是普通函数调用模式。

var name = '若川';
setTimeout(function(){
    console.log(this.name);
}, 0);
// 语法
setTimeout(fn | code, 0, arg1, arg2, ...)
// 也可以是一串代码。也可以传递其他函数
// 类比 setTimeout函数内部调用fn或者执行代码`code`。
fn.call(undefined, arg1, arg2, ...);

对象中的函数（方法）调用模式

var name = 'window';
var doSth = function(){
    console.log(this.name);
}
var student = {
    name: '若川',
    doSth: doSth,
    other: {
        name: 'other',
        doSth: doSth,
    }
}
student.doSth(); // '若川'
student.other.doSth(); // 'other'
// 用call类比则为：
student.doSth.call(student);
// 用call类比则为：
student.other.doSth.call(student.other);

但往往会有以下场景，把对象中的函数赋值成一个变量了。 这样其实又变成普通函数了，所以使用普通函数的规则（默认绑定）。

var studentDoSth = student.doSth;
studentDoSth(); // 'window'
// 用call类比则为：
studentDoSth.call(undefined);

call、apply、bind 调用模式

上文提到call、apply，这里详细解读一下。先通过MDN认识下call和apply MDN 文档：Function.prototype.call()。

语法

fun.call(thisArg, arg1, arg2, ...)

thisArg
在fun函数运行时指定的this值。需要注意的是，指定的this值并不一定是该函数执行时真正的this值，如果这个函数处于非严格模式下，则指定为null和undefined的this值会自动指向全局对象(浏览器中就是window对象)，同时值为原始值(数字，字符串，布尔值)的this会指向该原始值的自动包装对象。
arg1, arg2, ...
指定的参数列表
返回值
返回值是你调用的方法的返回值，若该方法没有返回值，则返回undefined。
apply和call类似。只是参数不一样。它的参数是数组（或者类数组）。

根据参数thisArg的描述，可以知道，call就是改变函数中的this指向为thisArg，并且执行这个函数，这也就使 JavaScript 灵活很多。严格模式下，thisArg是原始值是值类型，也就是原始值。不会被包装成对象。举个例子：

var doSth = function(name){
    console.log(this);
    console.log(name);
}
doSth.call(2, '若川'); // Number{2}, '若川'
var doSth2 = function(name){
    'use strict';
    console.log(this);
    console.log(name);
}
doSth2.call(2, '若川'); // 2, '若川'

虽然一般不会把thisArg参数写成值类型。但还是需要知道这个知识。 之前写过一篇文章：面试官问：能否模拟实现JS的call和apply方法 就是利用对象上的函数this指向这个对象，来模拟实现call和apply的。感兴趣的读者思考如何实现，再去看看笔者的实现。

bind和call和apply类似，第一个参数也是修改this指向，只不过返回值是新函数，新函数也能当做构造函数（new）调用。 MDN Function.prototype.bind

bind()方法创建一个新的函数， 当这个新函数被调用时this键值为其提供的值，其参数列表前几项值为创建时指定的参数序列。
语法： fun.bind(thisArg[, arg1[, arg2[, ...]]])
参数： thisArg 调用绑定函数时作为this参数传递给目标函数的值。 如果使用new运算符构造绑定函数，则忽略该值。当使用bind在setTimeout中创建一个函数（作为回调提供）时，作为thisArg传递的任何原始值都将转换为object。如果没有提供绑定的参数，则执行作用域的this被视为新函数的thisArg。 arg1, arg2, ... 当绑定函数被调用时，这些参数将置于实参之前传递给被绑定的方法。 返回值 返回由指定的this值和初始化参数改造的原函数拷贝。

之前也写过一篇文章：如何模拟实现 JS 的 bind 方法，就是利用call和apply指向这个thisArg参数，来模拟实现bind的。感兴趣的读者思考如何实现，再去看看笔者的实现。

构造函数调用模式

function Student(name){
    this.name = name;
    console.log(this); // {name: '若川'}
    // 相当于返回了
    // return this;
}
var result = new Student('若川');

使用new操作符调用函数，会自动执行以下步骤。

1. 创建了一个全新的对象。
2. 这个对象会被执行[[Prototype]]（也就是__proto__）链接。
3. 生成的新对象会绑定到函数调用的this。
4. 通过new创建的每个对象将最终被[[Prototype]]链接到这个函数的prototype对象上。
5. 如果函数没有返回对象类型Object(包含Functoin, Array, Date, RegExg, Error)，那么new表达式中的函数调用会自动返回这个新的对象。

由此可以知道：new操作符调用时，this指向生成的新对象。 特别提醒一下，new调用时的返回值，如果没有显式返回对象或者函数，才是返回生成的新对象。

function Student(name){
    this.name = name;
    // return function f(){};
    // return {};
}
var result = new Student('若川');
console.log(result); {name: '若川'}
// 如果返回函数f，则result是函数f，如果是对象{}，则result是对象{}

很多人或者文章都忽略了这一点，直接简单用typeof判断对象。虽然实际使用时不会显示返回，但面试官会问到。

之前也写了一篇文章面试官问：能否模拟实现JS的new操作符，是使用apply来把this指向到生成的新生成的对象上。感兴趣的读者思考如何实现，再去看看笔者的实现。

原型链中的调用模式

function Student(name){
    this.name = name;
}
var s1 = new Student('若川');
Student.prototype.doSth = function(){
    console.log(this.name);
}
s1.doSth(); // '若川'

会发现这个似曾相识。这就是对象上的方法调用模式。自然是指向生成的新对象。 如果该对象继承自其它对象。同样会通过原型链查找。 上面代码使用 ES6中class写法则是：

class Student{
    constructor(name){
        this.name = name;
    }
    doSth(){
        console.log(this.name);
    }
}
let s1 = new Student('若川');
s1.doSth();

babel es6转换成es5的结果，可以去babeljs网站转换测试自行试试。

'use strict';

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var Student = function () {
    function Student(name) {
        _classCallCheck(this, Student);

        this.name = name;
    }

    _createClass(Student, [{
        key: 'doSth',
        value: function doSth() {
            console.log(this.name);
        }
    }]);

    return Student;
}();

var s1 = new Student('若川');
s1.doSth();

由此看出，ES6的class也是通过构造函数模拟实现的，是一种语法糖。

箭头函数调用模式

先看箭头函数和普通函数的重要区别：

1、没有自己的this、super、arguments和new.target绑定。 2、不能使用new来调用。 3、没有原型对象。 4、不可以改变this的绑定。 5、形参名称不能重复。

箭头函数中没有this绑定，必须通过查找作用域链来决定其值。 如果箭头函数被非箭头函数包含，则this绑定的是最近一层非箭头函数的this，否则this的值则被设置为全局对象。 比如：

var name = 'window';
var student = {
    name: '若川',
    doSth: function(){
        // var self = this;
        var arrowDoSth = () => {
            // console.log(self.name);
            console.log(this.name);
        }
        arrowDoSth();
    },
    arrowDoSth2: () => {
        console.log(this.name);
    }
}
student.doSth(); // '若川'
student.arrowDoSth2(); // 'window'

其实就是相当于箭头函数外的this是缓存的该箭头函数上层的普通函数的this。如果没有普通函数，则是全局对象（浏览器中则是window）。 也就是说无法通过call、apply、bind绑定箭头函数的this(它自身没有this)。而call、apply、bind可以绑定缓存箭头函数上层的普通函数的this。 比如：

var student = {
    name: '若川',
    doSth: function(){
        console.log(this.name);
        return () => {
            console.log('arrowFn:', this.name);
        }
    }
}
var person = {
    name: 'person',
}
student.doSth().call(person); // '若川'  'arrowFn:' '若川'
student.doSth.call(person)(); // 'person' 'arrowFn:' 'person'

DOM事件处理函数调用

addEventerListener、attachEvent、onclick

<button class="button">onclick</button>
<ul class="list">
    <li>1</li>
    <li>2</li>
    <li>3</li>
</ul>
<script>
    var button = document.querySelector('button');
    button.onclick = function(ev){
        console.log(this);
        console.log(this === ev.currentTarget); // true
    }
    var list = document.querySelector('.list');
    list.addEventListener('click', function(ev){
        console.log(this === list); // true
        console.log(this === ev.currentTarget); // true
        console.log(this);
        console.log(ev.target);
    }, false);
</script>

onclick和addEventerListener是指向绑定事件的元素。 一些浏览器，比如IE6~IE8下使用attachEvent，this指向是window。 顺便提下：面试官也经常考察ev.currentTarget和ev.target的区别。 ev.currentTarget是绑定事件的元素，而ev.target是当前触发事件的元素。比如这里的分别是ul和li。 但也可能点击的是ul，这时ev.currentTarget和ev.target就相等了。

内联事件处理函数调用

<button class="btn1" onclick="console.log(this === document.querySelector('.btn1'))">点我呀</button>
<button onclick="console.log((function(){return this})());">再点我呀</button>

第一个是button本身，所以是true，第二个是window。这里跟严格模式没有关系。 当然我们现在不会这样用了，但有时不小心写成了这样，也需要了解。

其实this的使用场景还有挺多，比如对象object中的getter、setter的this，new Function()、eval。 但掌握以上几种，去分析其他的，就自然迎刃而解了。 使用比较多的还是普通函数调用、对象的函数调用、new调用、call、apply、bind调用、箭头函数调用。 那么他们的优先级是怎样的呢。

优先级

而箭头函数的this是上层普通函数的this或者是全局对象（浏览器中是window），所以排除，不算优先级。

var name = 'window';
var person = {
    name: 'person',
}
var doSth = function(){
    console.log(this.name);
    return function(){
        console.log('return:', this.name);
    }
}
var Student = {
    name: '若川',
    doSth: doSth,
}
// 普通函数调用
doSth(); // window
// 对象上的函数调用
Student.doSth(); // '若川'
// call、apply 调用
Student.doSth.call(person); // 'person'
new Student.doSth.call(person);

试想一下，如果是Student.doSth.call(person)先执行的情况下，那new执行一个函数。是没有问题的。 然而事实上，这代码是报错的。运算符优先级是new比点号低，所以是执行new (Student.doSth.call)(person) 而Function.prototype.call，虽然是一个函数（apply、bind也是函数），跟箭头函数一样，不能用new调用。所以报错了。

Uncaught TypeError: Student.doSth.call is not a constructor

这是因为函数内部有两个不同的方法：[[Call]]和[[Constructor]]。 当使用普通函数调用时，[[Call]]会被执行。当使用构造函数调用时，[[Constructor]]会被执行。call、apply、bind和箭头函数内部没有[[Constructor]]方法。

从上面的例子可以看出普通函数调用优先级最低，其次是对象上的函数。 call（apply、bind）调用方式和new调用方式的优先级，在《你不知道的JavaScript》是对比bind和new，引用了mdn的bind的ployfill实现，new调用时bind之后的函数，会忽略bind绑定的第一个参数，(mdn的实现其实还有一些问题，感兴趣的读者，可以看我之前的文章：面试官问：能否模拟实现JS的bind方法)，说明new的调用的优先级最高。 所以它们的优先级是new 调用 > call、apply、bind 调用 > 对象上的函数调用 > 普通函数调用。

总结

如果要判断一个运行中函数的 this 绑定， 就需要找到这个函数的直接调用位置。 找到之后 就可以顺序应用下面这四条规则来判断 this 的绑定对象。

1. new 调用：绑定到新创建的对象，注意：显示return函数或对象，返回值不是新创建的对象，而是显式返回的函数或对象。
   
2. call 或者 apply（ 或者 bind） 调用：严格模式下，绑定到指定的第一个参数。非严格模式下，null和undefined，指向全局对象（浏览器中是window），其余值指向被new Object()包装的对象。
   
3. 对象上的函数调用：绑定到那个对象。
   
4. 普通函数调用： 在严格模式下绑定到 undefined，否则绑定到全局对象。
   

ES6 中的箭头函数：不会使用上文的四条标准的绑定规则， 而是根据当前的词法作用域来决定this， 具体来说， 箭头函数会继承外层函数，调用的 this 绑定（ 无论 this 绑定到什么），没有外层函数，则是绑定到全局对象（浏览器中是window）。 这其实和 ES6 之前代码中的 self = this 机制一样。

DOM事件函数：一般指向绑定事件的DOM元素，但有些情况绑定到全局对象（比如IE6~IE8的attachEvent）。

一定要注意，有些调用可能在无意中使用普通函数绑定规则。 如果想“ 更安全” 地忽略 this 绑 定， 你可以使用一个对象， 比如ø = Object.create(null)， 以保护全局对象。

面试官考察this指向就可以考察new、call、apply、bind，箭头函数等用法。从而扩展到作用域、闭包、原型链、继承、严格模式等。这就是面试官乐此不疲的原因。