How to create a jQuery plugin with methods?

How to create a jQuery plugin with methods?

I’m trying to write a jQuery plugin that will provide additional functions/methods to the object that calls it. All the tutorials I read online (have been browsing for the past 2 hours) include, at the most, how to add options, but not additional functions.
Here’s what I am looking to do:
//format div to be a message container by calling the plugin for that div

or something along those lines.
Here’s what it boils down to: I call the plugin, then I call a function associated with that plugin. I can’t seem to find a way to do this, and I’ve seen many plugins do it before.
Here’s what I have so far for the plugin:
jQuery.fn.messagePlugin = function() {
return this.each(function(){

//i tried to do this, but it does not seem to work
jQuery.fn.messagePlugin.saySomething = function(message){

How can I achieve something like that?
Thank you!

Update Nov 18, 2013: I’ve changed the correct answer to that of Hari’s following comments and upvotes.


Solution 1:

According to the jQuery Plugin Authoring page (, it’s best not to muddy up the jQuery and jQuery.fn namespaces. They suggest this method:

(function( $ ){

    var methods = {
        init : function(options) {

        show : function( ) {    },// IS
        hide : function( ) {  },// GOOD
        update : function( content ) {  }// !!!

    $.fn.tooltip = function(methodOrOptions) {
        if ( methods[methodOrOptions] ) {
            return methods[ methodOrOptions ].apply( this, arguments, 1 ));
        } else if ( typeof methodOrOptions === 'object' || ! methodOrOptions ) {
            // Default to "init"
            return methods.init.apply( this, arguments );
        } else {
            $.error( 'Method ' +  methodOrOptions + ' does not exist on jQuery.tooltip' );

})( jQuery );

Basically you store your functions in an array (scoped to the wrapping function) and check for an entry if the parameter passed is a string, reverting to a default method (“init” here) if the parameter is an object (or null).

Then you can call the methods like so…

$('div').tooltip(); // calls the init method
$('div').tooltip({  // calls the init method
  foo : 'bar'
$('div').tooltip('hide'); // calls the hide method
$('div').tooltip('update', 'This is the new tooltip content!'); // calls the update method

Javascripts “arguments” variable is an array of all the arguments passed so it works with arbitrary lengths of function parameters.

Related:  Difference between the created and mounted events in Vue.js

Solution 2:

Here’s the pattern I have used for creating plugins with additional methods. You would use it like:

$('selector').myplugin( { key: 'value' } );

or, to invoke a method directly,

$('selector').myplugin( 'mymethod1', 'argument' );


;(function($) {

        myplugin: function(options,arg) {
            if (options && typeof(options) == 'object') {
                options = $.extend( {}, $.myplugin.defaults, options );

            // this creates a plugin for each element in
            // the selector or runs the function once per
            // selector.  To have it do so for just the
            // first element (once), return false after
            // creating the plugin to stop the each iteration 
            this.each(function() {
                new $.myplugin(this, options, arg );

    $.myplugin = function( elem, options, arg ) {

        if (options && typeof(options) == 'string') {
           if (options == 'mymethod1') {
               myplugin_method1( arg );
           else if (options == 'mymethod2') {
               myplugin_method2( arg );

        ...normal plugin actions...

        function myplugin_method1(arg)
   method1 with this and arg

        function myplugin_method2(arg)
   method2 with this and arg


    $.myplugin.defaults = {


Solution 3:

What about this approach:

jQuery.fn.messagePlugin = function(){
    var selectedObjects = this;
    return {
             saySomething : function(message){
                              return selectedObjects; // Preserve the jQuery chainability 
             anotherAction : function(){
                               return selectedObjects;
// Usage:
$('p').messagePlugin().saySomething('I am a Paragraph').css('color', 'red');

The selected objects are stored in the messagePlugin closure, and that function returns an object that contains the functions associated with the plugin, the in each function you can perform the desired actions to the currently selected objects.

You can test and play with the code here.

Edit: Updated code to preserve the power of the jQuery chainability.

Solution 4:

The problem with the currently selected answer is that you’re not actually creating a new instance of the custom plugin for every element in the selector like you think you’re doing… you’re actually only creating a single instance and passing in the selector itself as the scope.

View this fiddle for a deeper explanation.

Instead, you’ll need to loop through the selector using jQuery.each and instantiate a new instance of the custom plugin for every element in the selector.

Related:  How can I get the sha1 hash of a string in node.js?

Here’s how:

(function($) {

    var CustomPlugin = function($el, options) {

        this._defaults = {
            randomizer: Math.random()

        this._options = $.extend(true, {}, this._defaults, options);

        this.options = function(options) {
            return (options) ?
                $.extend(true, this._options, options) :

        this.move = function() {
            $el.css('margin-left', this._options.randomizer * 100);


    $.fn.customPlugin = function(methodOrOptions) {

        var method = (typeof methodOrOptions === 'string') ? methodOrOptions : undefined;

        if (method) {
            var customPlugins = [];

            function getCustomPlugin() {
                var $el          = $(this);
                var customPlugin = $'customPlugin');



            var args    = (arguments.length > 1) ?, 1) : undefined;
            var results = [];

            function applyMethod(index) {
                var customPlugin = customPlugins[index];

                if (!customPlugin) {
                    console.warn('$.customPlugin not instantiated yet');

                if (typeof customPlugin[method] === 'function') {
                    var result = customPlugin[method].apply(customPlugin, args);
                } else {
                    console.warn('Method \'' + method + '\' not defined in $.customPlugin');


            return (results.length > 1) ? results : results[0];
        } else {
            var options = (typeof methodOrOptions === 'object') ? methodOrOptions : undefined;

            function init() {
                var $el          = $(this);
                var customPlugin = new CustomPlugin($el, options);

                $'customPlugin', customPlugin);

            return this.each(init);



And a working fiddle.

You’ll notice how in the first fiddle, all divs are always moved to the right the exact same number of pixels. That is because only one options object exists for all elements in the selector.

Using the technique written above, you’ll notice that in the second fiddle, each div is not aligned and is randomly moved (excluding the first div as it’s randomizer is always set to 1 on line 89). That is because we are now properly instantiating a new custom plugin instance for every element in the selector. Every element has its own options object and is not saved in the selector, but in the instance of the custom plugin itself.

This means that you’ll be able to access the methods of the custom plugin instantiated on a specific element in the DOM from new jQuery selectors and aren’t forced to cache them, as you would be in the first fiddle.

For example, this would return an array of all options objects using the technique in the second fiddle. It would return undefined in the first.

$('div').customPlugin('options'); // would return an array of all options objects

This is how you would have to access the options object in the first fiddle, and would only return a single object, not an array of them:

var divs = $('div').customPlugin();
divs.customPlugin('options'); // would return a single options object

// would return undefined, since it's not a cached selector

I’d suggest using the technique above, not the one from the currently selected answer.

Related:  load scripts asynchronously

Solution 5:

jQuery has made this a lot easier with the introduction of the Widget Factory.


$.widget( "myNamespace.myPlugin", {

    options: {
        // Default options

    _create: function() {
        // Initialization logic here

    // Create a public method.
    myPublicMethod: function( argument ) {
        // ...

    // Create a private method.
    _myPrivateMethod: function( argument ) {
        // ...



$('#my-element').myPlugin( {defaultValue:10} );

Method calling:

$('#my-element').myPlugin('myPublicMethod', 20);

(This is how the jQuery UI library is built.)

Solution 6:

A simpler approach is to use nested functions. Then you can chain them in an object-oriented fashion. Example:

jQuery.fn.MyPlugin = function()
  var _this = this;
  var a = 1;

  jQuery.fn.MyPlugin.DoSomething = function()
    var b = a;
    var c = 2;

    jQuery.fn.MyPlugin.DoSomething.DoEvenMore = function()
      var d = a;
      var e = c;
      var f = 3;
      return _this;

    return _this;

  return this;

And here’s how to call it:

var pluginContainer = $("#divSomeContainer");

Be careful though. You cannot call a nested function until it has been created. So you cannot do this:

var pluginContainer = $("#divSomeContainer");

The DoEvenMore function doesn’t even exist because the DoSomething function hasn’t been run yet which is required to create the DoEvenMore function. For most jQuery plugins, you really are only going to have one level of nested functions and not two as I’ve shown here.
Just make sure that when you create nested functions that you define these functions at the beginning of their parent function before any other code in the parent function gets executed.

Finally, note that the “this” member is stored in a variable called “_this”. For nested functions, you should return “_this” if you need a reference to the instance in the calling client. You cannot just return “this” in the nested function because that will return a reference to the function and not the jQuery instance. Returning a jQuery reference allows you to chain intrinsic jQuery methods on return.