Why is some_func(…) != some_func.call(this, …) in

Question

I always assumed that some_function(...) was exactly the same as some_function.call(this, ...). This seems not to hold true for calls in constructors / an object construction context:

function Class(members, parent) {
    function Ctor(value) {
        members.__init__.call(this, value);
        return this;
    };
    Ctor.prototype = members;
    Ctor.prototype.__proto__ = parent.prototype;
    return Ctor;
}

var Base = Class({
    __init__: function(value) {
        this.value = value;
    }
}, {});

var Child = Class({
    __init__: function(value) {
        // Base(value*2); ← WON'T WORK AS EXPECTED
        Base.call(this, value*2); // works just fine
    }
}, Base);

In Child.__init__ it in necessary to use the explicit call to Base.call(this, value). If I don't use this lengthy expressing, this would name the global object (window in browsers) in the called base constructor. With "use strict" an error would be thrown as there is no global object in strict mode.

Can someone please explain why I have to use Func.call(this, ...) in this example?

(Tested with Node.js v0.6.12 and Opera 12.50.)

Answer 1

Calling a function with .call is different from just invoking it with (). With .call you explicitly set the value of this for the call in the first argument. With normal invocation, the this value will implicitly be the global object or undefined, depending on whether strict mode is enabled or not.

func.call({}, 1); //Call the function func with `this` set to the object and pass 1 as the first argument

func(1); //Call the function func with 1 as the first argument. The value of this inside the function depends on whether strict mode is on or off.

See .call

---

I always assumed that some_function(...) was exactly the same as some_function.call(this, ...). This seems not to hold true for calls in constructors / an object construction context:

That's not true, they are never the same. You are probably confusing it with calling a function as a property of some object. obj.method() will mean that obj is the value of this for the method call and it would be effectively the same as obj.method.call(obj).