Javascript Module Pattern – Một cái nhìn khái quát

I – Khái quát chung?

Module pattern (là một design pattern) trong javascript là phương pháp implement source code theo các modules riêng biệt với các ưu điểm như dễ mở rộng, giảm thiểu conflict khi làm việc theo nhóm, quản lý các biến local dễ hơn…

ví dụ cơ bản:

var module = (function(){
     // private variables and functions

     var some_variable

     // constructor

     var module = function(){
             some_variable = "test module pattern";
     }
     // private methods
     // public methods
     var print_out = function(val){

          console.log(some_variable + val);

     }

     // prototype
     module.prototype = {
         constructor: module,
         print_out :print_out
     }

     // return module
     return module;
})();

var new_module = new module();

new_module.print_out('test');

II-  Tại sao nên dùng Module pattern

– Scalable: các module là các phần riêng biệt nên nếu được thiết kế cẩn thận thì nó sẽ hoàn toàn không động chạm đến các module khác, cho nên việc thêm bớt hay xóa bỏ một tính năng, function cho module rất thuận tiện

-Team-work:  khi phát triển một hệ thống js đồ sộ, việc các thành viên 1 team phải edit cùng một source code thật sự là thảm họa. Nếu mỗi người chỉ phải quan tâm đến module do mình phát triển thì việc conflict code sẽ được giảm thiểu đi rất nhiều. Không những thế, việc được làm việc với module riêng của mình đồng nghĩa với việc mình có thể code theo style mà mình thích (đương nhiên vẫn phải theo convention của project) giúp mình có thể code thoải mái hơn.

– Localized: việc không phát triển theo module pattern có thể dẫn đến việc các biến global js được khai báo tràn lan, khó cho việc quản lý và có thể bị conflict với các biến khác. Với module pattern, các biến được khai báo trong module là private, không thể access từ bên ngoài có thể giải quyết được vấn đề này. Ngoài ra, các biến ngoài vẫn có thể truyền vào module thoải mái nên không lo ngại việc không liên kết được với bên ngoài

– Dynamical extension: Khi làm việc theo module pattern, nếu bạn muốn thêm một function chỉ trong một số trường hợp, mà không muốn làm thay đổi cấu trúc của module chính là việc hoàn toàn có thể: với ví dụ module ban đầu, mình có thể mở rộng ra thành 1 module khác như sau:

var new_module = (function (module) {
    module.prototype.other_function = function () {         
        console.log("some thing else");
    };
    return module;
})(module);
var new_one = new new_module();
new_one.other_function();

III – Một số gợi ý cho việc design modules tốt hơn

– Đừng để các module phải phụ thuộc vào nhau. Cần hạn chế việc sử dụng hàm của module này trong module khác, hay trong một plugin nào đó được sử dụng chung bởi các module khác

– Việc liên kết giữa các module nên được thực hiện thông qua các sự kiện chung, không nên gọi trực tiếp từ module này vào module khác. Phương pháp này được gọi là pubsub (public subscribe pattern mọi người có thể tự tìm hiểu thêm)

– Tạo ra những lớp nhỏ để xử lý những công việc như thêm bớt hay liên kết các module

IV – Nhược điểm

– Debug khó khăn hơn: việc các biến là local và tách biệt riêng so với toàn sản phẩm, nên bạn sẽ không thể thoải mái bật f12 lên và gõ vào console như thường lệ nữa. Việc debug sẽ phải thực hiện bằng các công cụ debug do trình duyệt cung cấp hoặc print out trong source code

– Việc mở rộng không hẳn là quá linh động: mặc dù bạn có thể thêm bớt các hàm một cách dễ dàng mỗi lần sử dụng, tuy nhiên bạn sẽ không thể truy cập vào những biến local đã được khai báo từ đầu, mà phải thêm biến mới và xử lý riêng trong đó. Ví dụ:

var new_module = (function (module) {
    module.prototype.other_function = function () {         
        console.log(some_variable);
    };
    return module;
})(module);
var new_one = new new_module();
new_one.other_function();

đoạn code này sẽ không hoạt động vì biến some_variable được khai báo từ trước, và không có khả năng truy cập ở bên ngoài.

– Javascript không còn thoải mái nữa: Javascript vốn là một ngôn ngữ rất thoải mái bạn hoàn toàn có thể làm những việc như:

var oldChild = ManageChildren.addChild;

ManageChildren.addChild = function(){

      /* code them vai function vao */

      oldChild();

}

như đã nói ở trên, module pattern rất khó làm những việc như thế nếu như design ban đầu không tốt.

V – Kết luận

– Module pattern trong javascript có rất nhiều lợi ích nhờ vào tính độc lập và sự riêng biệt. Bạn chỉ nên sử dụng nó khi việc thiết kế toàn bộ sản phẩm và của team bạn đã rõ ràng. Tuy có nhiều ưu điểm nhưng cũng có những nhược điểm thế nên bạn cần cân nhắc về việc có sử dụng nó hay không.