递归函数是在函数的定义中调用函数自身的一种方法。在JavaScript中，可以使用递归来解决许多问题，比如遍历数组，处理嵌套对象，或者解决需要重复执行相同或类似任务的问题。

这是一个基本的JavaScript递归函数的例子：

function recursiveFunction(n) {  
  if (n <= 0) { // 基本情况  
    return;  
  }  
  
  console.log(n); // 执行一些任务  
  
  return recursiveFunction(n - 1); // 递归情况  
}  
  
recursiveFunction(5); // 输出：5 4 3 2 1

在这个例子中，recursiveFunction 是一个递归函数，它接受一个参数 n。如果 n 小于或等于0，这就是基本情况，函数不再递归调用自身，而是直接返回。否则，函数会执行一些任务（在这个例子中，只是打印出 n），然后调用自身，但是这次传入的参数是 n - 1。这就是递归情况。

需要注意的是，如果没有基本情况或者递归情况不满足，那么递归将会无限进行下去，这可能会导致栈溢出错误。因此，设计递归函数时，需要确保有一个或多个基本情况可以终止递归。

在 JavaScript 中，尾调用（Tail Call）是指在一个函数的调用栈中，最后一个操作是调用另一个函数，而不是执行其他操作（比如返回值或者抛出异常）。

在尾调用中，调用栈的最后一个元素是一个函数调用，并且这个函数调用后面没有任何其他操作。这意味着在这个函数调用之后，程序就结束了，不再执行其他代码。

在 JavaScript 中，尾调用优化是一种优化技术，可以将尾调用中的一些开销省略，从而提高程序的执行效率。具体来说，如果一个函数是通过尾调用调用的，那么这个函数可以直接使用被调用函数的堆栈帧，而不是创建新的堆栈帧。这样可以省去创建和销毁堆栈帧的开销，提高程序的执行效率。

需要注意的是，尾调用优化只适用于通过尾调用调用的函数没有改变调用上下文的情况。如果函数改变了调用上下文，比如修改了全局变量或者调用了其他函数，那么就不能使用尾调用优化。

尾调用优化（Tail Call Optimization，TCO）是一种在函数式编程中常见的优化技术，它可以在调用链的尾部减少不必要的堆栈帧创建和销毁，提高程序的执行效率。在 JavaScript 中，要实现尾调用优化，需要满足以下条件：

1. 调用必须是尾调用：在函数调用的最后一步是调用另一个函数，而不是执行其他操作（比如返回值或者抛出异常）。

2. 必须直接或间接地返回其自身的结果：尾调用返回的结果必须是调用结果的最后一个步骤。

3. 不能改变调用上下文：在尾调用过程中，不能有任何操作改变了当前的调用上下文，比如修改全局变量或者调用其他函数。

在 JavaScript 中，由于第一条和第二条条件很容易满足，大多数情况下可以实现尾调用优化。但是，如果使用了闭包或者递归调用了可能会导致堆栈溢出，所以在实际的开发中，需要注意控制递归调用的深度，或者采用其他非递归的方式实现算法。

以下是一个使用尾调用优化的 JavaScript 代码示例：

// 非尾调用版本  
function sum(a, b) {  
  return a + b;  
}  
  
function multiply(a, b) {  
  return a * b;  
}  
  
function calculate(a, b) {  
  let result = sum(a, b);  
  return multiply(result, 2);  
}  
  
console.log(calculate(3, 4)); // 输出 14  
  
// 尾调用版本  
function sum(a, b) {  
  return a + b;  
}  
  
function multiply(a, b) {  
  return a * b;  
}  
  
function calculate(a, b) {  
  return multiply(sum(a, b), 2); // 调用 sum 后直接返回结果，不创建新的变量 result  
}  
  
console.log(calculate(3, 4)); // 输出 14

在尾调用版本中，直接在 calculate 函数中将 sum 的结果作为参数传递给 multiply 函数，避免了创建新的变量 result，从而减少了堆栈帧的创建和销毁，提高了程序的执行效率。

在JavaScript中，闭包是一个非常重要的概念，是函数和声明该函数的词法环境的组合。这个环境包含了这个闭包创建时所能访问的所有局部变量。

在JavaScript中，函数是第一类对象，可以像其他对象一样操作，例如可以将函数作为参数传递，可以从函数返回函数，也可以将函数赋值给变量。由于函数是在其词法环境中定义的，当一个函数在其定义环境之外被引用时，它仍然可以访问其定义环境的变量和函数，这就是闭包。

下面是一个典型的JavaScript闭包例子：

function outerFunction(outerVariable) {  
    return function innerFunction(innerVariable) {  
        console.log('outerVariable:', outerVariable);  
        console.log('innerVariable:', innerVariable);  
    }  
}  
  
const newFunction = outerFunction('outside');  
newFunction('inside'); // logs out 'outerVariable: outside' 'innerVariable: inside'

在这个例子中，outerFunction是一个外部函数，它接受一个外部变量outerVariable并返回一个内部函数innerFunction。innerFunction可以访问到outerVariable，即使outerFunction已经执行完毕。当执行newFunction时，它仍然可以访问到outerVariable的值。这就是因为outerFunction的词法环境形成了闭包，使得innerFunction可以在其定义环境之外访问到outerVariable。

闭包在JavaScript编程中非常有用，常见的应用包括创建私有变量，实现函数工厂和模块化开发等。

JavaScript中的闭包可能会导致内存泄漏，这是由于闭包可以维持函数执行上下文，使得一些不再需要的变量仍然被引用和使用，导致垃圾回收器无法回收这些内存。

下面是一个可能导致内存泄漏的闭包示例：

function createLeakyFunction() {  
  let x = [];  
  return function() {  
    x.push(arguments);  
  };  
}  
  
const leakyFunc = createLeakyFunction();  
leakyFunc(1, 2, 3); // x now contains the arguments

在这个例子中，内部函数可以访问外部函数的变量x，并且通过调用leakyFunc将参数推入x数组中。即使外部函数已经执行完毕，x数组仍然被内部函数引用，并且无法被垃圾回收器回收，从而导致内存泄漏。

为了避免这种内存泄漏，可以尝试将闭包中不必要的变量解构掉，或者将不必要的数据结构置为 null，以便垃圾回收器能够回收它们。例如：

function createNonLeakyFunction() {  
  let x = [];  
  return function() {  
    x.push(arguments);  
  };  
}  
  
const nonLeakyFunc = createNonLeakyFunction();  
nonLeakyFunc(1, 2, 3); // x now contains the arguments  
x = null; // x can now be garbage collected

立即调用的函数表达式（Immediately Invoked Function Expression，IIFE）是一种在 JavaScript 中常用的模式，可以创建一个新的作用域以避免全局作用域的污染。

一个立即调用的函数表达式定义了一个函数，然后这个函数立即在其定义之后被调用。这种模式非常有用，因为它创建了一个新的作用域，使得在其中定义的变量不会泄漏到全局作用域中。

以下是一个立即调用的函数表达式的例子：

(function() {  
    var a = 10;  
    console.log(a);  // 输出 10  
})();  
  
console.log(a);  // 报错，因为变量 a 在全局作用域中是未定义的

在这个例子中，var a = 10; 在一个立即调用的函数表达式中定义，所以 a 只在该函数表达式的作用域中存在。在全局作用域中，a 是未定义的，所以 console.log(a); 会报错。

这种模式常常在模块化开发和避免全局变量污染的场景中使用。