Comments on: On modifying prototypes of JavaScript built-ins

By: Daniel Phillimore

Daniel Phillimore — Sun, 19 Nov 2006 00:15:33 +0000

In response to that last post, all I do to skip extended members is as follows (untested, conceptual):

Array.prototype.extender = window.alert; //random reference
var arrArray = [”foo”, “bar”, “chicken”];
for (var anyIndex in arrArray)
{
//skip extension
if (anyIndex != “extender”) continue;

//…

//do_something…
}

By: Thomas Frank

Thomas Frank — Fri, 16 Jun 2006 02:57:08 +0000

Sorry didn’t get my pre tags right ;-):

//let's extend another prototype String.prototype.proto=function(obj){ var proto=obj.sort?Array.prototype:Object.prototype; return proto[this] && proto[this]==obj[this] };


// and extend some more prototypes

Object.prototype.you=1;

Array.prototype._dont=1;

Object.prototype.like=1;

Array.prototype._this=1;
// and create a new array

var x=[1,1,1];

x.you=2;

// now it is really easy to iterate through non-prototype members // this will return 0,1,2,you props=[]; for(var i in x){ if(!i.proto(x)){ props.push(i) } }; alert(props.join("\n"))

By: Thomas Frank

Thomas Frank — Fri, 16 Jun 2006 02:54:56 +0000

I really disagree too. Prototypes are an important part of JavaScript. It’s not the programmer who extends them that is sloppy - it’s the programmer who won’t check if they’re extended. It is really easy to check this:

//let’s extend another prototype
String.prototype.proto=function(obj){
var proto=obj.sort?Array.prototype:Object.prototype;
return proto[this] && proto[this]==obj[this]
};

// and extend some more prototypes
Object.prototype.you=1;
Array.prototype._dont=1;
Object.prototype.like=1;
Array.prototype._this=1;

// and create a new array
var x=[1,1,1];
x.you=2;

// now it is really easy to iterate through non-prototype members
// this will return 0,1,2,you
props=[];
for(var i in x){
if(!i.proto(x)){
props.push(i)
}
};
alert(props.join(”\n”))

By: Mike

Mike — Mon, 12 Jun 2006 14:50:55 +0000

You wrote:
“using a normal for(i=0,l=a.length;0>l;i++) loop”

Shouldn’t this be
for(i=0,l=a.length;l>i;i++)

By: Dean Edwards

Dean Edwards — Fri, 09 Jun 2006 11:04:23 +0000

I really disagree with this post. It is arguments like this that hold back JS development. None of the reasons you come up with have convinced me that extending the Array object is a bad idea.

In one of your code samples you use the example of Array.push. IE5.0 does not support this. How do we get our code to work with IE5.0? We extend the Array object of course.

By: Andrew Dupont

Andrew Dupont — Thu, 08 Jun 2006 20:57:54 +0000

Liorean, this is a good post, and I wish I had happened upon it sooner. I started to post a comment, but it turned into a theological tract, so I’ll just link it here. Cheers.

By: Hermann Klinke

Hermann Klinke — Wed, 31 May 2006 20:18:44 +0000

I see your point. Thanks for the clarification!

By: liorean

liorean — Tue, 30 May 2006 21:36:04 +0000

Hermann: Yes, you can. But you’re repeating the error I talked about with regard to the Array prototype, but in larger scale - by extending Object.prototype you are forcing everybody else to do that runtime checking for every object whose members they want to iterate through. You’re breaking all code that didn’t do that checking because they knew that all built-in members are marked {DontEnum}. Breaking language built-ins is bad, because you’re breaking code that normally would work perfectly fine. Any solution to the problem that would demand changing other code is unacceptable.

By: Hermann Klinke

Hermann Klinke — Tue, 30 May 2006 21:06:22 +0000

I do not understand you problem with extending Object.prototype. You can still iterate over its members as you did before by ignoring the members of Object.prototype.

for (member in object)
{
if (Object.prototype[member] === undefined)
{
//do your thing
}
}

By: liorean

liorean — Thu, 25 May 2006 21:43:07 +0000

Erik: It should only appear in an enumeration if it was overridden — which is the case that bug is about. But I'm talking about the case where it's not overridden - in that case, it will not be enumerated, because ECMA-262 3ed. specifies that it's {DontEnum}. So, there's no way of autodiscovering it in code. The problem is one of getting the property from the prototype when you in fact only wanted properties from the actual object. And for that, you only need to check whether it exists on the object at hand or not, which can be done using arr.hasOwnProperty(key).

As for sparse arrays not being enough of a concern to avoid extending Array.prototype — maybe you're right about that. It's not a common use of arrays. I'm still of the opinion that libraries should try not to destroy native language functionality though.

It's not as if arrays and iterating over them is homogenously implemented anyways. Try this in moz, iew and op:

var
    a=[,,,,,,,,],
    b=[],
    i;
a[4]='first';
a[0]='second';
a[2]='third';
for(i in a)
   b.push(i+':'+a[i]);
p.push('length:'+a.length);
b.join();

Moz and iew have their bugs with sparse array literals. Op has a different — but entirely correct accoring to the spec — implementation of the iteration through array members. Or rather of how those members are stored, but it amounts to a difference in the iteration.