a method to make js have the ability to inherit

[zzw8206262001]

Hi,I find a way to make javescript more like c++ or pyhon
There is the sample code:

function Father(self) //every contructor may have "self"
argument
{
self=self?self: this; //every class may have this statement

self.hello = function()
{
alert("father"+ self.name);
}
self.name = "baibai";
}

function Child(self) //every contructor may have "self" argument
{
self=self?self: this; //every class may have this statement

//inherit from faher
Father(self);
self.hello = function()
{
alert("child"+s elf.name);
}
}

a = new Father();
a.hello();
b = new Child();
b.hello();

[Richard Cornford]

zz***********@y ahoo.com.cn wrote:

Hi,I find a way to make javescript more like c++ or pyhon
There is the sample code:

function Father(self) //every contructor may have "self" argument
{
self=self?self: this; //every class may have this statement

self.hello = function()
{
alert("father"+ self.name);
}
self.name = "baibai";
}

function Child(self) //every contructor may have "self"
argument {
self=self?self: this; //every class may have this statement

//inherit from faher
Father(self);
self.hello = function()
{
alert("child"+s elf.name);
}
}

a = new Father();
a.hello();
b = new Child();
b.hello();

But have you achieved anything more than can be done with normal
javascript inheritance, using a fraction of the code and with
considerably less added complexity? For example, as:-

function Father(){
}
Father.prototyp e = {
hello:function( ){
alert(this.type +this.name);
};
type:"father";
name:"father"
};
function Child(){
}
Child.prototype = new Father():
Child.prototype .type = 'child';
a = new Father();
a.hello();
b = new Child();
b.hello();

Richard.

[Richard Cornford]

Richard Cornford wrote:
<snip>

function Father(){
}
Father.prototyp e = {
hello:function( ){
alert(this.type +this.name);
};
type:"father";
name:"father"
};

<snip>

The name value pairs in the object literal should be comma separated not
semicolon separated. I.E:-

Father.prototyp e = {
hello:function( ){
alert(this.type +this.name);
},
type:"father",
name:"father"
};

Richard.

[John G Harris]

In article <11************ **********@j44g 2000cwa.googleg roups.com>,
zz***********@y ahoo.com.cn writes

>Hi,I find a way to make javescript more like c++ or pyhon

Why ?

John
--
John Harris

[Jonas Raoni]

Richard Cornford escreveu:

Richard Cornford wrote:
The name value pairs in the object literal should be comma separated not
semicolon separated. I.E:-

On the example there's another small mistake: "new Father():"

Father.prototyp e = {
hello:function( ){
alert(this.type +this.name);
},
type:"father",
name:"father"
};

This looks cute, but it damages the language, because this should work:

var a = new Father, b = new a.constructor;

//#1
alert((a instanceof Father) + "\n" + (b instanceof Father));

So to correct it:

Father.prototyp e = {
hello:function( ){
alert(this.type +this.name);
},
type:"father",
name:"father",
constructor: Father
};

or

new function(){
var o = Father.prototyp e;
o.type = "father";
:
:
};
--
Jonas Raoni Soares Silva
http://www.jsfromhell.com

[Richard Cornford]

Jonas Raoni wrote:

Richard Cornford escreveu:

>Richard Cornford wrote:
The name value pairs in the object literal should be comma
separated not semicolon separated. I.E:-

On the example there's another small mistake: "new Father():"

You will have the explain that as I don't see it.

>Father.prototy pe = {
hello:function( ){
alert(this.type +this.name);
},
type:"father",
name:"father"
};

This looks cute, but it damages the language, because this
should work:

var a = new Father, b = new a.constructor;

Why "should" it work? It will work if no object is assigned to a
constructor's prototype but that is only a feature of the language, it
is not actually useful.

//#1
alert((a instanceof Father) + "\n" + (b instanceof Father));

So to correct it:

Father.prototyp e = {
hello:function( ){
alert(this.type +this.name);
},
type:"father",
name:"father",
constructor: Father
};

Why include an assignment to a - constructor - property if nobody is
going to use it?

new function(){
var o = Father.prototyp e;
o.type = "father";
:
:
};

And I don't see any point in doing that at all.

Richard.

[Jonas Raoni]

Richard Cornford escreveu:

Jonas Raoni wrote:

>On the example there's another small mistake: "new Father():"

You will have the explain that as I don't see it.

":" instead of ";" :)

>This looks cute, but it damages the language, because this
should work:

var a = new Father, b = new a.constructor;

Why "should" it work? It will work if no object is assigned to a
constructor's prototype but that is only a feature of the language, it
is not actually useful.

Don't worry, I just want to be boring... But that's true, till now I
just used the constructor once or twice.

>Father.prototy pe = {
constructor: Father
};

Why include an assignment to a - constructor - property if nobody is
going to use it?

I suppose you've written this way to avoid writing several assignments
to the "Father.prototy pe". But if you can keep the language features
intact, why not?

