每个 Node 开发人员都必须掌握的 10 个 JavaScript 概念

一. JavaScript 闭包

JavaScript 中的闭包（Closure）是指一个内部函数能够访问其外部函数的作用域，即使外部函数已经执行完毕。闭包的这一特性使得内部函数能够访问和操作外部函数的作用域中的变量，从而创建了所谓的“私有变量”。

示例代码：

// 定义一个外部函数，它返回一个内部函数
function counter() { // 定义外部函数
  let _counter = 0; // 定义一个计数器变量，只能被内部函数访问
  return function() { // 返回一个内部函数
    _counter++; // 每次调用内部函数时，计数器加一
    return _counter; // 返回当前计数器的值
  }
}

const incrementCounter = counter(); // 创建一个计数器实例
console.log(incrementCounter()); // 输出: 1
console.log(incrementCounter()); // 输出: 2

这段代码展示了如何使用闭包来创建一个计数器，每次调用返回的函数时，计数器的值就会增加。

二. JavaScript 原型

JavaScript 的原型链是实现继承的核心机制之一。每个函数都有一个 prototype 属性，这个属性是用来初始化新创建的对象的。当我们通过构造函数创建一个新对象时，这个对象就会从构造函数的 prototype 属性继承属性和方法。

示例代码：

function Person(name) { // 定义一个构造函数
  this.name = name; // 设置对象的名字属性
}

Person.prototype.greet = function() { // 向构造函数的原型添加方法
  console.log(`Hello, my name is ${this.name}.`); // 打印问候语句
};

const person = new Person('Alice'); // 创建一个新的 Person 实例
person.greet(); // 输出: Hello, my name is Alice.

这个例子中，我们定义了一个 Person 构造函数，并向其原型链中添加了一个 greet 方法。这样，所有通过 Person 构造函数创建的对象都可以访问 greet 方法。

三. 使用哈希名称定义私有属性

JavaScript ES6 引入了私有类字段的概念，通过使用 # 符号前缀定义私有属性。这使得类的成员可以在类的外部保持隐藏状态，同时允许在类的内部方法之间共享数据。

示例代码：

class MyClass {
  #privateField = 'This is a private field'; // 定义私有字段

  getPrivateField() { // 提供一个公共方法来访问私有字段
    return this.#privateField; // 返回私有字段的值
  }

  setPrivateField(value) { // 提供一个公共方法来设置私有字段
    this.#privateField = value; // 设置私有字段的值
  }
}

const instance = new MyClass(); // 创建类的一个实例
console.log(instance.getPrivateField()); // 输出: This is a private field
instance.setPrivateField('New value for private field');
console.log(instance.getPrivateField()); // 输出: New value for private field

这个例子演示了如何在类中定义私有属性，并通过公共方法来访问和修改这些私有属性。

四. 使用闭包定义私有属性

除了使用 # 符号定义私有属性外，另一种常见的做法是使用闭包来模拟私有变量。这种方法在不支持私有类字段的老版本 JavaScript 中非常有用。

示例代码：

function createCounter() { // 创建一个计数器
  let count = 0; // 定义一个私有变量
  return { // 返回一个对象，该对象包含公共方法
    increment: function() { // 定义一个公共方法
      count++; // 私有变量的值增加
      return count; // 返回私有变量的当前值
    },
    getCount: function() { // 定义一个公共方法来获取私有变量的值
      return count; // 返回私有变量的值
    }
  };
}

const counter = createCounter(); // 创建一个计数器实例
console.log(counter.increment()); // 输出: 1
console.log(counter.increment()); // 输出: 2
console.log(counter.getCount()); // 输出: 2

这个例子展示了如何使用闭包来创建一个计数器对象，该对象具有两个公共方法来修改和读取一个私有变量的值。

五. JavaScript 模块

Node.js 支持两种主要的模块系统：CommonJS 和 ES6 模块。CommonJS 是 Node.js 的默认模块系统，而 ES6 模块则更加现代化并且逐渐成为主流。

示例代码：

使用 CommonJS：

// module.js 文件内容
exports.add = function(a, b) { // 导出一个函数
  return a + b; // 返回两数之和
};

// main.js 文件内容
const module = require('./module.js'); // 导入模块
console.log(module.add(1, 2)); // 输出: 3

使用 ES6 模块：

// module.js 文件内容
export default function add(a, b) { // 导出一个函数
  return a + b; // 返回两数之和
};

// main.js 文件内容
import add from './module.js'; // 导入模块
console.log(add(1, 2)); // 输出: 3

这两个例子分别展示了如何使用 CommonJS 和 ES6 模块来导入和导出函数。

