如何将原型函数映射到具有该原型的对象数组？

Question

Is there a way in javascript to get a handle on a object prototype function with the this guaranteed to be the object in question? I particularly got to a PITA situation when I wanted to map an array of objects of the proper type to such a function. This ended up being Window. Yes I did pull the function itself from the proper place but internally it refers to 'this'. I know about call and apply but not how you might use them to handle this sort of situation.

Is there a way short of an explicit loop instead of using map? Oddly it apparently does not do the same thing re 'this' as

object_with_the_prototype.some_prototype_function() 

would do if instead I have

[object_with_the_prototype].map(this.some_prototype_function)

How come?

Answer 1

if your method expects one argument, then it's easy. If you need more than one argument, or more importantly, not a number as a 2nd argument (think .toString), then you can use bind to curry this into the 1st argument:

"a,b,c".split(",").map( Function.call.bind(  "".big  )  );

in your code:

[object_with_the_prototype]
  .map( Function.call.bind( thisObject.some_prototype_function ) );

if your method calls like x(a,b,c), the bound function calls like x(this, a, b, c)

Answer 2

I think you are looking for this:

[object_with_the_prototype].map(function(thisObject) {
    thisObject.some_prototype_function();
} );

Answer 3

Ah, I see it. The problem is that in the array case I was mistakenly assuming that the normal walk from the object up its prototype chain would happen although I was giving it an explicit function to map to. I fixed it by defining a function taking an element from the array and calling the desired prototype function through that element. I map to that function instead.

function do_one(element) {element.some_prototype_function()}
[object_with_prototype].map(do_one)