Javascript 函数与对象文字符号-是否存在差异？

这两种方法都使用相同的调用机制

显然，我想用最好的方法，但也许这只是一个偏好的问题

就风格而言，我喜欢对象文字符号，因为它提供了外壳

函数表示法：

var TextProcessor = function()
{
};
TextProcessor.unEscape = function( second_split )
{
    var element;
    for( element in second_split )
    {
        second_split[element] = second_split[element].replace( '**', '*', 'g' );
        second_split[element] = second_split[element].replace( '|*', '|', 'g' );
    }
    return second_split;
};
TextProcessor.pullBullet = function( text )
{
    var pattern = /<(.+)_([a-z]){1}>$/;
    return pattern.exec( text );
};
TextProcessor.pullDomain = function( text )
{
    return text.match( /:\/\/(www\.)?(.[^\/:]+)/ )[2];
};

var TextProcessor=function（）
{
};
TextProcessor.unEscape=函数（第二次分割）
{
var元素；
for（第二次分割中的元素）
{
第二次分割[元素]=第二次分割[元素]。替换（'**'，'*'，'g'）；
第二次分割[元素]=第二次分割[元素]。替换（“|*”、“|”、“g”）；
}
返回第二次分割；
};
TextProcessor.pullBullet=函数（文本）
{
var模式=/$/；
返回模式.exec（文本）；
};
TextProcessor.pullDomain=函数（文本）
{
返回text.match（/：\/（www\）？（.[^\/：]+）/）[2]；
};

对象文字符号

/**
 *TextProcessor
 */

var TextProcessor = 
{
    unEscape:    function( text )
    {
        var index;
        for( index in second_split )
        {
            text[index] = text[index].replace( '**', '*', 'g' );
            text[index] = text[index].replace( '|*', '|', 'g' );
        }
        return second_split;
    },
    pullBullet:  function( text )
    {
        var pattern = /<(.+)_([a-z]){1}>$/;
        return pattern.exec( text );
    },
    pullDomain:  function( text )
    {
        return text.match( /:\/\/(www\.)?(.[^\/:]+)/ )[2];
    }
}

/**
*文本处理器
*/
var TextProcessor=
{
unEscape：函数（文本）
{
var指数；
for（第二次分割中的索引）
{
text[index]=text[index]。替换（'**'，'*'，g'）；
text[index]=text[index]。替换（“|*”、“|”、“g”）；
}
返回第二次分割；
},
pullBullet:函数（文本）
{
var模式=/$/；
返回模式.exec（文本）；
},
pullDomain:函数（文本）
{
返回text.match（/：\/（www\）？（.[^\/：]+）/）[2]；
}
}

您正在做两件有些不同的事情

• 第一个示例创建函数对象并为其指定属性

• 第二个示例创建具有这些属性的普通对象

在您的示例中，第一个选项实际上没有多大实际意义。可以使用函数对象指定属性，但为什么要这样做？这些属性对函数的调用没有影响

---

“就风格而言，我喜欢对象文字符号，因为它提供了外壳。”

我不知道什么是“圈地”。这听起来像是封装和闭包的组合，而对象文字既不提供封装也不提供闭包

---

回到第一部分，想象一下如果你创建了这些对象中的任何一个

var TextProcessor = new Number();
var TextProcessor = new Boolean();
var TextProcessor = new Date();

…然后将属性分配给它。这是可行的，但这是一件奇怪的事情。对象是

数字

、

布尔值

或

日期

这一事实与手头的任务没有多大关系

---

当您将属性指定给

函数

对象时，这就是有效的操作。

有关如何使用这些对象的一些附加信息将非常有用。这些对象中是否只创建了一个，循环中是否有多个，等等？您想知道哪种方法最适合创建类吗？或者想解决这个特殊情况？我希望在某个时候有一个好的类（对象）层次结构…我希望有比我更聪明的人也能为此演示显示模块模式。我想我要用这个-第一个可以用来创建具有

新

的对象，第二个是不能的。@Rocket:但是关于添加到函数对象的属性，这对将函数用作构造函数没有影响。如果函数打算用作构造函数来创建具有这些属性的对象，那么属性将需要分配给函数体内部的

this

。我认为“enclosure”并不是指任何技术概念，只是所有代码都“封装”在

{}

而不是一堆单独的语句。可能是错的。我倾向于第一种方式实际上。。。一旦我弄明白如何实现继承，我就可以把正则表达式抽象成一个“hold”这个对象和我的另一个使用正则表达式的对象继承的对象…第一个示例将是这个方向上的中间步骤…因为我还不知道如何实现继承…有点离题了。@Guymantag:请注意，在第一个示例中，您这样做的方式对使用它创建的对象没有影响函数，无论是直接还是通过继承。