자바스크립트 모듈식 프로그래밍 재판

Javascript Modular 프로그래밍

저자: Ruan Yifeng 출판일: 2013-01-08 18:04 읽기: 7632회 추천: 40 원본 링크 [즐겨찾기]

웹사이트가 점차 "인터넷 애플리케이션"으로 변모하면서 웹페이지에 포함된 Javascript 코드가 점점 더 커지고 복잡해지고 있습니다.

웹 페이지는 점점 더 데스크톱 프로그램과 비슷해지고 있어 팀의 업무 분담과 협업, 진행 관리, 단위 테스트 등이 필요합니다. 개발자는 웹의 비즈니스 로직을 관리하기 위해 소프트웨어 엔지니어링 방법을 사용해야 합니다. 페이지.

Javascript 모듈형 프로그래밍이 시급한 요구 사항이 되었습니다. 이상적으로는 개발자가 핵심 비즈니스 로직만 구현하면 되고, 다른 모듈은 다른 모듈이 로드할 수 있습니다.

그러나 Javascript는 "모듈"은 물론 "클래스"도 지원하지 않는 모듈형 프로그래밍 언어입니다. (공식화되고 있는 ECMAScript 표준 6판에서는 "클래스"와 "모듈"을 공식적으로 지원할 예정이지만, 실제로 적용되기까지는 오랜 시간이 걸릴 것입니다.)

Javascript 커뮤니티에서 기존의 실행환경을 개선하기 위한 많은 노력으로 "모듈"의 효과를 얻을 수 있었습니다. 이 기사에서는 "Javascript 모듈식 프로그래밍"의 현재 모범 사례를 요약하고 이를 실제로 적용하는 방법을 설명합니다. 입문 튜토리얼은 아니지만, 자바스크립트 구문에 대한 기본적인 이해가 있다면 이해할 수 있습니다.

1. 원문 작성

모듈은 특정 기능을 구현하기 위한 메소드의 집합입니다.

다양한 기능(및 상태를 기록하는 변수)을 간단히 모아두면 모듈이 됩니다.

function m1(){
　　//...
}
function m2(){
　　//...
} 

위의 함수 m1()과 m2()는 모듈을 구성합니다. 사용할 때는 직접 전화하면 됩니다.

이 접근 방식의 단점은 분명합니다. 전역 변수를 "오염"시키고, 변수 이름이 다른 모듈과 충돌하지 않는다는 보장이 없으며, 모듈 멤버 간에 직접적인 관계가 없다는 것입니다.

2. 객체 작성

위의 단점을 해결하기 위해 모듈을 객체로 작성할 수 있으며, 모든 모듈 멤버가 이 객체에 배치됩니다.

var module1 = new Object ({
　　_count : 0,
　　m1 : function (){
　　　　//...
　　},
　　m2 : function (){
　　　　//...
　　}
}); 

위의 함수 m1()과 m2()는 모두 module1 객체에 캡슐화되어 있습니다. 사용 시 이 개체의 속성은

module1.m1(); 

이라고 합니다. 그러나 이러한 작성 방법을 사용하면 모든 모듈 멤버가 노출되며 내부 상태를 외부에서 다시 작성할 수 있습니다. 예를 들어 외부 코드는 내부 카운터의 값을 직접 변경할 수 있습니다.

module1._count = 5; 

3. 즉시 호출 함수 작성

Private 멤버의 노출을 피하기 위해 "즉시 호출 함수 표현식, IIFE"를 사용합니다.

var module1 = (function(){
　　var _count = 0;
　　var m1 = function(){
　　　　//...
　　};
　　var m2 = function(){
　　　　//...
　　};
　　return {
　　m1 : m1,
　　m2 : m2
　　};
})(); 

위의 작성 방법을 사용하면 외부 코드에서 내부 _count 변수를 읽을 수 없습니다.

console.info (module1._count); //undefined

　module1은 Javascript 모듈의 기본 작성 방식입니다. 다음으로 이 쓰기 방법을 처리하겠습니다.

4. 증폭 모드

모듈이 매우 커서 여러 부분으로 나누어야 하거나 하나의 모듈이 다른 모듈을 상속해야 하는 경우 "증강 모드"를 사용해야 합니다.

var module1 = (function (mod){
　　mod.m3 = function () {
　　　　//...
　　};
　　return mod;
})(module1); 

위 코드는 module1 모듈에 새로운 메소드 m3()을 추가한 후, 새로운 module1 모듈을 반환합니다.

5. 느슨한 증강 모드(Loose Augmentation)

