The MVC in JavaScriptMVC

Unfortunately the images to this post were lost during the migration from Blogengine.Net to WordPress

DISCLAIMER: I recently started using JavaScriptMVC and got to like it a lot. These blogposts are a way for me to document my learning process of the framework. There is the possibility that I misinterpreted certain principles or abusing the framework at some points. So don’t be afraid to ask questions or set things straight in the comments.

In my last post I outed my love for JavaScriptMVC. I got the remark of James that a library that consolidates javascript files doesn’t make it MVC and that is absolutely correct. But JavaScriptMVC is much more then just javascript file consolidation. In this post I would like to show the MVC capabilities of the JavaScript framework and how a typical application built with JavaScriptMVC is structured.

When you download the framework and unzip it to the folder of your choice you get the following file structure:

We will touch some of the folders and files in this structure. The js.bat is a very important one because we will be generating a lot of the files via this command file. As an exercise I will build a fairly simple tabbed interface using JavaScriptMVC. I’ve put the result of this tutorial online. The initial mockup of the application looks like this:

Before we can start writing code, we have to create an application. You can do this by navigating in a command prompt to the folder where you unzipped the JavaScriptMVC bytes and executing the following command:

js jmvc\generate\app tab_manager

The batch command has generated a couple of application files. This batch file will also be used to generate models, controllers, views and much more. Before we go any further let’s digg into how JavaSciptMVC uses the MVC pattern. From their website we get the following explanation for models, views and controllers:


Wrap an application’s data layer, this is done in two ways:

  • Request data from and interacting with services
  • Wrap service data with a domain-specific representation


Event delegation that helps logically organize your event handlers.


Is used as a templating library, it builds html strings from JSON

While using the framework I took the liberty to use parts a little different. Controllers I use as defined for event delegation. But models I don’t use solely for requesting data from a service. I try to make my models as fat as possible and also do things like UI manipulation. Because I use JavaScriptMVC in combination with ASP.NET my usage of the View has been limited. I will be mainly speaking about the Models and Controllers given that my *.aspx (or *.ascx) page is my actual view.

When generating the application, JavaScriptMVC generated an index.html page for us which automatically includes the necessary javascript. We’ll be using that page to create our tab control. I changed the HTML a bit, this is the end result:

	<script language="javascript" type="text/javascript" src="../../jmvc/include.js?tab_manager,development"></script>
	<style type="text/css">
			border:solid 1px #000;


		li.selected a

		p, ul

			border:solid 1px #000;

		<ul id="tab_manager">
			<li class="selected"><a href="#tab-1">Tab 1</a></li>
			<li><a href="#tab-2">Tab 2</a></li>
			<li><a href="#tab-3">Tab 3</a></li>
		<p id="tab-1">Tab 1 selected</p>
		<p id="tab-2" style="display:none;">Tab 2 selected</p>
		<p id="tab-3" style="display:none;">Tab 3 selected</p>

Some basic CSS rules and HTML to represent the tabbed control. I think this code speaks for itself, let’s create the javascript that is needed to make this control work. In order to respond to events that occur we first need a controller that will do the event delegation. So we use the js.bat command batch to generate a controller, this is the command:

js jmvc/generate/controller tab_manager

In our controllers folder we now have a tab_manager_controller.js which we will use to hook into the events that occur on our html page. We can hook into different sort of events and all the important ones are supported. So in order to respond to a click on one of the tabs we add the following method to the controller.

TabManagerController = MVC.Controller.extend('tab_manager',
/* @Static */
/* @Prototype */
   'li click': function(params)
		new Tab().select(params.element);

Let’s reflect over this code. This code defines a TabManagerController class which controls an element that has the id 'tab_manager', the id that our ul-tag has. There is one function in the controller that will respond to a click event on a li-tag. Notice how they use CSS selectors to define the event handlers. No real rocket science here for anyone who already is familiar with JavaScript and CSS selectors. Now we could write all necessary code in the controller, but in order to keep my JavaScript code maintainable I would like to use the controllers as a delegation mechanism to my models. This is somewhat different from what the guys of JavaScriptMVC are recommending to use models for. I try to get my models to reflect the different concepts in my application. So we want to generate a Tab model to show and hide the different tabs. Again we use the batch we are already familiar with to generate the model:

js jmvc/generate/model ajax Tab

This will generate a Tab.js file under the models directory. Now we can add the necessary methods to this class in order to manipulate a certain tab. The nice thing about this is that it resides in its own class which has a name that reflects the actual UI object it will manipulate. You might have noticed the ‘ajax’ parameter we have provided. This is simply because a model has to be generated with a certain data type (json_p, ajax, xml_rest, ...). We will not be using one of the types in our code so this can be ignored for now. This is how the implementation of the Tab model looks like:

Tab = MVC.Model.Ajax.extend('Tab',
/* @Static */
/* @Prototype */
	getTabContentSelector: function($tab)
		return $tab.find('a').attr('href');

	hideTabContent: function(selector)
		$(selector).css('display', 'none');

	showTabContent: function(selector)
		$(selector).css('display', 'block');

	select: function(tabToShow)
		var $currentSelectedTab = $('li.selected');


		var $tabToShow = $(tabToShow);


Notice that I use jQuery in the mix. jQuery and JavaScriptMVC are actually very compatible. You do have to include jQuery as a resource in order to be able to use it, more on that later. There are four functions in the Tab model, the most imporant one is the select function which takes a tab (which is actually an li-element) as argument. The content to show is currently hidden in the page, each tab has a corresponding p-tag which holds the data for that tab, but this could be replaced by an Ajax call in order to request some data for a specific tab.

The last thing I have to mention is the tab_manager.js file in the app folder. That file looks like this:


include(function(){ //runs after prior includes are loaded

This is actually the main file of our application which determines what resources, plugins, models and controllers are loaded. As you can see the jquery file, the tab_manager controller and the Tab model are present in this file. Don’t forget to add new models and controllers to this file, otherwise they will not be loaded and executed.

Because this post is already rather lengthy I will leave it here and give you some room to expirement with the code. I know there are a lot of concepts that are left unexplained but I’m planning on writing a few more posts to go into further detail into certain concepts of the framework. As always if you have any remarks the comments are still open and free.

To finish would like to end with a brief overview of the important files and folders so you have a nice overview of where to find everything we used in this tutorial.

	tab_manager.js                  general application file to load models, controllers and resources
	index.html                      file which holds the necessary html code, used for testing purposes
	tab_manager_controller.js       controller which responds on events coming from the tab manager
	Tab.js                          model which represent a tab
	jquery-1.3.2.min.js             jquery file

Source code of this article

Result of this tutorial