🏘️🏘️个人简介：以山河作礼。
🎖️🎖️:Python领域新星创作者，CSDN实力新星认证，阿里云社区专家博主
🎁🎁:Web全栈开发专栏：《Web全栈开发》免费专栏，欢迎阅读！

1. JavaScript 函数定义

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

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

其中，functionName 是函数的名称，parameters
是函数的参数列表，可以是多个参数，用逗号分隔。函数体是函数执行的代码块，可以包含任意数量的语句。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

在上面的例子中，x 和 y 就是函数 add 的显式参数。在函数调用时，实参 2 和 3 会分别赋值给 x 和 y。

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 就是函数 sum 的隐式参数。在函数调用时，实参 1、2、3 和 4 会被存储在 arguments
对象中，然后通过循环遍历 arguments 对象来计算它们的总和。

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

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

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

在上面的例子中，使Array.prototype.slice.call(arguments) 将 arguments
对象转换成了一个真正的数组，然后返回该数组。

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 对象包含了所有传递给函数 sum 的实参，通过循环遍历 arguments 对象，可以计算出它们的总和。

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

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

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

使用 Array.prototype.slice.call(arguments) 将 arguments
对象转换成了一个真正的数组，然后返回该数组。

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}

Person 函数被作为构造函数来使用，通过 new 操作符创建了两个新的对象 person1 和 person2。在构造函数中，使用
this 关键字来指向新创建的对象，并将属性赋值给它们。最后，构造函数返回新创建的对象。

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

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

5. JavaScript 闭包

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

function outer() {
  var count = 0;

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

  return inner;
}

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

outer 函数返回了一个内部函数 inner，该函数可以访问 outer 函数中的 count 变量。当 outer函数被调用时，它创建了一个新的词法作用域，并在其中定义了 count 变量和 inner 函数。然后，outer 函数返回 inner 函数，使其可以在外部作用域中被调用。

当 counter 函数被调用时，它会访问 outer 函数中的 count 变量，并将其递增。由于 inner 函数是一个闭包，它可以访问outer 函数中的 count 变量，即使 outer 函数已经执行完毕并且 count变量已经不在 outer 函数的作用域中了。

闭包在 JavaScript 中有广泛的应用，例如在模块化编程中、实现私有变量和方法、以及在异步编程中保存状态等。但是，由于闭包可以访问外部作用域中的变量，如果不妥善地使用闭包，可能会导致内存泄漏和性能问题。因此，在使用闭包时，需要谨慎考虑其影响，并避免滥用。