“Friend Classes” in javascript

Question

I have a Factory class that creates a Widget object. The Factory object needs to callback a "private method" of the Widget object at a later time to pass it some ajax info. So far, the only implementation I've come up with is to create a public method in the Widget that returns the private method to the factory, and then deletes itself, the Factory then returns the new Widget while retaining a pointer to the private method. Here is a simplified example:

function Factory()
{
    var widgetCallback = null;

    this.ajaxOperation = function()
    {
        //some ajax calls
        widgetCallback('ajaxresults');
    }

    this.getNewWidget = function()
    {
        var wid = new Widget();
        widgetCallback = wid.getCallback();
        return wid;
    }

    function Widget()
    {
        var state = 'no state';
        var self = this;
        var modifyState = function(newState)
        {
            state = newState;
        }

        this.getState = function()
        {
            return state;
        }

        this.getCallback = function()
        {
            delete self.getCallback;
            return modifyState;
        }
    }
}

Is there a better way to achieve the effect I'm after or is this a fairly reasonable approach? I know it works, just curious if I'm stepping into any pitfalls I should be aware of.

Answer 1

this.getNewWidget = function() {
    var val = new Widget(),
        wid = val[0],
        widgetCallback = val[1];

    return wid;
}

function Widget() {
    var state = 'no state';
    var self = this;
    var modifyState = function(newState) {
        state = newState;
    }

    this.getState = function() {
        return state;
    }

    // Return tuple of Widget and callback
    return [this, modifyState];
}

Just get your constructor to return a Tuple<Widget, function>

Alternative just use closure scope to edit widgetCallback directly in your Widget constructor

function Factory() {
    var widgetCallback = null;

    this.ajaxOperation = function() {
        //some ajax calls
        widgetCallback('ajaxresults');
    }

    this.getNewWidget = function() {
        return new Widget();;
    }

    function Widget() {
        var state = 'no state';
        var self = this;
        // set it directly here!
        widgetCallback = function(newState) {
            state = newState;
        }

        this.getState = function() {
            return state;
        }
    }
}

Answer 2

I'm not familiar enough with object oriented JavaScript (I use mostly one-or-two liners inside GWT code) to actually give an Real Answer (But I found that my response were a bit long for a comment...)

I think self-modifying classes, sounds like a major potential for gotcha's.

I personally prefer languages such as JavaScript, Ruby, etc. that are not restrictive in what you can do (even if I have to use Java+GWT at work, hehe), but where you rely self discipline to not do stupid things. I would rather prefix the method name with "_" (and simply avoid using it where I should not), than try to enforce private methods. Since JavaScript by nature is very unrestricted in what crazy things you may do, it requires a lot of discipline anyway.

If you deleted a method after use; to kind-of-protecting it, could you not just as easily add a new method to do the same? You would still rely on your (and others) self discipline and sanity anyway, aren't you?