1. JavaScript 函数定义

📑📑在 JavaScript 中，函数可以通过 function 关键字来定义。
📌函数定义的一般语法如下：

function functionName(parameters) {
  // 函数体
  return returnValue; // 可选
}

📌以下是一个简单的例子，定义了一个接收两个参数并返回它们之和的函数：

function add(num1, num2) {
  return num1 + num2;
}

📌可以通过以下方式调用该函数：

var sum = add(2, 3); // sum 的值为 5

📌函数也可以使用匿名函数的形式定义，例如：

var add = function(num1, num2) {
  return num1 + num2;
}

📌这种方式定义的函数可以通过变量名来调用，例如：

var sum = add(2, 3); // sum 的值为 5

2. JavaScript 函数参数

2.1 函数显式参数(Parameters)与隐式参数(Arguments)

📑📑在 JavaScript 中，函数的参数有两种类型：显式参数和隐式参数。

2.1.1 显式参数（Parameters）

📌显式参数是在函数定义时声明的参数，它们的值在函数调用时通过传递实参来确定。
例如：

function add(x, y) {
  return x + y;
}

add(2, 3); // 5

2.1.2 隐式参数（Arguments）

📌隐式参数是在函数内部自动创建的一个对象，它包含了所有传递给函数的实参。它是一个类数组对象，可以通过下标访问其中的元素。
例如：

function sum() {
  let total = 0;
  for (let i = 0; i < arguments.length; i++) {
    total += arguments[i];
  }
  return total;
}

sum(1, 2, 3, 4); // 10

📌隐式参数 arguments 是一个类数组对象，它没有数组的所有方法，如果需要使用数组方法，需要将其转换成真正的数组。
例如：

function toArray() {
  return Array.prototype.slice.call(arguments);
}

toArray(1, 2, 3); // [1, 2, 3]

2.2 arguments 对象

📌在 JavaScript 中，每个函数都有一个内部对象 arguments，它表示函数的实参集合。arguments 对象是一个类数组对象，可以通过下标访问其中的元素。

例如，下面的函数可以计算任意数量的实参的总和：

function sum() {
  let total = 0;
  for (let i = 0; i < arguments.length; i++) {
    total += arguments[i];
  }
  return total;
}

sum(1, 2, 3, 4); // 10

📌arguments 对象不是一个真正的数组，它没有数组的所有方法，如果需要使用数组方法，需要将其转换成真正的数组。
例如：

function toArray() {
  return Array.prototype.slice.call(arguments);
}

toArray(1, 2, 3); // [1, 2, 3]

3. JavaScript 函数调用

3.1 this 关键字

📑📑在 JavaScript 中，关键字 this 通常用于引用当前函数所属的对象。this 的值在函数调用时确定，并且取决于调用函数的方式。
下面是一些常见的 this 使用方式：

📌全局环境中的 this：在全局环境中，this 指向全局对象（在浏览器中是 window 对象）。
例如：

console.log(this); // 输出 window 对象

📌对象方法中的 this：在对象方法中，this 指向调用该方法的对象。
例如：

let person = {
  name: 'Tom',
  sayHi: function() {
    console.log('Hi, my name is ' + this.name);
  }
};

person.sayHi(); // 输出 Hi, my name is Tom

📌构造函数中的 this：在构造函数中，this 指向新创建的对象。
例如：

function Person(name) {
  this.name = name;
  this.sayHi = function() {
    console.log('Hi, my name is ' + this.name);
  }
}

let person1 = new Person('Tom');
let person2 = new Person('Jerry');

person1.sayHi(); // 输出 Hi, my name is Tom
person2.sayHi(); // 输出 Hi, my name is Jerry

📌apply 和 call 方法中的 this：在 apply 和 call 方法中，this 可以指向任意对象。
例如：

function sayHi() {
  console.log('Hi, my name is ' + this.name);
}

let person1 = {name: 'Tom'};
let person2 = {name: 'Jerry'};

sayHi.call(person1); // 输出 Hi, my name is Tom
sayHi.call(person2); // 输出 Hi, my name is Jerry

当函数作为普通函数调用时，this 指向全局对象；
当函数作为对象方法调用时，this 指向调用该方法的对象；
当函数作为构造函数调用时，this 指向新创建的对象；
当函数使用 apply 或 call 方法调用时，this 可以指向任意对象。

3.2 全局对象

在 JavaScript 中，全局对象是一个特殊的对象，它是全局作用域中所有变量和函数的宿主对象。在浏览器中，全局对象是 window对象，它包含了所有浏览器窗口的全局变量和函数。在 Node.js 中，全局对象是 global 对象，它包含了所有 Node.js程序的全局变量和函数。
全局对象可以通过 this 关键字来引用。在全局作用域中，this 指向全局对象本身。例如，在浏览器中，可以通过window.alert() 来弹出一个对话框，也可以通过 this.alert() 来实现同样的效果。
全局对象还包含了一些内置的属性和方法，例如在浏览器中，window 对象包含了document、consolesetTimeout、setInterval 等属性和方法，可以通过window.document、window.console、window.setTimeout、window.setInterval等来访问它们。

4. 使用构造函数调用函数

📑📑在 JavaScript 中，函数可以通过构造函数的方式调用，这种方式被称为构造函数调用。当使用 new 操作符调用一个函数时，该函数会被作为构造函数来使用，它将返回一个新创建的对象。

下面是一个使用构造函数调用函数的示例：

function Person(name, age) {
  this.name = name;
  this.age = age;
}

let person1 = new Person('Tom', 18);
let person2 = new Person('Jerry', 20);

console.log(person1); // {name: "Tom", age: 18}
console.log(person2); // {name: "Jerry", age: 20}

构造函数的名称通常以大写字母开头，这是一种约定俗成的写法，用来区分普通函数和构造函数。

另外，使用构造函数调用函数时，如果构造函数中没有显式地返回一个对象，则构造函数会默认返回新创建的对象。如果构造函数中显式地返回一个对象，则该对象将会被返回，而新创建的对象将被忽略。

5. JavaScript 闭包

📑📑在 JavaScript 中，闭包是指一个函数可以访问其词法作用域之外的变量。换句话说，闭包可以访问在函数定义时处于父级作用域中的变量，即使在函数调用时，这些变量已经不在父级作用域中了。
下面是一个使用闭包的例子：

function outer() {
  var count = 0;

  function inner() {
    count++;
    console.log(count);
  }

  return inner;
}

var counter = outer();
counter(); // 输出 1
counter(); // 输出 2