The jQuery library has a passionate community of developers,
and it is now
the most widely used JavaScript library on
the web today. Two years ago I announced that Microsoft would begin offering product support for jQuery,
and that we’d be including it in new versions of Visual Studio going forward. By default, when you create new ASP.NET Web Forms
and ASP.NET MVC projects with VS 2010 you’ll find jQuery automatically added to your project. A few weeks ago during my second keynote at
the MIX 2010 conference I announced that Microsoft would also begin contributing to
the jQuery project. During
the talk, John Resig --
the creator of
the jQuery library
and leader of
the jQuery developer
team – talked a little about our participation
and discussed an early prototype of a new client templating API for jQuery. In this blog post, I’m going to talk a little about how my
team is starting to contribute to
the jQuery project,
and discuss some of
the specific features that we are working on such as client-side templating
and data linking (data-binding). Contributing to jQuery jQuery has a fantastic developer community,
and a very open way to propose suggestions
and make contributions. Microsoft is following
the same process to contribute to jQuery as any other member of
the community. As an example, when working with
the jQuery community to improve support for templating to jQuery my
team followed
the following steps: We created a proposal for templating
and posted
the proposal to
the jQuery developer forum (http://forum.jquery.com/topic/jquery-templates-proposal
and http://forum.jquery.com/topic/templating-syntax ). After receiving feedback on
the forums,
the jQuery
team created a prototype for templating
and posted
the prototype at
the Github code repository (http://github.com/jquery/jquery-tmpl ). We iterated on
the prototype, creating a new fork on Github of
the templating prototype, to suggest design improvements. Several other members of
the community also provided design feedback by forking
the templating code. There has been an amazing amount of participation by
the jQuery community in response to
the original templating proposal (over 100 posts in
the jQuery forum),
and the design of
the templating proposal has evolved significantly based on community feedback.
The jQuery
team is
the ultimate determiner on what happens with
the templating proposal – they might include it in jQuery core, or make it an official plugin, or reject it entirely. My
team is excited to be able to participate in
the open source process,
and make suggestions
and contributions
the same way as any other member of
the community. jQuery Template Support Client-side templates enable jQuery developers to easily generate
and render HTML UI on
the client. Templates support a simple syntax that enables either developers or designers to declaratively specify
the HTML they want to generate. Developers can then programmatically invoke
the templates on
the client,
and pass JavaScript objects to them to make
the content rendered completely data driven. These JavaScript objects can optionally be based on data retrieved from a server. Because
the jQuery templating proposal is still evolving in response to community feedback,
the final version might look very different than
the version below. This blog post gives you a sense of how you can try out
and use templating as it exists today (you can download
the prototype by
the jQuery core
team at http://github.com/jquery/jquery-tmpl or
the latest submission from my
team at http://github.com/nje/jquery-tmpl). jQuery Client Templates You create client-side jQuery templates by embedding content within a <script type="text/html"> tag. For example,
the HTML below contains a <div> template container, as well as a client-side jQuery “contactTemplate” template (within
the <script type="text/html"> element) that can be used to dynamically display a list of contacts:
The {{= name }}
and {{= phone }} expressions are used within
the contact template above to display
the names
and phone numbers of “contact” objects passed to
the template. We can use
the template to display either an array of JavaScript objects or a single object.
The JavaScript code below demonstrates how you can render a JavaScript array of “contact” object using
the above template.
The render() method renders
the data into a string
and appends
the string to
the “contactContainer” DIV element: When
the page is loaded,
the list of contacts is rendered by
the template. All of this template rendering is happening on
the client-side within
the browser: Templating Commands
and Conditional Display Logic
The current templating proposal supports a small set of template commands - including if, else,
and each statements.
The number of template commands was deliberately kept small to encourage people to place more complicated logic outside of their templates. Even this small set of template commands is very useful though. Imagine, for example, that each contact can have zero or more phone numbers.
The contacts could be represented by
the JavaScript array below:
The template below demonstrates how you can use
the if
and each template commands to conditionally display
and loop
the phone numbers for each contact: If a contact has one or more phone numbers then each of
the phone numbers is displayed by iterating through
the phone numbers with
the each template command:
The jQuery
team designed
the template commands so that they are extensible. If you have a need for a new template command then you can easily add new template commands to
the default set of commands. Support for Client Data-Linking
The ASP.NET
team recently submitted another proposal
and prototype to
the jQuery forums (http://forum.jquery.com/topic/proposal-for-adding-data-linking-to-jquery). This proposal describes a new feature named data linking. Data Linking enables you to link a property of one object to a property of another object - so that when one property changes
the other property changes. Data linking enables you to easily keep your UI
and data objects synchronized within a page. If you are familiar with
the concept of data-binding then you will be familiar with data linking (in
the proposal, we call
the feature data linking because jQuery already includes a bind() method that has nothing to do with data-binding). Imagine, for example, that you have a page with
the following HTML <input> elements:
The following JavaScript code links
the two INPUT elements above to
the properties of a JavaScript “contact” object that has a “name”
and “phone” property: When you execute this code,
the value of
the first INPUT element (#name) is set to
the value of
the contact name property,
and the value of
the second INPUT element (#phone) is set to
the value of
the contact phone property.
The properties of
the contact object
and the properties of
the INPUT elements are also linked – so that changes to one are also reflected in
the other. Because
the contact object is linked to
the INPUT element, when you request
the page,
the values of
the contact properties are displayed: More interesting,
the values of
the linked INPUT elements will change automatically whenever you update
the properties of
the contact object they are linked to. For example, we could programmatically modify
the properties of
the “contact” object using
the jQuery attr() method like below: Because our two INPUT elements are linked to
the “contact” object,
the INPUT element values will be updated automatically (without us having to write any code to modify
the UI elements): Note that we updated
the contact object above using
the jQuery attr() method. In order for data linking to work, you must use jQuery methods to modify
the property values. Two Way Linking
The linkBoth() method enables two-way data linking.
The contact object
and INPUT elements are linked in both directions. When you modify
the value of
the INPUT element,
the contact object is also updated automatically. For example,
the following code adds a client-side JavaScript click handler to an HTML button element. When you click
the button,
the property values of
the contact object are displayed using an alert() dialog:
The following demonstrates what happens when you change
the value of
the Name INPUT element
and click
the Save button. Notice that
the name property of
the “contact” object that
the INPUT element was linked to was updated automatically:
The above example is obviously trivially simple. Instead of displaying
the new values of
the contact object with a JavaScript alert, you can imagine instead calling a web-service to save
the object to a database.
The benefit of data linking is that it enables you to focus on your data
and frees you from
the mechanics of keeping your UI
and data in sync. Converters
The current data linking proposal also supports a feature called converters. A converter enables you to easily convert
the value of a property during data linking. For example, imagine that you want to represent phone numbers in a standard way with
the “contact” object phone property. In particular, you don’t want to include special characters such as ()- in
the phone number - instead you only want digits
and nothing else. In that case, you can wire-up a converter to convert
the value of an INPUT element into this format using
the code below: Notice above how a converter function is being passed to
the linkFrom() method used to link
the phone property of
the “contact” object with
the value of
the phone INPUT element. This convertor function strips any non-numeric characters from
the INPUT element before updating
the phone property. Now, if you enter
the phone number (206) 555-9999 into
the phone input field then
the value 2065559999 is assigned to
the phone property of
the contact object: You can also use a converter in
the opposite direction also. For example, you can apply a standard phone format string when displaying a phone number from a phone property. Combining Templating
and Data Linking Our goal in submitting these two proposals for templating
and data linking is to make it easier to work with data when building websites
and applications with jQuery. Templating makes it easier to display a list of database records retrieved from a database through an Ajax call. Data linking makes it easier to keep
the data
and user interface in sync for update scenarios. Currently, we are working on an extension of
the data linking proposal to support declarative data linking. We want to make it easy to take advantage of data linking when using a template to display data. For example, imagine that you are using
the following template to display an array of product objects: Notice
the {{link name}}
and {{link price}} expressions. These expressions enable declarative data linking between
the SPAN elements
and properties of
the product objects.
The current jQuery templating prototype supports extending its syntax with custom template commands. In this case, we are extending
the default templating syntax with a custom template command named “link”.
The benefit of using data linking with
the above template is that
the SPAN elements will be automatically updated whenever
the underlying “product” data is updated. Declarative data linking also makes it easier to create edit
and insert forms. For example, you could create a form for editing a product by using declarative data linking like this: Whenever you change
the value of
the INPUT elements in a template that uses declarative data linking,
the underlying JavaScript data object is automatically updated. Instead of needing to write code to scrape
the HTML form to get updated values, you can instead work with
the underlying data directly – making your client-side code much cleaner
and simpler. Downloading Working Code Examples of
the Above Scenarios You can download this .zip file to get with working code examples of
the above scenarios.
The .zip file includes 4 static HTML page: Listing1_Templating.htm – Illustrates basic templating. Listing2_TemplatingConditionals.htm – Illustrates templating with
the use of
the if
and each template commands. Listing3_DataLinking.htm – Illustrates data linking. Listing4_Converters.htm – Illustrates using a converter with data linking. You can un-zip
the file to
the file-system
and then run each page to see
the concepts in action. Summary We are excited to be able to begin participating within
the open-source jQuery project. We’ve received lots of encouraging feedback in response to our first two proposals,
and we will continue to actively contribute going forward. These features will hopefully make it easier for all developers (including ASP.NET developers) to build great Ajax applications. Hope this helps,
Scott P.S. [In addition to blogging, I am also now using Twitter for quick updates
and to share links. Follow me at: twitter.com/scottgu]
