blocks|key|588574|text|是，因为您不能在对象声明中使用此类型的链接|type|unstyled|depth|inlineStyleRanges|entityRanges|data|588575|这里是obj.prototype或obj.something，因为该语言将obj视为非对象的值。你可以像这样伪造这样的效果|588576|Namespace+=+{};

Namespace.obj+=function()+{
++++++++this.foo="bar";
};

Namespace.obj.prototype.start+=+function(tabinst)+{
++++++++this.foo="fubar";
};

console.log(+Namespace.obj.prototype+);|code-block|syntax|javascript|588577|(请参阅此fiddle+http://jsfiddle.net/WewnF/+)|offset|length|588578|编辑:哇，我刚刚注意到我说的话已经在问题中了。我很抱歉没有注意到更早……好吧，你描述自己的方式是实现这一目标的正确方法。|588579|否则，你可以像这样重写你的代码--但这并不是你想要的，也不会以同样的方式工作(因为obj本身不是一个函数，你必须像这样调用它的主函数obj.main()；)|588580|Namespace+=+{
++++obj:+{
++++++++++main+:+function()+{
+++++++++++++++this.foo="bar";
++++++++++},
++++++++++prototype+:+{
+++++++++++++start:+function(tabinst)+{
+++++++++++++this.foo="fubar";
+++++++++++++}
++++++++++}
++++}
}|588581|编辑2:查看此小提琴http://jsfiddle.net/NmA3v/1/|588582|Namespace+=+{
++++obj:+function()+{
++++++++this.foo="bar";
++++},
++++prototype:+{
++++++++obj+:+{
++++++++++++start+:+function(+hi+)+{
+++++++++++++++++alert(+hi+);+
++++++++++++}++
++++++++}

++++},

++++initProto+:+function(){
++++++++for(+var+key+in+Namespace+)
++++++++{
++++++++++++if(+key+!==+"prototype"+)
++++++++++++{
++++++++++++++++for(+var+jey+in+Namespace.prototype[+key+]+)
++++++++++++++++++++Namespace[+key+].prototype[+jey+]+=++Namespace.prototype[+key+][+jey+];++
++++++++++++}
++++++++}
++++}
}

Namespace.initProto();

console.log(+Namespace.obj);

var+test++=+new+Namespace.obj();

test.start(+"Hello+World"+);|588583|这将具有完全相同的效果。解释:我们将我们的对象声明为普通的属性-函数，然后使用一个主原型对象，该对象包含与上面相同的名称的对象，例如，对于每个Namespace.obj，还有一个包含我们想要添加到原型链中的函数的Namespace.prototype.obj。|588584|然后使用namespace.protoInit()遍历所有属性-并从Namespace.prototype键提取函数并将它们添加到Namespace键.prototype+-成功地扩展了原型对象！有点不正统，但很管用！|588585|entityMap|0|LINK|mutability|MUTABLE|url|http://jsfiddle.net/WewnF/|1|http://jsfiddle.net/NmA3v/1/^0|0|0|0|C|Q|0|0|0|0|0|A|S|1|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1A|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1B|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|1C|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|1D|8|@]|9|@$K|1E|L|1F|1|1G]]|A|$]]|$1|M|3|N|5|6|7|1H|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|1I|8|@]|9|@]|A|$]]|$1|Q|3|R|5|F|7|1J|8|@]|9|@]|A|$G|H]]|$1|S|3|T|5|6|7|1K|8|@]|9|@$K|1L|L|1M|1|1N]]|A|$]]|$1|U|3|V|5|F|7|1O|8|@]|9|@]|A|$G|H]]|$1|W|3|X|5|6|7|1P|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|10|3|-4|5|6|7|1R|8|@]|9|@]|A|$]]]|11|$12|$5|13|14|15|A|$16|17]]|18|$5|13|14|15|A|$16|19]]]]

Yes because, you cannot use this type of chaining in an object declaration

obj.prototype or obj.something here, because the language sees obj as a non-object value. You can fake such an effect like this

<pre><code>Namespace = {};

Namespace.obj =function() {
 this.foo="bar";
};

Namespace.obj.prototype.start = function(tabinst) {
 this.foo="fubar";
};

console.log( Namespace.obj.prototype );
</code></pre>