It's not something dangerous as can be prototyping the Array/Object, but
*I* preffer to keep the features intact.

>new function(){
var o = Father.prototyp e;
o.type = "father";
};

And I don't see any point in doing that at all.

Hmm, it's just a closure with a shortcut variable, something like this:

with({o: a.prototype}){
o.abc = 123;
}

Just other ways to avoid overwriting the constructor.
--
Jonas Raoni Soares Silva
http://www.jsfromhell.com

[Jonas Raoni]

Jonas Raoni escreveu:

Richard Cornford escreveu:

>Jonas Raoni wrote:

Don't worry, I just want to be boring... But that's true, till now I
just used the constructor once or twice.

Just to mention, I remembered one of the places where I used the
constructor:

alert("" instanceof String);
//i could use typeof, but in my case this looked better because "String"
was an argument
alert("".constr uctor == String);
--
Jonas Raoni Soares Silva
http://www.jsfromhell.com

[Richard Cornford]

Jonas Raoni wrote:

Richard Cornford escreveu:

>Jonas Raoni wrote:

>>On the example there's another small mistake: "new Father():"

You will have the explain that as I don't see it.

":" instead of ";" :)

Ah, I see. Thank you. Another typo corrected.

>>This looks cute, but it damages the language, because
this should work:

var a = new Father, b = new a.constructor;

Why "should" it work? It will work if no object is assigned to
a constructor's prototype but that is only a feature of the
language, it is not actually useful.

Don't worry, I just want to be boring... But that's true, till
now I just used the constructor once or twice.

I have never seen a reason for using the -constructor - property of any
object, and where I have seen others use it the resulting code ended up
in a style that I would consider inappropriate to javascript.

>>Father.protot ype = {
constructor: Father
};

Why include an assignment to a - constructor - property
if nobody is going to use it?

I suppose you've written this way to avoid writing several
assignments to the "Father.prototy pe". But if you can keep
the language features intact, why not?

If there is no reason for using the property any effort to "keep it
intact" is futile and wasteful.

It's not something dangerous as can be prototyping the
Array/Object, but *I* preffer to keep the features intact.

I am generally expected to write efficient code, so I don't have ti doe
what is not needed or useful.

>>new function(){
var o = Father.prototyp e;
o.type = "father";
};

And I don't see any point in doing that at all.

Hmm, it's just a closure with a shortcut variable,

There is no closure there. And the result of the expression is an object
that is not an instance of - Father -, does not have - Father.protoype -
on its prototype chain and does not have - Father - as its -
constructor -, so what is the point?

something like
this:

with({o: a.prototype}){
o.abc = 123;
}

Nor there.

Just other ways to avoid overwriting the constructor.

If that was a useful thing to be doing then your earlier methods make
more sense.

Richard.

[Jonas Raoni]

Richard Cornford escreveu:

I have never seen a reason for using the -constructor - property of any
object, and where I have seen others use it the resulting code ended up
in a style that I would consider inappropriate to javascript.

Hmmm, I just remember of using it in a situation similar to this one:

"" instanceof String
"".construc tor == String

I could use typeof (which also looks better, since it's a native type),
but I preferred comparing the constructor with the given argument.

If there is no reason for using the property any effort to "keep it
intact" is futile and wasteful.

I don't think so, I don't like to assume anything as world truth and,
"fixing" it isn't what I can call a hard job :]

>It's not something dangerous as can be prototyping the
Array/Object, but *I* preffer to keep the features intact.

I am generally expected to write efficient code, so I don't have ti doe
what is not needed or useful.

It's ok, everybody has its own point of view.

>>>new function(){
var o = Father.prototyp e;
o.type = "father";
};
And I don't see any point in doing that at all.

Hmm, it's just a closure with a shortcut variable,

There is no closure there. And the result of the expression is an object
that is not an instance of - Father -, does not have - Father.protoype -
on its prototype chain and does not have - Father - as its -
constructor -, so what is the point?

Didn't you perceive the code purpose???

Some people like to do it this way:

var o = Father.prototyp e;
o.type = "father";
o.name = "lala";

Instead of writing:

Father.prototyp e.type = "father";
Father.prototyp e.name = "lala";

So, "o" is just a shortcut for the prototype, what I've done was just to
enclose the variable inside the function to avoid collisions. And used
"new function(){}" instead of "(function(){}) ()".

>something like
this:

with({o: a.prototype}){
o.abc = 123;
}

Nor there.

I won't explain the purpose again, it's the same.

var o = 0;
with({o: 1})
o = 2;
alert(o);

>Just other ways to avoid overwriting the constructor.

If that was a useful thing to be doing then your earlier methods make
more sense.

Ah, there are a lot of ways to do the same thing, fixing the constructor
or not, it's up to you ^^
--
Jonas Raoni Soares Silva
http://www.jsfromhell.com