5

我将我的代码组织成 20-60 行模块,通常采用模块模式。我想要一个结构良好的面向对象的 JavaScript 库。

这是最好的方法吗?该代码已经过测试并且可以工作。

我喜欢它,因为程序员可以从库中提取模块并根据需要使用它们,它们是自包含的。

这是工具、消息、效果和文本,都包含在 NS 中。

问题?

这是组织我的图书馆的好方法(最佳实践)吗?

笔记

到目前为止,评论和答案中的共识为 0……非常令人沮丧。

外部模块模式

var NS = ( function ( window, undefined ) 
{ 
/* All Modules below here */ 
} )( window );

工具

/**
 *Tools
 *    getTimeLapse - benchmark for adding
 */

var Tool = ( function () 
{
    var Tool = function ( ) 
    {
    };
    Tool.prototype.getTimeLapse = function( numberOfAdds ) 
    {
        var end_time;
        var start_time = new Date().getTime();
        var index = 0;           
        while ( index <= numberOfAdds )
        {
            index++;
        }
        end_time = new Date().getTime();
        return ( end_time - start_time );
    };
    return Tool;
} () );

信息

/**
 *Message
 *    element - holds the element to send the message to via .innerHTML
 *    type - determines the message to send
 */

var Message = ( function () 
{
    var messages = 
    {
        name:         'Please enter a valid name',
        email:        'Please enter a valid email',
        email_s:      'Please enter a valid email.',
        pass:         'Please enter passoword, 6-40 characters',
        url:          'Please enter a valid url',
        title:        'Please enter a valid title',
        tweet:        'Please enter a valid tweet',
        empty:        'Please complete all fields',
        same:         'Please make emails equal',
        taken:        'Sorry, that email is taken',
        validate:     'Please contact <a class="d" href="mailto:foo@foo.com">support</a> to reset your password',
    };
    var Message = function (element) 
    {
        this.element = element;
    };
    Message.prototype.display = function( type ) 
    {
        this.element.innerHTML = messages[ type ];
    };
    return Message;
} () );

效果

/**
 *Effects
 *    element - holds the element to fade
 *    direction - determines which way to fade the element
 *    max_time - length of the fade
 */

var Effects = ( function () 
{
    var Effects = function ( element )
    {
        this.element = element;
    };
    Effects.prototype.fade = function( direction, max_time ) 
    {
        var element = this.element;
        element.elapsed = 0;
        clearTimeout( element.timeout_id );
        function next()
        {
            element.elapsed += 10;
            if ( direction === 'up' )
            {
                element.style.opacity = element.elapsed / max_time;
            }
            else if ( direction === 'down' )
            {
                element.style.opacity = ( max_time - element.elapsed ) / max_time;
            }
            if ( element.elapsed <= max_time ) 
            {
                element.timeout_id = setTimeout( next, 10 );
            }
        }
        next();
    };
    return Effects;
} () );

文本

/**
 *Text
 *    form_elment - holds text to check
 */

var Text = ( function () 
{
    var Text = function ( form_element )
    {
        this.text_array = form_element.elements;
    };
    Text.prototype.patterns = 
    {
        prefix_url:     /^(http:)|(https:)\/\//,
        aml:            /<(.+)_([a-z]){1}>$/,
        url:            /^.{1,2048}$/,
        tweet:          /^.{1,40}$/, 
        title:          /^.{1,32}$/,
        name:           /^.{1,64}$/, 
        email:          /^.{1,64}@.{1,255}$/,
        pass:           /^.{6,20}$/
    };
    Text.prototype.checkPattern = function( type ) 
    {
        return this.patterns[ type ].exec( this.text_array[type].value );
    };
    Text.prototype.checkUrl = function( type ) 
    {
        return this.patterns[ type ].exec( this.text_array.url.value );
    };
    Text.prototype.checkSameEmail = function() 
    {
        return ( ( this.text_array.email.value ) === ( this.text_array.email1.value ) );
    };
    Text.prototype.checkEmpty = function() 
    {
        for ( var index = 0; index < this.text_array.length; ++index ) 
        {
            if ( this.text_array[ index ].value === '') 
            { 
                return 0; 
            }
        }
        return 1;
    };
    return Text;
} () );
4

3 回答 3

2

我建议更改以使您的代码更清洁并减少其占用空间的一件事是立即设置原型属性,而不是这样做

Object.prototype.method1 = function(){};
Object.prototype.method2 = function(){};

你做

Object.prototype = {
    method1: function(){},
    method2: function(){}
};

如果您需要保存推荐的构造函数引用,则应在之后重新分配构造函数。有关更多详细信息,请参阅此答案

于 2012-04-12T19:28:06.387 回答
1

我个人更喜欢使用像ncore这样的模块化代码组织库

这鼓励您将代码编写为一组模块(每个文件一个模块),然后使用依赖注入和引导将它们连接在一起。

该代码具有轻微的可移植性,因为模块本身就是对象,但是如果不使用 ncore,就会失去优势。

排行榜应用展示了OO代码组织的详细示例

于 2012-04-12T19:23:51.157 回答
1

一些建议...首先是创建一个命名空间对象作为库的范围... jQuery 使用“jQuery”和“$”,下划线使用“_”。我倾向于使用“CompanyName.SiteName”

if (typeof CompanyName == "undefined") var CompanyName = {};
CompanyName.SiteName = CompanyName.SiteName || {};

第一行明确地检查未定义,因为您会在许多浏览器中得到错误,否则使用 SiteName 属性上的方法查找根变量。

从那里,我会做一些调整......当你内联调用匿名函数时,最好将整个调用包装在括号内。

CompanyName.SiteName.ModuleName = (function(w){
    ...
    return moduleImplementation;
}(window || this)); //CompanyName.SiteName.ModuleName

这倾向于通过让括号包裹整个内容并在模块声明的末尾添加注释来避免混淆。

根据上面的评论,您可能希望将原型声明作为更单一的声明。我建议不要这样做,因为更长的模块会使可读性成为问题。

myModule.prototype = {
    "method1": function(){
    }
    ...
    "methodN": function(){
       //by the time you get here, you may not see the top, and where you are nested in
    }
};

//with the dot-notation, or hash notation
myModule.prototype.methodN = ...
myModule.prototype["methodN"] = ...
//you can see where you are binding to at that function

您可能还想研究RequireJSAMD

还有处理更简单对象和使用功能绑定器的概念。将您的库视为一组函数(类似于 C 导出),它们被传递并使用更简单的对象/类型。这实际上取决于您的需求/使用以及您的需求和使用的具体情况。

您可能还想查看一些示例,例如KnockoutJSUnderscoreBackbone等 javascript 库。

于 2012-04-12T19:48:33.733 回答