JavaScript Patterns Collection


JS Patterns

A JavaScript pattern and antipattern collection that covers function patterns, jQuery patterns, jQuery plugin patterns, design patterns, general patterns, literals and constructor patterns, object creation patterns, code reuse patterns, DOM and browser patterns (upcoming).

General Patterns

jQuery Patterns

  • requery – avoid requery by using jQuery chaining
  • append – use string concatenate and set innerHTML
  • data – pattern and antipattern of using data
  • context and find – use find over context
  • detach – take element off the DOM while manipulating them
  • event delegation – event delegation pattern and antipattern
  • selector cache – using selector cache to avoid requery
  • window scroll event – avoid attaching handlers to the window scroll event

Selector

Publish–subscribe

  • Method 1 – custom events using .on() and .off()
  • Method 2 – using jQuery 1.7’s $.Callbacks() feature
  • Method 3 – using jQuery UI $.Observable
  • Method 4 – third-party plugins

jQuery Plugin Patterns

Literals and Constructors Patterns

  • Object literal – use the simpler and reliable object literal instead of new Object();
  • Enforcing new – when you forget `new`, `this` inside the constructor will point to the global object
  • Array literal – use array literal notation to avoid potential errors when creating dynamic arrays at runtime
  • Working with JSON – use library from JSON.org, YUI, jQuery instead of eval for parsing
  • Primitive wrappers – try to use the primitive without wrapper
  • Regular expression literal – try to use the shorter literal notation

Function Patterns

API Patterns

  • Callback patterns – when you pass function A to function B as a parameter, function A is a callback function
  • Configuration objects – keep control of function arguments and makes it easily configurable
  • Returning functions – one function returns another function or create another function on-demand
  • Currying – used to create new functions dynamically by partially applying a set of arguments
  • Partial application – the process of fixing a number of arguments to a function, producing another function of smaller arity

Initialization patterns

Performance patterns

  • Memoization – use function properties to avoid repeated computation
  • Self-defining functions – self-overwrite with new bodies to do less work from the second invocation and after

Object Creation Patterns

  • Namespace – namespaces help reduce the number of globals required and avoid naming collisions or excessive name prefixing
  • Declaring Dependencies – it’s good to declare the modules your code relies on at the top
  • Private Properties and Methods – JavaScript doesn’t have special syntax for private members, you can implement them using a closure
  • Revelation Pattern – it is about having private methods, which you also expose as public methods
  • Module Pattern – all the methods are kept private and you only expose those that you decide at the end
  • Sandbox – it provides an environment for the modules to work without affecting other modules and their personal sandboxes
  • Static Members – public and private static members
  • Object Constants – an implementation of a contant object provides set, inDefined and get methods
  • Chaining Pattern – it enables you to call methods on an object one after the other
  • method() Method – adding convenient funcationality to a language

Code Reuse Patterns

Classical Patterns (patterns that should generally be avoided)

  • The default pattern – create an object using the Parent() constructor and assign this object to the Child()’s prototype
  • Rent a constructor – it borrows the parent constructor, passing the child object to be bound to this and also forwarding any arguments
  • Rent and Set Prototype – restricts object creation for a class to only one instance
  • Share the Prototype – restricts object creation for a class to only one instance
  • A Temporary Constructor – first borrow the constructor and then also set the child’s prototype to point to a new instance of the constructor
  • Klass – generally a pattern that should be avoided unless one is more comfortable with class than prototype

Preferred Patterns

Design Patterns

Creational

  • Builder – constructs complex objects by separating construction and representation
  • Factory method – creates objects without specifying the exact class to create
  • Singleton – restricts object creation for a class to only one instance

Structural

  • Decorator – dynamically adds/overrides behaviour in an existing method of an object
  • Facade – provides a simplified interface to a large body of code
  • Proxy – provides a placeholder for another object to control access, reduce cost, and reduce complexity

Behavioral

  • Chain of responsibility – delegates commands to a chain of processing objects
  • Command – creates objects which encapsulate actions and parameters
  • Iterator – implements a specialized language
  • Mediator – allows loose coupling between classes by being the only class that has detailed knowledge of their methods
  • Observer – is a publish/subscribe pattern which allows a number of observer objects to see an event
  • Strategy – allows one of a family of algorithms to be selected on-the-fly at runtime
Advertisements

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s