브라우저 환경에서는 모듈의 각 부분을 인터넷에서 얻는 경우가 많으며 어떤 부분이 로드될지 알 수 없는 경우도 있습니다. 첫 번째. 이전 섹션의 쓰기 방법을 사용하는 경우 처음 실행되는 부분에서 존재하지 않는 빈 개체를 로드할 수 있으며, 이 경우 "확장 모드"를 사용해야 합니다.

var module1 = ( function (mod){
　　//...
　　return mod;
})(window.module1 {}); 

"확대 모드"에 비해 "와이드 확대 모드"는 "즉시 실행 기능"의 매개 변수가 빈 개체일 수 있음을 의미합니다.

6. 전역 변수 입력

모듈의 중요한 특징 중 하나는 모듈 내부에서 프로그램의 다른 부분과 직접 상호 작용하지 않는 것이 가장 좋습니다.

모듈 내부에서 전역 변수를 호출하려면 다른 변수를 모듈에 명시적으로 입력해야 합니다.

var module1 = (function ($， YAHOO) {
　　//...
})(jQuery， YAHOO); 

위 module1 모듈은 jQuery 라이브러리와 YUI 라이브러리를 사용해야 하므로 이 두 라이브러리(실제로는 두 모듈)가 module1에 매개변수로 입력됩니다. 이는 모듈의 독립성을 보장하는 것 외에도 모듈 간의 종속성을 명백하게 만듭니다. 이와 관련된 자세한 내용은 Ben Cherry의 유명한 기사 "JavaScript 모듈 패턴: 심층"을 참조하세요.

7. 모듈 사양

먼저 생각해 보세요. 모듈이 왜 중요한가요?

모듈 덕분에 우리는 다른 사람의 코드를 더 편리하게 사용할 수 있고, 우리가 원하는 기능에 대해 우리가 원하는 모듈을 로드할 수 있습니다.

하지만 여기에는 전제 조건이 있습니다. 즉, 모든 사람이 같은 방식으로 모듈을 작성해야 한다는 것입니다. 그렇지 않으면 당신의 글쓰기 방식이 있고, 나는 나의 글쓰기 방식이 있지 않을까요? 엉망! 아직 Javascript 모듈에 대한 공식 사양이 없다는 점을 고려하면 이는 더욱 중요합니다.

　　目前，通行的 Javascript 模块规范共有两种：CommonJS 和 AMD。我主要介绍 AMD，但是要先从 CommonJS 讲起。

八、CommonJS

　　2009年，美国程序员 Ryan Dahl 创造了 node.js 项目，将 Javascript 语言用于服务器端编程。

　　这标志"Javascript 模块化编程"正式诞生。因为老实说，在浏览器环境下，没有模块也不是特别大的问题，毕竟网页程序的复杂性有限；但是在服务器端，一定要有模块，与操作系统和其他应用程序互动，否则根本没法编程。

　　node.js 的模块系统，就是参照 CommonJS 规范实现的。在 CommonJS 中，有一个全局性方法 require ()，用于加载模块。假定有一个数学模块 math.js，就可以像下面这样加载。

var math = require ('math'); 

　　然后，就可以调用模块提供的方法：

var math = require ('math');
math.add (2,3); // 5 

　　因为这个系列主要针对浏览器编程，不涉及 node.js，所以对 CommonJS 就不多做介绍了。我们在这里只要知道，require () 用于加载模块就行了。

九、浏览器环境

　　有了服务器端模块以后，很自然地，大家就想要客户端模块。而且最好两者能够兼容，一个模块不用修改，在服务器和浏览器都可以运行。

　　但是，由于一个重大的局限，使得 CommonJS 规范不适用于浏览器环境。还是上一节的代码，如果在浏览器中运行，会有一个很大的问题，你能看出来吗？

var math = require ('math');
math.add (2, 3); 

　　第二行 Math.add (2, 3)，在第一行 require ('math') 之后运行，因此必须等 math.js 加载完成。也就是说，如果加载时间很长，整个应用就会停在那里等。

　　这对服务器端不是一个问题，因为所有的模块都存放在本地硬盘，可以同步加载完成，等待时间就是硬盘的读取时间。但是，对于浏览器，这却是一个大问题，因为模块都放在服务器端，等待时间取决于网速的快慢，可能要等很长时间，浏览器处于"假死"状态。

　　因此，浏览器端的模块，不能采用"同步加载"（synchronous），只能采用"异步加载"（asynchronous）。这就是 AMD 规范诞生的背景。

十、AMD

　　AMD 是"Asynchronous Module Definition"的缩写，意思就是"异步模块定义"。它采用异步方式加载模块，模块的加载不影响它后面语句的运行。所有依赖这个模块的语句，都定义在一个回调函数中，等到加载完成之后，这个回调函数才会运行。

　　AMD 也采用 require ()语句加载模块，但是不同于 CommonJS，它要求两个参数：