(see this fiddle <a href="http://jsfiddle.net/WewnF/" rel="nofollow">http://jsfiddle.net/WewnF/</a> )

EDIT: Wow, I just noticed that what I said was already within the question. I 'm so sorry did not notice that sooner... Well the way you described yourself is the correct method of achieving this.

Otherwise you can re-write your code like this - but is not exactly what you 're after and won't work the same (since obj won't be a function itself and you will have to call its main function like this obj.main(); )

<pre><code>Namespace = {
 obj: {
 main : function() {
 this.foo="bar";
 },
 prototype : {
 start: function(tabinst) {
 this.foo="fubar";
 }
 }
 }
}
</code></pre>

EDIT 2: See this fiddle <a href="http://jsfiddle.net/NmA3v/1/" rel="nofollow">http://jsfiddle.net/NmA3v/1/</a>

<pre><code>Namespace = {
 obj: function() {
 this.foo="bar";
 },
 prototype: {
 obj : {
 start : function( hi ) {
 alert( hi ); 
 } 
 }

 },

 initProto : function(){
 for( var key in Namespace )
 {
 if( key !== "prototype" )
 {
 for( var jey in Namespace.prototype[ key ] )
 Namespace[ key ].prototype[ jey ] = Namespace.prototype[ key ][ jey ]; 
 }
 }
 }
}

Namespace.initProto();

console.log( Namespace.obj);

var test = new Namespace.obj();

test.start( "Hello World" );
</code></pre>

This will have the exact same effect.
Explanation : we are declaring our objects as normal properties-functions, and then use a master prototype object which containers objects with the same names as above, for example for each Namespace.obj, there is also a Namespace.prototype.obj which contains the functions we want to add in the prototype chain.

then with namespace.protoInit(), we iterate through all properties - and extract the functions from the Namespace.prototype[ key ] and add them to Namespace[ key ].prototype - succesfully extending the prototype object! A bit unorthodox, but works!

blocks|key|804459|text|我要做的就是使用"Module+pattern"。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|804460|你基本上将所有的“模块”逻辑封装在一个自动执行的函数中，该函数将返回一个包含你的类、函数、变量等的对象……将返回值视为公开模块API。|804461|Namespace+=+(function+()+{
++++/**+Class+obj+**/
++++var+obj+=+function+()+{
++++++++this.foo+=+'bar';
++++};
++++obj.prototype+=+{
++++++++start:+function+()+{
++++++++++++this.foo+=+'fubar';
++++++++}
++++};

++++/**+Class+obj2+**/++
++++var+obj2+=+function+()+{
++++++++this.bar+=+'foo'
++++};
++++obj2.prototype+=+{
++++++++start:+function+()+{
++++++++++++this.bar+=+'barfoo';
++++++++},
++++++++end:+function+()+{
++++++++++++this.bar+=+'';
++++++++}
++++};
++++return+{
++++++++obj+:+obj,
++++++++obj2:+obj2
++++};
})();

var+o+=+new+Namespace.obj()
o.start()|code-block|syntax|javascript|804462|为了进一步封装"obj“类方法和构造函数，我们可以执行以下操作：|804463|/**+Class+obj+**/
var+obj+=+(function+()+{
++++/**+class+Constructor+**/
++++var+obj+=+function+()+{
++++++++this.foo+=+'bar';
++++};
++++/**+class+methods+**/
++++obj.prototype+=+{
++++++++start:+function+()+{
++++++++++++this.foo+=+'fubar';
++++++++}
++++};
++++return+obj;
})();|804464|使用此模式还有一个免费的重要特性，即“私有变量”，请考虑以下几点：|804465|/**+Class+Foo+**/
var+Foo+=+(function+()+{
++++//+Private+variables
++++var+private_number+=+200
++++/**+class+Constructor+**/
++++var+Foo+=+function+()+{
++++++++this.bar+=+0;
++++};
++++/**+class+methods+**/
++++Foo.prototype+=+{
++++++++add:+function+()+{
++++++++++++this.bar+%2B=+private_number;
++++++++}
++++};
++++return+Foo;
})();

foo+=+new+Foo();
alert(foo.bar);+//+0
foo.add();+
alert(foo.bar);//+200
alert(foo.private_number)+//undefined|804466|entityMap|0|LINK|mutability|MUTABLE|url|http://www.yuiblog.com/blog/2007/06/12/module-pattern/^0|8|G|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@$A|11|B|12|1|13]]|C|$]]|$1|D|3|E|5|6|7|14|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|15|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|16|8|@]|9|@]|C|$]]|$1|M|3|N|5|H|7|17|8|@]|9|@]|C|$I|J]]|$1|O|3|P|5|6|7|18|8|@]|9|@]|C|$]]|$1|Q|3|R|5|H|7|19|8|@]|9|@]|C|$I|J]]|$1|S|3|-4|5|6|7|1A|8|@]|9|@]|C|$]]]|T|$U|$5|V|W|X|C|$Y|Z]]]]

The way I would do it is using the <a href="http://www.yuiblog.com/blog/2007/06/12/module-pattern/" rel="noreferrer">"Module pattern"</a>. 
You basically encapsulate all your "Module" logic in a self executing function that would return an object having your classes, functions, variables etc... Think of the return value as exposing your Module API. 

<pre><code>Namespace = (function () {
 /** Class obj **/
 var obj = function () {
 this.foo = 'bar';
 };
 obj.prototype = {
 start: function () {
 this.foo = 'fubar';
 }
 };

 /** Class obj2 **/ 
 var obj2 = function () {
 this.bar = 'foo'
 };
 obj2.prototype = {
 start: function () {
 this.bar = 'barfoo';
 },
 end: function () {
 this.bar = '';
 }
 };
 return {
 obj : obj,
 obj2: obj2
 };
})();

var o = new Namespace.obj()
o.start()
</code></pre>

In order to further encapsulate the "obj" class methods and constructor we could do the following:

<pre><code>/** Class obj **/
var obj = (function () {
 /** class Constructor **/
 var obj = function () {
 this.foo = 'bar';
 };
 /** class methods **/
 obj.prototype = {
 start: function () {
 this.foo = 'fubar';
 }
 };
 return obj;
})();
</code></pre>

There is also an important feature that comes for free using this pattern, which is "Private variables", consider the following:

<pre><code>/** Class Foo **/
var Foo = (function () {
 // Private variables
 var private_number = 200
 /** class Constructor **/
 var Foo = function () {
 this.bar = 0;
 };
 /** class methods **/
 Foo.prototype = {
 add: function () {
 this.bar += private_number;
 }
 };
 return Foo;
})();

foo = new Foo();
alert(foo.bar); // 0
foo.add(); 
alert(foo.bar);// 200
alert(foo.private_number) //undefined
</code></pre>

blocks|key|588773|text|只是为了好玩，并在上面的答案上进行扩展。基于嵌套命名空间的更多面向对象的表示法|type|unstyled|depth|inlineStyleRanges|entityRanges|data|588774|var+NS+=+{};

//+Class+List
NS.Classes+=+{
++Shape:+(function(){
++++//+Private
++++var+whateveryouwishboss+=+false;

++++//+Public
++++var+Shape+=+function(x,y,w,h){
++++++this.x+=+x;
++++++this.y+=+y;
++++++this.w+=+w;
++++++this.h+=+h;
++++};
++++Shape.prototype+=+{
++++++draw:+function(){
++++++++//...+Im+on+prototype+Shape+
++++++}
++++}
++++return+Shape;
++})(),
++Person:+(function(){
++++//....
++})()
}

///////+Let+the+games+begin

var+rect+=+new+NS.Class.Shape(0,0,10,10);
rect.draw()|code-block|syntax|javascript|588775|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Just for kicks and to expand on the answer above. A bit more object notation oriented based on nested namespace

<pre><code>var NS = {};

// Class List
NS.Classes = {
 Shape: (function(){
 // Private
 var whateveryouwishboss = false;

 // Public
 var Shape = function(x,y,w,h){
 this.x = x;
 this.y = y;
 this.w = w;
 this.h = h;
 };
 Shape.prototype = {
 draw: function(){
 //... Im on prototype Shape 
 }
 }
 return Shape;
 })(),
 Person: (function(){
 //....
 })()
}

/////// Let the games begin

var rect = new NS.Class.Shape(0,0,10,10);
rect.draw()
</code></pre>

I know, this is often discussed. But after searching around like someone out of the 19th century, I need some advice. I have no problem by declaring a "namespace", but when it comes to a prototype.foo function, I stuck. I found a way, but I don't like it:

<pre><code>Namespace = {}
Namespace.obj = function() {
 this.foo="bar";
}
Namespace.obj.prototype.start = function() {
 this.foo="fubar";
}

blah = new Namespace.obj();
blah.start();
</code></pre>

Now, since I'm a little neurotic in case of scripting, I would like to have something like this:

<pre><code>Namespace = {
 obj: function() {
 this.foo="bar";
 },
 obj.prototype.start: function(tabinst) {
 this.foo="fubar";
 }
}
...
</code></pre>

But then it throws an error:
 "Uncaught SyntaxError: Unexpected token ."

I know, this is cosmetic, but I think that there has to be a better method of declaring a "namespace" containing a class and prototype functions.

Javascript namespace declaration with function-prototype

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我知道，这是经常讨论的。但在像19世纪的人一样四处寻找之后，我需要一些建议。我可以声明一个“名称空间”，但是当涉及到prototype.foo函数时，我就坚持了下来。我找到了一种方法，但我不喜欢：Namespace = {}Namespace.obj = function() {    this.foo="bar";}...

问使用function-prototype声明Javascript命名空间
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问使用function-prototype声明Javascript命名空间EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问使用function-prototype声明Javascript命名空间
EN