Why jQuery code does not use prototype for methods?

Question

Why jquery code (https://github.com/jquery/jquery/blob/master/src/callbacks.js) does not use prototype for methods?

I am asking this because experts suggest to use prototype for methods for performance reasons( As functions only gets created once).

Code snippet from jquery code,

self = {
            // Add a callback or a collection of callbacks to the list
            add: function() {
                if ( list ) {
                    // First, we save the current length
                    var start = list.length;
                    (function add( args ) {
                        jQuery.each( args, function( _, arg ) {
                            var type = jQuery.type( arg );
                            if ( type === "function" ) {
                                if ( !options.unique || !self.has( arg ) ) {
                                    list.push( arg );
                                }
                            } else if ( arg && arg.length && type !== "string" ) {
                                // Inspect recursively
                                add( arg );
                            }
                        });
                    })( arguments );
                    // Do we need to add the callbacks to the
                    // current firing batch?
                    if ( firing ) {
                        firingLength = list.length;
                    // With memory, if we're not firing then
                    // we should call right away
                    } else if ( memory ) {
                        firingStart = start;
                        fire( memory );
                    }
                }
                return this;
            },
            // Remove a callback from the list
            remove: function() {
                if ( list ) {
                    jQuery.each( arguments, function( _, arg ) {
                        var index;
                        while( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {
                            list.splice( index, 1 );
                            // Handle firing indexes
                            if ( firing ) {
                                if ( index <= firingLength ) {
                                    firingLength--;
                                }
                                if ( index <= firingIndex ) {
                                    firingIndex--;
                                }
                            }
                        }
                    });
                }
                return this;
            },

My question is why all methods are not part of a separate object which becomes prototype for self object?

Answer 1

Using those specific functions here allows the embedding of specific variables (for example list) in the closure while keeping them private.

Using in a standard fashion a prototype based object would have made those properties public.

A thumb rule, when choosing, might be the necessity of the coherency of the variables. When a direct variable change may bring the object to an invalid state, it might seem pertinent to be more protective. Here, for example, reducing the list length might make an index invalid.

Answer 2

When using prototype you have access only to the privileged/public members of the object.

As I see from the code, jQuery does not set any options as public/privileged members to the Callback objects, they use a closure for accessing the options inside the Callback instances. If they initialize the methods in the prototype they wont have access to the options object.

Here an alternative example:

Using prototype

function Callback(opt) {
    var options = opt;
}

Callback.prototype.execute = function () {
   console.log(typeof options);   //undefined
}

Without using prototype

function Callback(opt) {
    var options = opt;
    this.execute = function () {
       console.log(typeof options);   //object
    }
}

I cant be sure about the considerations of jQuery but here are few assumptions:

1. In my opinion they don't want to provide a public access to everything which is used inside by the callback object.

2. The use of new. I haven't seen jQuery to require from the client to use new for initialization an object provided by the API.

The new can be avoided by:

function Callbacks() {
    if (this === window) {
        return new Callbacks();
    }
}

Callbacks.prototype.method = function () {
    //implementation
}

var c = Callbacks(); 

But there are few performance overheads:

• Here is an overhead because of the recursive call return new Callbacks().
• Another one is because of the use of new. In jsperf you can see that usually the object literal is faster then new.

• And the last one is from the traversal of the prototype chain:

  If I use: c.method(); first the JS interpreter will look at the properties of c for invoking method. Of course it won't find it there so it has to look also in c's prototype.