//обьявления "класса"
function SuperClass(parameter) 
{ 
    this._construct(parameter); 
}
(function()
{
    SuperClass.prototype = 
    {
        property : null,
        staticProperty : new SuperClass("Tram pam pam"),
        _construct : function(parameter)
        {
            this.property = parameter;
        },
        someMethod : function(args)
        {
            //todo
        }
    }
})();

//использование
var sclass = new SuperClass("Xmm");
sclass.property = "Xmm2";
sclass.someMethod();

D>Приходится писать в ASP.NET приложениях много клиентского кода на JScript, видел несколько способов написания обьектного кода на js, но я в js не доктор, знакомых гуру по js нету, вот решил узнать как вообще принято обьектно-ориентировано писать на js

var MyClass = Class(
    //Base class
    BaseClass,
    //Constructor
    function( a, b )
    {
        base.constructor.call( this );
        this.a = a;
        this.b = b;
    },
    //Implementation
    function()
    {

    this.someMethod = function( a )
    {
        // call method from base class;
        return base.someMethod.call( this, a );        
    }
    
    this.callPrivate = function()
    {
        // call private method
        privateMethod.call( this );
    }    
    
    // private method
    var privateMethod = function()
    {
        return this.a + this.b;
    }
    
    }
);

var obj = new MyClass( 1, 2 );

obj.someMethod();
obj.callPrivate(); // вернет 1+2 переданные в конструкторе

// obj.privateMethod(); - даст ошибку

D>"сударь, да вы знаете толк в извращениях!" (с)

D>на самом деле прикольно, было бы любопытно взглянуть на реализацию функции Class

function Class(bc,c,i)
{
    var l=function(){};
    l.prototype=bc.prototype;
    var cc=c;
    cc.base=new l();
    cc.prototype=new l();    
    i.call( cc.prototype );
    cc.prototype.constructor=cc;
    return cc;
}

_JK>function Class(bc,c,i)
_JK>{
_JK>    var l=function(){};
_JK>    l.prototype=bc.prototype;
_JK>    var cc=c;
_JK>    cc.base=new l();
_JK>    cc.prototype=new l();    
_JK>    i.call( cc.prototype );
_JK>    cc.prototype.constructor=cc;
_JK>    return cc;
_JK>}
_JK>

function newClass(parent, prop) {
  // Dynamically create class constructor.
  var clazz = function() {
    // Stupid JS need exactly one "operator new" calling for parent
    // constructor just after class definition.
    if (clazz.preparing) return delete(clazz.preparing);
    // Call custom constructor.
    if (clazz.constr) {
      this.constructor = clazz; // we need it!
      clazz.constr.apply(this, arguments);
    }
  }
  clazz.prototype = {}; // no prototype by default
  if (parent) {
    parent.preparing = true;
    clazz.prototype = new parent;
    clazz.prototype.constructor = parent;
    clazz.constr = parent; // BY DEFAULT - parent constructor
  }
  if (prop) {
    var cname = "constructor";
    for (var k in prop) {
      if (k != cname) clazz.prototype[k] = prop[k];
    }
    if (prop[cname] && prop[cname] != Object)
      clazz.constr = prop[cname];
  }
  return clazz;
}

D>Приходится писать в ASP.NET приложениях много клиентского кода на JScript, видел несколько способов написания обьектного кода на js, но я в js не доктор, знакомых гуру по js нету, вот решил узнать как вообще принято обьектно-ориентировано писать на js

core.js.register_module( "components.webcontrols.client.test_class", function() {

core.js.import_module( "core.js.build_class2" );
core.js.import_module( "core.lists.map" );
var ff = core.js.import_module( "core.lists.find_first" ); // using alias.       

var _class = core.js.build_class2( "components.webcontrols.client.test_class", function()
    {
    this.__base_classes__ = [ components.webcontrols.client.client.base_class ]; // наследование множественное
    this.__constructor__ = function( events )
        {
       
        }
    
    function private_method( param )
        {
                ff( core.lists.map( param, function (x){...} ),  ), function (x){...} );        
        }
    this.methods.some_public_method = function ( param )
        {
        //...                
        }
        
    this.methods.override_sample (param) // перегрузка не требует никаки дополнительных операторов
        {
        base_class$override_sample( param ) // вызов бвзового метода
        }
    
    this.static_methods.some_static = function ( param )
        {
        //....
        }
   });   
   return { test_class:  _class }; 
} );

page_utils.include_module( "components.webcontrols.client.test_class" );

 <script scr="core/js/module.js" />
 <script scr="core/js/build_class2.js" />
 <script scr="core/lists/map.js" />
 <script scr="core/lists/find_first.js" />
 <script scr="components/webcontrols/client/base_class.js" />
 <script scr="components/webcontrols/client/test_class.js" />

    ...
    <script language="JScript">var __file_name__ = "..\\..\\..\\..\\..\\core\\js\\module.js"</script><script language="JScript" src="..\..\..\..\..\core\js\module.js"></script>
    ...

/*
 (C) Copyright MetaCommunications, Inc. 2004. All rights reserved. 
*/

core.js.register_module( "core.lists.map", function(){

function map( list, for_func, if_func )
    {
    var mapped_list = []
    for ( var i = 0; i < list.length; ++i )
        {
        var x = list[i]
        if ( null == if_func || if_func( x ) ) 
            mapped_list.push( for_func( x ) )
        }
    return mapped_list;
    }

function map_object( object, for_func, if_func )
    {
    ...
    }

function map_list( list, for_func, if_func )
    {
    ...
    }

function multi_map( list, key_func )
    {
    ...
    }

return {
          map:        map
        , map_object: map_object
        , map_list:   map_list
        , multi_map:  multi_map
        };
} )

classname$methodname()

D>А так все очень любопытно! жаль для моих целей точно избыточно