模块模式函数语法 - Javascript

在Javascript中，模块模式是一种常见的组织代码的方式。它通过使用函数作用域和闭包来实现私有变量和方法，以及对外暴露公共接口。模块模式可以帮助我们减少全局作用域中的变量污染，提高代码的可维护性和可读性。

基本语法

模块模式的基本语法是一个立即执行的函数表达式，它可以定义私有变量和方法，然后返回一个对象，该对象包含对外暴露的公共接口。

下面是一个使用模块模式的例子：

var myModule = (function() {
  // 定义私有变量和方法
  var privateVariable = "I am private";
  function privateMethod() {
    console.log("私有方法被调用");
  }

  // 将公共接口返回给外部
  return {
    publicMethod: function() {
      console.log("公共方法被调用");
      privateMethod();
    },
    publicVariable: "I am public"
  };
})();

// 调用公共方法
myModule.publicMethod(); // 输出: "公共方法被调用" 和 "私有方法被调用"
console.log(myModule.publicVariable); // 输出: "I am public"

在上面的例子中，我们使用一个立即执行的函数表达式来创建一个名为myModule的模块。该模块包含一个私有变量和一个私有方法，以及两个对外暴露的公共接口：publicMethod和publicVariable。我们可以通过调用myModule.publicMethod()和访问myModule.publicVariable来使用这些公共接口。

高级用法

除了基本语法，我们还可以使用模块模式高级用法来实现更复杂的功能，比如单例模式、惰性载入和命名空间等。

单例模式

如果我们想创建一个全局唯一的对象，可以使用单例模式。单例模式可以通过在模块中缓存一个实例，并在需要时返回该实例来实现。

下面是一个使用单例模式的例子：

var mySingleton = (function() {
  // 定义私有变量和方法
  var instance;
  function init() {
    // 私有方法和变量
    var privateVariable = "I am private";
    function privateMethod() {
      console.log("私有方法被调用");
    }

    // 将公共接口返回给外部
    return {
      publicMethod: function() {
        console.log("公共方法被调用");
        privateMethod();
      },
      publicVariable: "I am public"
    };
  }

  // 如果存在实例，则直接返回该实例；否则创建一个新实例
  return {
    getInstance: function() {
      if (!instance) {
        instance = init();
      }
      return instance;
    }
  };
})();

// 调用公共方法
var singleton1 = mySingleton.getInstance();
singleton1.publicMethod(); // 输出: "公共方法被调用" 和 "私有方法被调用"
console.log(singleton1.publicVariable); // 输出: "I am public"

var singleton2 = mySingleton.getInstance();
console.log(singleton1 === singleton2); // 输出: true

在上面的例子中，我们使用一个立即执行的函数表达式来创建一个名为mySingleton的模块。该模块包含一个内部函数init，该函数用于创建一个包含私有变量和方法和公共接口的对象。我们通过定义一个instance变量来缓存该对象的实例。当我们第一次调用mySingleton.getInstance()时，如果instance不存在，就会创建一个新实例；否则直接返回该实例。这样，我们就实现了一个全局唯一的对象。

惰性载入

如果我们想实现一个模块仅在需要时才加载，可以使用惰性载入。惰性载入可以通过在模块中定义一个load方法，并在需要时调用该方法来实现。

下面是一个使用惰性载入的例子：

var myLazyModule = (function() {
  var loaded = false;
  
  function loadModule() {
    // 动态载入模块
    console.log("模块已经加载");
    loaded = true;
  }

  function publicMethod() {
    // 调用load方法
    if (!loaded) {
      loadModule();
    }
    console.log("公共方法被调用");
  }

  return {
    publicMethod: publicMethod
  };
})();

// 第一次调用publicMethod时，会先加载模块
myLazyModule.publicMethod(); // 输出: "模块已经加载" 和 "公共方法被调用"

// 第二次调用publicMethod时，因为已经加载过了，所以不会再次加载模块
myLazyModule.publicMethod(); // 输出: "公共方法被调用"

在上面的例子中，我们使用一个立即执行的函数表达式来创建一个名为myLazyModule的模块。该模块包含一个私有变量loaded，用于标记模块是否已经加载；以及一个私有方法loadModule，用于在模块第一次被调用时加载模块。我们通过在publicMethod方法中调用loadModule方法来实现惰性载入。这样，我们就可以在需要时才加载模块，提高性能和可维护性。

命名空间

如果我们想避免命名冲突，可以使用命名空间。命名空间可以通过在全局作用域中创建一个对象，并将模块定义为该对象的一个属性来实现。

下面是一个使用命名空间的例子：

var myNamespace = {
  myModule1: (function() {
    function privateMethod() {
      console.log("私有方法被调用");
    }

    return {
      publicMethod: function() {
        console.log("公共方法 1 被调用");
        privateMethod();
      }
    };
  })(),
  myModule2: (function() {
    function privateMethod() {
      console.log("私有方法被调用");
    }

    return {
      publicMethod: function() {
        console.log("公共方法 2 被调用");
        privateMethod();
      }
    };
  })()
};

// 通过命名空间调用模块的公共方法
myNamespace.myModule1.publicMethod(); // 输出: "公共方法 1 被调用" 和 "私有方法被调用"
myNamespace.myModule2.publicMethod(); // 输出: "公共方法 2 被调用" 和 "私有方法被调用"

在上面的例子中，我们使用一个全局对象myNamespace来包含两个模块myModule1和myModule2。这两个模块定义方式和基本语法类似，但是在各自的闭包中定义的私有变量和方法不会相互干扰。我们可以通过myNamespace.myModule1.publicMethod()和myNamespace.myModule2.publicMethod()来分别调用这两个模块的公共方法。

结论

模块模式是一种常见的组织Javascript代码的方式，它可以帮助我们减少全局作用域中的变量污染，提高代码的可维护性和可读性。除了基本语法，我们还可以使用模块模式高级用法来实现更复杂的功能，比如单例模式、惰性载入和命名空间等。掌握模块模式的基本语法和高级用法，可以使我们更加高效地编写Javascript代码。