六. 错误处理

错误处理是编写健壮应用程序的关键部分。Node.js 提供了多种方式来处理错误，包括 try/catch 语句、错误对象的 throw 和 on() 处理程序。

示例代码：

try { // 尝试执行可能出错的代码
  const result = performOperation(); // 执行操作
  console.log(result); // 打印结果
} catch (error) { // 捕获任何发生的错误
  console.error(error.message); // 打印错误信息
  if (error instanceof TypeError) { // 如果错误类型为 TypeError
    throw new Error('Type mismatch occurred.'); // 抛出一个新的错误
  }
}

function performOperation() { // 定义一个可能抛出错误的函数
  throw new TypeError('Expected number, got string.'); // 抛出一个类型错误
}

这个例子展示了如何使用 try/catch 语句来捕获和处理错误。

七. JavaScript 局部套用（柯里化）

柯里化（Currying）是一种技术，它允许您创建新的函数，这些函数保留了原始函数的部分参数，以便稍后调用时可以补充剩余的参数。

示例代码：

function curry(fn) { // 定义一个柯里化函数
  return function curried(...args) { // 返回一个闭包
    if (args.length >= fn.length) { // 如果传入的参数足够多
      return fn.apply(this, args); // 直接调用原函数
    } else { // 否则返回一个新的函数
      return function(...args2) { // 返回一个带有剩余参数的新函数
        return curried.apply(this, [...args, ...args2]); // 递归调用
      };
    }
  };
}

function add(a, b, c) { // 定义一个函数
  return a + b + c; // 返回三数之和
}

const curriedAdd = curry(add); // 创建一个柯里化的 add 函数
console.log(curriedAdd(1)(2)(3)); // 输出: 6
console.log(curriedAdd(1, 2)(3)); // 输出: 6

这个例子展示了如何使用柯里化技术来创建一个可以部分应用参数的函数。

八. JavaScript apply, call 和 bind 方法

这些方法用于改变函数内部 this 的值。它们各有用途，但都能帮助开发者更好地控制函数的执行上下文。

示例代码：

const obj = {
  value: 42,
  getValue: function() { // 定义一个方法
    console.log(this.value); // 打印 this 的 value 属性
  }
};

obj.getValue(); // 输出: 42

const anotherObj = {
  value: 21
};

obj.getValue.call(anotherObj); // 使用 call 方法改变 this 的值，输出: 21
obj.getValue.apply(anotherObj, []); // 使用 apply 方法改变 this 的值，输出: 21

const boundMethod = obj.getValue.bind(anotherObj); // 使用 bind 方法绑定 this 的值
boundMethod(); // 输出: 21

这个例子展示了如何使用 call, apply 和 bind 方法来改变函数执行时的 this 上下文。

九. JavaScript 记忆化

记忆化（Memoization）是一种优化技术，通过缓存函数计算的结果来加速未来的调用。JavaScript 中的记忆化通常通过创建一个对象来存储已计算过的值。

示例代码：

function memoize(fn) { // 定义一个记忆化函数
  const cache = {}; // 创建一个缓存对象
  return function(...args) { // 返回一个闭包
    const key = JSON.stringify(args); // 生成一个基于参数的唯一键
    if (!cache[key]) { // 如果缓存中没有这个键
      cache[key] = fn.apply(this, args); // 计算并存储结果
    }
    return cache[key]; // 返回缓存的结果
  };
}

function factorial(n) { // 定义一个递归函数
  if (n < 2) { // 基础情况
    return 1; // 返回 1
  }
  return n * factorial(n - 1); // 递归调用
}

const memoizedFactorial = memoize(factorial); // 创建一个记忆化的阶乘函数
console.log(memoizedFactorial(5)); // 输出: 120
console.log(memoizedFactorial(5)); // 再次输出: 120（这次是从缓存）

这个例子展示了如何使用记忆化技术来优化递归函数的性能。

十. JavaScript IIFE

立即调用的函数表达式（Immediately Invoked Function Expression, IIFE）是一种在定义时立即执行的函数。这种模式常用于创建局部作用域，避免全局污染。

示例代码：

(function immediate() { // 定义一个立即执行的函数
  const secret = 'I am immediately invoked!'; // 创建一个局部变量
  console.log(secret); // 打印局部变量
})();

// 下面的代码不会打印任何东西，因为 secret 是局部作用域内的
console.log(secret); // ReferenceError: secret is not defined

这个例子展示了如何使用 IIFE 来创建一个独立的作用域。

通过掌握以上提到的这些 JavaScript 核心概念和技术，你可以在开发过程中编写更加高效、可维护的代码。