require ([module], callback); 

　　第一个参数[module]，是一个数组，里面的成员就是要加载的模块；第二个参数 callback，则是加载成功之后的回调函数。如果将前面的代码改写成 AMD 形式，就是下面这样：

require (['math'], function (math) {
    math.add (2, 3);
}); 

　　math.add () 与 math 模块加载不是同步的，浏览器不会发生假死。所以很显然，AMD 比较适合浏览器环境。

　　目前，主要有两个 Javascript 库实现了 AMD 规范：require.js 和 curl.js。本系列的第三部分，将通过介绍 require.js，进一步讲解 AMD 的用法，以及如何将模块化编程投入实战。

　　我采用的是一个非常流行的库 require.js。

一、为什么要用 require.js？

　　最早的时候，所有 Javascript 代码都写在一个文件里面，只要加载这一个文件就够了。后来，代码越来越多，一个文件不够了，必须分成多个文件，依次加载。下面的网页代码，相信很多人都见过。

<script src="1.js"></script>
<script src="2.js"></script>
<script src="3.js"></script>
<script src="4.js"></script>
<script src="5.js"></script>
<script src="6.js"></script>

　　这段代码依次加载多个 js 文件。

　　这样的写法有很大的缺点。首先，加载的时候，浏览器会停止网页渲染，加载文件越多，网页失去响应的时间就会越长；其次，由于 js 文件之间存在依赖关系，因此必须严格保证加载顺序（比如上例的1.js 要在2.js 的前面），依赖性最大的模块一定要放到最后加载，当依赖关系很复杂的时候，代码的编写和维护都会变得困难。

　　require.js 的诞生，就是为了解决这两个问题：

（1）实现 js 文件的异步加载，避免网页失去响应；

（2）管理模块之间的依赖性，便于代码的编写和维护。

二、require.js 的加载

　　使用 require.js 的第一步，是先去官方网站下载最新版本。

　　下载后，假定把它放在 js 子目录下面，就可以加载了。

<script src="js/require.js"></script>

　　有人可能会想到，加载这个文件，也可能造成网页失去响应。解决办法有两个，一个是把它放在网页底部加载，另一个是写成下面这样：

<script src="js/require.js" defer async="true" ></script>

　　async 属性表明这个文件需要异步加载，避免网页失去响应。IE 不支持这个属性，只支持 defer，所以把 defer 也写上。

　　加载 require.js 以后，下一步就要加载我们自己的代码了。假定我们自己的代码文件是 main.js，也放在 js 目录下面。那么，只需要写成下面这样就行了：

<script src="js/require.js" data-main="js/main"></script>

　　data-main 属性的作用是，指定网页程序的主模块。在上例中，就是 js 目录下面的 main.js，这个文件会第一个被 require.js 加载。由于 require.js 默认的文件后缀名是 js，所以可以把 main.js 简写成 main。

三、主模块的写法

　　上一节的 main.js，我把它称为"主模块"，意思是整个网页的入口代码。它有点像C语言的 main ()函数，所有代码都从这儿开始运行。

　　下面就来看，怎么写 main.js。

　　如果我们的代码不依赖任何其他模块，那么可以直接写入 javascript 代码。

// main.js
alert ("加载成功！");

　　但这样的话，就没必要使用 require.js 了。真正常见的情况是，主模块依赖于其他模块，这时就要使用 AMD 规范定义的的 require ()函数。

// main.js
require (['moduleA'， 'moduleB'， 'moduleC'], function (moduleA, moduleB, moduleC){
// some code here
});

　　require () 函数接受两个参数。第一个参数是一个数组，表示所依赖的模块，上例就是['moduleA'， 'moduleB'， 'moduleC']，即主模块依赖这三个模块；第二个参数是一个回调函数，当前面指定的模块都加载成功后，它将被调用。加载的模块会以参数形式传入该函数，从而在回调函数内部就可以使用这些模块。

　　require () 异步加载 moduleA，moduleB 和 moduleC，浏览器不会失去响应；它指定的回调函数，只有前面的模块都加载成功后，才会运行，解决了依赖性的问题。

　　下面，我们看一个实际的例子。

　　假定主模块依赖 jquery、underscore 和 backbone 这三个模块，main.js 就可以这样写：

require (['jquery'， 'underscore'， 'backbone'], function ($， _, Backbone){
// some code here
});

　　require.js 会先加载 jQuery、underscore 和 backbone，然后再运行回调函数。主模块的代码就写在回调函数中。

四、模块的加载

　　上一节最后的示例中，主模块的依赖模块是['jquery'， 'underscore'， 'backbone']。默认情况下，require.js 假定这三个模块与 main.js 在同一个目录，文件名分别为 jquery.js，underscore.js 和 backbone.js，然后自动加载。

