Tag Archives: design patterns

JavaScript Closures and the Module Pattern

Posted on by
9

JavaScript Closures and the Module PatternOne of the most widely used design patterns in JavaScript is the module pattern.  The module pattern makes use of one of the nicer features of JavaScript – closures – in order to give you some control of the privacy of your methods so that third party applications cannot access private data or overwrite it. In this post I’ll teach you what a closure is, how it works, and how to utilize it to implement the module pattern in your own JavaScript code. Continue reading →

Introduction to Backbone.js Part 4: Collections – Video Tutorial

Posted on by
8

Backbone.js Collections Video TutorialPart 4: Backbone.js Collections Video Tutorial is here now. We’ve already discussed models, views, and routers in Backbone.js so far, but now we’re on to collections. Collections are pretty much exactly what their name implies: collections of models. Many times, data is displayed in lists, not just singular items. This is where collections come in – to keep every model in order and synchronized with the database on the back end. Continue reading →

Give Your Apps a Backbone(.js)

Posted on by
17

Give Your Apps a BackboneAs the internet gets smarter and smarter and JavaScript starts piling up on web pages, we need to learn to organize our code. The days of filling the global namespace with all the functions we can think of are long over and have become far too difficult to maintain. Along with many other design patterns, the MVC (model, view, controller) pattern can bring order to the chaotic spaghetti of your JavaScript code. Right now, the de facto JavaScript MVC framework library is Backbone.js.
Continue reading →

JavaScript Design Patterns: Chain of Responsibility

Posted on by
Reply

We’ve made it to the final installment in the JavaScript Design Patterns series. That’s right, after this you’ll no longer have any clue what post will be coming out every Monday! Well today, we’ll be talking about the Chain of Responsibility Pattern. This pattern decouples the sender and receiver of a request. This is done with a chain of objects, each of which can handle the request itself or pass it on to the next object. Confused? Read on.
Continue reading →

JavaScript Design Patterns: Command

Posted on by
4

The Command Pattern is a strange beast in the context of object-oriented programming. Unlike most objects, a command object represents a verb, rather than a noun. This is a little less odd in a language like JavaScript where functions are actually a type of object, but the classical sense of the Command pattern is still different than a function. Continue reading →

JavaScript Design Patterns: Observer

Posted on by
2

It’s time to introduce you guys to the Observer pattern. If you’ve been following this blog lately, you may have already had an introduction through my post talking about my jQuery plugin called JZ Publish/Subscribe. Well, here we’ll be talking about a few other ways to implement the Observer pattern, so you’ll know the method that works best for you and your application. Continue reading →

JavaScript Design Patterns: Proxy

Posted on by
Reply

This is the 9th installment of the JavaScript Design Patterns series and today we’re featuring the Proxy pattern. The word “proxy” can be defined as a substitute, and that essentially explains what a proxy is. A proxy is an object that has the same interface as another object and is used in place of that other object. The only question is why we would use a proxy instead of the original object. Continue reading →

JavaScript Design Patterns: Factory Part 2

Posted on by
2

In the last post, I started talking about the Factory Design Pattern, which creates objects for you, generally all of which follow the same interface. So far we’ve covered the Simple Factory, which creates this functionality in a Singleton object, which is the simplest way of creating a Factory, hence its nomenclature (I love that word). This time I’ll show you the true Factory. Continue reading →

JavaScript Design Patterns: Factory

Posted on by
4

Another post, another JavaScript design pattern. Today we feature the Factory pattern. The Factory pattern is one of my favorite patterns, especially the “simple factory”, which I’ll explain later. Factories – in real life as well as within the programming world – create objects. It helps clean up your code by removing all of the new operators. Continue reading →

JavaScript Design Patterns: Decorator

Posted on by
14

Today I’d like to show another JavaScript Design Pattern: the Decorator, which is a way to add features to objects without subclassing or adding extra attributes. This post continues the JavaScript Design Patterns series that I started several months ago. If you’re new to the JavaScript Design Patterns series that I’m running here, you can find a list of the previous and upcoming posts in the series at the bottom of the post. Continue reading →