Question

I’m writing a small JavaScript framework for fun and possible implementation similar to backbone(hence the tag). I’ve started saving elements as object properties, as shown below. I’m not sure if I’ve seen this done, so I was curious if this causes any issues.

Similarly, If the module depends on other modules I list those at the top of the object in the form of….another object.

I wanted a way to list dependencies ( page elements or JavaScript modules ) and detect any issues up front. This has similar ( not same ) benefits as dependency injection.

This is a specific question on this code review post which explains a bit further on how the framework works.

/*MUserTry
**
**
**         
*/
$A.modelAjax({
    Name:       'MUserTry',
    S:          {
                    DynSma: SDynSma,
                    DynTwe: SDynTwe,
                    DynArc: SDynArc,
                    AniFlipPage: SAniFlipPage,
                    ClientStorage: SClientStorage
                },
    E:          {
                    but: $A('#ut_but')[0]
                },
    J:          {
                    box: $('#ut_box')
                },
    init: function () {
        var pipe = {}, 
            this_hold = this;
        this.J.box.draggable();
        this.E.but.addEventListener("click", function () {
            pipe = $A.definePipe(this_hold.Name);
            $A.ajaxMachine(pipe);
        }, false);
    },
    pre: function (pipe) {
        pipe.page.email = this.e_button.getAttribute('data-email');
        pipe.proceed = true;
    },
    post: function (pipe) {
        this.S.ClientStorage.setAll(pipe.server.smalls);
        this.S.DynSma.run(pipe.server.smalls);
        this.S.DynArc.run(pipe.server.arcmarks);
        this.S.DynTwe.run(pipe.server.tweets);
        this.S.AniFlipPage.run('ma');
    },
    finish: function (pipe) {
        $A.log(pipe);
    }
});

Answer 1

Ok first off let me offer the obligatory “you’ll never get a better wheel by re-inventing the wheel” warning. Whatever you’re trying to accomplish, you’re almost certainly going to be more successful with it if you use an existing library. And even if there is good cause for you to make your own, it would still benefit you immensely to at least look at existing libraries.

But … maybe you’re just having fun with this project, and looking at other projects isn’t fun so you’re not doing it. Fair enough.

In any case, if you do look at Backbone, you’ll find that this practice is core to the Backbone View class. Every View in Backbone has an “el” and “$el” property, which refer to the raw DOM element for the view and the jQuery-wrapped version of that element.

Backbone has no real performance issues with this because variables/properties in JS are just pointers; in other words, when you set the property of an object to an element, you aren’t duplicating that element, you’re just adding a reference to it (to put it another way, it’s more like you’re an A tag rather than a whole new document).

The one time Backbone does have a problem though (and your framework will too) is with stale references. In other words, if you just remove element X from the page, the browser will stop using memory for it (eventually, via garbage collection). But if there is an object out there which points to that element, it won’t get garbage-collected, because anything with a reference isn’t “garbage”.

So, the main thing you have to watch out for is making sure that these objects either:

A) get deleted whenever their elements do, or

B) get rid of their references (eg. delete obj.reference) when their elements get deleted

If you don’t do that, things will still probably work just fine … until you use it on a page with lots of elements being created/deleted, at which point Firefox will start popping up “this script took way too long to run, are you really sure you want to be doing this?” messages.