　　使用 require.config () 方法，我们可以对模块的加载行为进行自定义。require.config () 就写在主模块（main.js）的头部。参数就是一个对象，这个对象的 paths 属性指定各个模块的加载路径。

require.config ({
    paths: {
        "jquery": "jquery.min.js",
        "underscore": "underscore.min.js",
        "backbone": "backbone.min.js"
    }
});

　　上面的代码给出了三个模块的文件名，路径默认与 main.js 在同一个目录（js 子目录）。如果这些模块在其他目录，比如 js/lib 目录，则有两种写法。一种是逐一指定路径。

require.config ({
    paths: {
        "jquery": "lib/jquery.min.js",
        "underscore": "lib/underscore.min.js",
        "backbone": "lib/backbone.min.js"
    }
}); 

　　另一种则是直接改变基目录（baseUrl）。

require.config ({
    baseUrl: "js/lib",
    paths: {
        "jquery": "jquery.min.js",
        "underscore": "underscore.min.js",
        "backbone": "backbone.min.js"
    }
});

　　如果某个模块在另一台主机上，也可以直接指定它的网址，比如：

require.config ({
    paths: {
        "jquery": "https://ajax.googleapis.com/ajax/libs/jquery/1.7.2/jquery.min"
    }
});

　　require.js 要求，每个模块是一个单独的 js 文件。这样的话，如果加载多个模块，就会发出多次 HTTP 请求，会影响网页的加载速度。因此，require.js 提供了一个优化工具，当模块部署完毕以后，可以用这个工具将多个模块合并在一个文件中，减少 HTTP 请求数。

五、AMD 模块的写法

　　require.js 加载的模块，采用 AMD 规范。也就是说，模块必须按照 AMD 的规定来写。

　　具体来说，就是模块必须采用特定的 define () 函数来定义。如果一个模块不依赖其他模块，那么可以直接定义在 define () 函数之中。

　　假定现在有一个 math.js 文件，它定义了一个 math 模块。那么，math.js 就要这样写：

// math.js
define(function () {
    var add = function (x, y) {
        return x + y;
    };
    return {
        add: add
    };
});

　　加载方法如下：

// main.js
require(['math'], function (math) {
    alert(math.add(1, 1));
});

　　如果这个模块还依赖其他模块，那么 define ()函数的第一个参数，必须是一个数组，指明该模块的依赖性。

define(['myLib'], function (myLib) {
    function foo() {
        myLib.doSomething();
    }
    return {
        foo: foo
    };
});

　　当 require ()函数加载上面这个模块的时候，就会先加载 myLib.js 文件。

六、加载非规范的模块

　　理论上，require.js 加载的模块，必须是按照 AMD 规范、用 define () 函数定义的模块。但是实际上，虽然已经有一部分流行的函数库（比如 jQuery）符合 AMD 规范，更多的库并不符合。那么，require.js 是否能够加载非规范的模块呢？

　　回答是可以的。

　　这样的模块在用 require () 加载之前，要先用 require.config ()方法，定义它们的一些特征。

　　举例来说，underscore 和 backbone 这两个库，都没有采用 AMD 规范编写。如果要加载它们的话，必须先定义它们的特征。

require.config({
    shim: {
        'underscore': {
            exports: '_'
        },
        'backbone': {
            deps: ['underscore', 'jquery'],
            exports: 'Backbone'
        }
    }
});

　　require.config () 接受一个配置对象，这个对象除了有前面说过的 paths 属性之外，还有一个 shim 属性，专门用来配置不兼容的模块。具体来说，每个模块要定义（1）exports 值（输出的变量名），表明这个模块外部调用时的名称；（2）deps 数组，表明该模块的依赖性。

　　比如，jQuery 的插件可以这样定义：

shim: {
    'jquery.scroll': {
        deps: ['jquery'],
        exports: 'jQuery.fn.scroll'
    }
}

七、require.js 插件

　　require.js 还提供一系列插件，实现一些特定的功能。

　　domready 插件，可以让回调函数在页面 DOM 结构加载完成后再运行。

require(['domready!'], function (doc) {
    // called once the DOM is ready
});

　　text 和 image 插件，则是允许 require.js 加载文本和图片文件。

define([
    'text!review.txt',
    'image!cat.jpg'
    ],
    function (review, cat) {
        console.log(review);
        document.body.appendChild(cat);
    }
);

　　类似的插件还有 json 和 mdown，用于加载 json 文件和 markdown 文件。

以上就介绍了javascript模块化编程转载，包括了方面的内容，希望对PHP教程有兴趣的朋友有所帮助。