关于javascript：如何使用方法创建jQuery插件？


How to create a jQuery plugin with methods?

我正在尝试编写一个jquery插件，它将为调用它的对象提供额外的函数/方法。我在线阅读的所有教程(已经浏览了2个小时)最多包括如何添加选项，但不包括其他功能。

我想做的是：

//通过调用DIV的插件将DIV格式化为消息容器

1
2
$("#mydiv").messagePlugin();
$("#mydiv").messagePlugin().saySomething("hello");

或者沿着这些线。这就是它的归根结底：我调用插件，然后调用与该插件相关联的函数。我似乎找不到这样做的方法，而且我以前见过很多插件这样做。

以下是迄今为止我对该插件的了解：

1
2
3
4
5
6
7
8
9
10
jQuery.fn.messagePlugin = function() {
  return this.each(function(){
    alert(this);
  });

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

我怎样才能做到这一点？

谢谢您！

2013年11月18日更新：我已将正确答案更改为Hari的以下评论和赞成票。

根据jquery插件创作页面(http://docs.jquery.com/plugin s/authoring)，最好不要混淆jquery和jquery.fn名称空间。他们建议这种方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
(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, Array.prototype.slice.call( 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 );

基本上，您将函数存储在一个数组中(范围为包装函数)，如果传递的参数是字符串，则检查条目，如果参数是对象(或空)，则恢复为默认方法("init")。

然后你可以像这样调用这些方法…

1
2
3
4
5
6
$('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"变量是所有传递的参数的数组，因此它可以使用任意长度的函数参数。

相关讨论

下面是我用其他方法创建插件时使用的模式。您可以这样使用它：

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

或者，直接调用一个方法，

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

例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
;(function($) {

    $.fn.extend({
        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 );
            });
            return;
        }
    });

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

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

        ...normal plugin actions...

        function myplugin_method1(arg)
        {
            ...do method1 with this and arg
        }

        function myplugin_method2(arg)
        {
            ...do method2 with this and arg
        }

    };

    $.myplugin.defaults = {
       ...
    };

})(jQuery);
相关讨论

这种方法怎么样：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
jQuery.fn.messagePlugin = function(){
    var selectedObjects = this;
    return {
             saySomething : function(message){
                              $(selectedObjects).each(function(){
                                $(this).html(message);
                              });
                              return selectedObjects; // Preserve the jQuery chainability
                            },
             anotherAction : function(){
                               //...
                               return selectedObjects;
                             }
           };
}
// Usage:
$('p').messagePlugin().saySomething('I am a Paragraph').css('color', 'red');

选定的对象存储在messageplugin闭包中，该函数返回一个包含与插件关联的函数的对象，在每个函数中，您可以对当前选定的对象执行所需的操作。

你可以在这里测试和玩代码。

编辑：更新代码以保持jquery可链接性的强大功能。

相关讨论

当前所选答案的问题是，您实际上并没有像您认为的那样为选择器中的每个元素创建自定义插件的新实例…实际上，您只创建了一个实例，并将选择器本身作为作用域传入。

查看此小提琴以获得更深入的解释。

相反，您需要使用jquery.each遍历选择器，并为选择器中的每个元素实例化一个自定义插件的新实例。

以下是如何：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
(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._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 = $el.data('customPlugin');

                customPlugins.push(customPlugin);
            }

            this.each(getCustomPlugin);

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

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

                if (!customPlugin) {
                    console.warn('$.customPlugin not instantiated yet');
                    console.info(this);
                    results.push(undefined);
                    return;
                }

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

            this.each(applyMethod);

            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);

                $el.data('customPlugin', customPlugin);
            }

            return this.each(init);
        }

    };

})(jQuery);

还有一把工作的小提琴。

您会注意到，在第一个小提琴中，所有的div总是以完全相同的像素数向右移动。这是因为选择器中的所有元素只存在一个选项对象。

使用上面所写的技术，您会注意到在第二个小提琴中，每个DIV没有对齐，并且是随机移动的(不包括第一个DIV，因为它的随机化器在第89行总是设置为1)。这是因为我们现在正确地为选择器中的每个元素实例化了一个新的自定义插件实例。每个元素都有自己的选项对象，并且不会保存在选择器中，而是保存在自定义插件本身的实例中。

这意味着您将能够从新的jquery选择器访问在DOM中的特定元素上实例化的自定义插件的方法，并且不会像第一个小提琴一样强制缓存它们。

例如，这将使用第二个小提琴中的技术返回所有选项对象的数组。它将返回第一个未定义的。

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

这是您必须在第一个小提琴中访问Options对象的方式，并且只返回一个对象，而不返回它们的数组：

1
2
3
4
5
var divs = $('div').customPlugin();
divs.customPlugin('options'); // would return a single options object

$('div').customPlugin('options');
// would return undefined, since it's not a cached selector

我建议使用上面的技巧，而不是当前选择的答案。

相关讨论

jQuery引入了小部件工厂，使这一过程变得简单多了。

例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
$.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 ) {
        // ...
    }

});

初始化：

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

方法调用：

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

(这是jquery UI库的构建方式。)

相关讨论

更简单的方法是使用嵌套函数。然后您可以以面向对象的方式将它们链接起来。例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
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;
};

以下是如何称呼它：

1
2
3
4
var pluginContainer = $("#divSomeContainer");
pluginContainer.MyPlugin();
pluginContainer.MyPlugin.DoSomething();
pluginContainer.MyPlugin.DoSomething.DoEvenMore();

不过要小心。在创建嵌套函数之前，不能调用它。所以你不能这样做：

1
2
3
4
var pluginContainer = $("#divSomeContainer");
pluginContainer.MyPlugin();
pluginContainer.MyPlugin.DoSomething.DoEvenMore();
pluginContainer.MyPlugin.DoSomething();

doevenmore函数甚至不存在，因为Dosomething函数还没有运行，这是创建doevenmore函数所必需的。对于大多数jquery插件，您实际上只需要一个嵌套函数级别，而不像我在这里展示的那样需要两个。只需确保在创建嵌套函数时，在执行父函数中的任何其他代码之前，先在父函数的开头定义这些函数。

最后，注意"this"成员存储在一个名为"this"的变量中。对于嵌套函数，如果需要对调用客户机中的实例的引用，则应返回"this"。不能只在嵌套函数中返回"this"，因为它将返回对函数的引用，而不是对jquery实例的引用。返回jquery引用允许您在返回时链接内部jquery方法。

相关讨论

我是从jquery插件样板文件得到的

同样在jquery插件样板文件中描述，重新打印

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
// jQuery Plugin Boilerplate
// A boilerplate for jumpstarting jQuery plugins development
// version 1.1, May 14th, 2011
// by Stefan Gabos

// remember to change every instance of"pluginName" to the name of your plugin!
(function($) {

    // here we go!
    $.pluginName = function(element, options) {

    // plugin's default options
    // this is private property and is accessible only from inside the plugin
    var defaults = {

        foo: 'bar',

        // if your plugin is event-driven, you may provide callback capabilities
        // for its events. execute these functions before or after events of your
        // plugin, so that users may customize those particular events without
        // changing the plugin's code
        onFoo: function() {}

    }

    // to avoid confusions, use"plugin" to reference the
    // current instance of the object
    var plugin = this;

    // this will hold the merged default, and user-provided options
    // plugin's properties will be available through this object like:
    // plugin.settings.propertyName from inside the plugin or
    // element.data('pluginName').settings.propertyName from outside the plugin,
    // where"element" is the element the plugin is attached to;
    plugin.settings = {}

    var $element = $(element), // reference to the jQuery version of DOM element
    element = element; // reference to the actual DOM element

    // the"constructor" method that gets called when the object is created
    plugin.init = function() {

    // the plugin's final properties are the merged default and
    // user-provided options (if any)
    plugin.settings = $.extend({}, defaults, options);

    // code goes here

   }

   // public methods
   // these methods can be called like:
   // plugin.methodName(arg1, arg2, ... argn) from inside the plugin or
   // element.data('pluginName').publicMethod(arg1, arg2, ... argn) from outside
   // the plugin, where"element" is the element the plugin is attached to;

   // a public method. for demonstration purposes only - remove it!
   plugin.foo_public_method = function() {

   // code goes here

    }

     // private methods
     // these methods can be called only from inside the plugin like:
     // methodName(arg1, arg2, ... argn)

     // a private method. for demonstration purposes only - remove it!
     var foo_private_method = function() {

        // code goes here

     }

     // fire up the plugin!
     // call the"constructor" method
     plugin.init();

     }

     // add the plugin to the jQuery.fn object
     $.fn.pluginName = function(options) {

        // iterate through the DOM elements we are attaching the plugin to
        return this.each(function() {

          // if plugin has not already been attached to the element
          if (undefined == $(this).data('pluginName')) {

              // create a new instance of the plugin
              // pass the DOM element and the user-provided options as arguments
              var plugin = new $.pluginName(this, options);

              // in the jQuery version of the element
              // store a reference to the plugin object
              // you can later access the plugin and its methods and properties like
              // element.data('pluginName').publicMethod(arg1, arg2, ... argn) or
              // element.data('pluginName').settings.propertyName
              $(this).data('pluginName', plugin);

           }

        });

    }

})(jQuery);
相关讨论

太晚了，但也许有一天它能帮助别人。

我也遇到过同样的情况，比如用一些方法创建一个jquery插件，在阅读了一些文章和一些轮胎之后，我创建了一个jquery插件样板(https://github.com/acanimal/jquery plugin样板)。

此外，我用它开发了一个管理标签的插件(https://github.com/acanimal/tagger.js)，并写了两篇博客文章，逐步解释jquery插件的创建(http://acuriousanimal.com/blog/2013/01/15/things-i-learned-creating-a-jquery-plugin-part-i/)。

相关讨论

你可以做到：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
(function ($) {

var YourPlugin = function (element, option) {
    var defaults = {
        //default value
    }

    this.option = $.extend({}, defaults, option);
    this.$element = $(element);
    this.init();
}

YourPlugin.prototype = {
    init: function () {
    },
    show: function() {

    },
    //another functions
}

$.fn.yourPlugin = function (option) {
    var arg = arguments,
        options = typeof option == 'object' && option;;
    return this.each(function () {
        var $this = $(this),
            data = $this.data('yourPlugin');

        if (!data) $this.data('yourPlugin', (data = new YourPlugin(this, options)));
        if (typeof option === 'string') {
            if (arg.length > 1) {
                data[option].apply(data, Array.prototype.slice.call(arg, 1));
            } else {
                data[option]();
            }
        }
    });
};
  });

这样，插件对象就作为数据值存储在元素中。

1
2
3
4
5
6
7
8
9
10
 //Initialization without option
 $('#myId').yourPlugin();

 //Initialization with option
 $('#myId').yourPlugin({
        //your option
 });

//call show method
$('#myId').yourPlugin('show');

使用触发器怎么样？有人知道使用它们有什么缺点吗？好处是所有内部变量都可以通过触发器访问，并且代码非常简单。

请参见jsiddle。

示例用法

1
2
3
4
5
6
7
8
9
10
This is the message container...


    var mp = $("#mydiv").messagePlugin();

    // the plugin returns the element it is called on
    mp.trigger("messagePlugin.saySomething","hello");

    // so defining the mp variable is not needed...
    $("#mydiv").trigger("messagePlugin.repeatLastMessage");

插件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
jQuery.fn.messagePlugin = function() {

    return this.each(function() {

        var lastmessage,
            $this = $(this);

        $this.on('messagePlugin.saySomething', function(e, message) {
            lastmessage = message;
            saySomething(message);
        });

        $this.on('messagePlugin.repeatLastMessage', function(e) {
            repeatLastMessage();
        });

        function saySomething(message) {
            $this.html("<p>
" + message +"
</p>");
        }

        function repeatLastMessage() {
            $this.append('<p>
Last message was: ' + lastmessage + '
</p>');
        }

    });

}
相关讨论

在这里，我想建议使用参数创建简单插件的步骤。

JS

1
2
3
4
5
6
7
8
9
10
11
12
(function($) {
    $.fn.myFirstPlugin = function( options ) {

        // Default params
        var params = $.extend({
            text     : 'Default Title',
            fontsize : 10,
        }, options);
        return $(this).text(params.text);

    }
}(jQuery));

这里，我们添加了名为params的默认对象，并使用extend函数设置了选项的默认值。因此，如果我们传递空参数，那么它将设置默认值，否则它将设置。

HTML

1
$('.cls-title').myFirstPlugin({ text : 'Argument Title' });

阅读更多：如何创建jquery插件

相关讨论

这是我的简略版本。与之前发布的内容类似，您可以致电：

1
2
$('#myDiv').MessagePlugin({ yourSettings: 'here' })
           .MessagePlugin('saySomething','Hello World!');

-或者直接访问@EDOCX1[0]

1
2
3
$elem = $('#myDiv').MessagePlugin();
var instance = $elem.data('plugin_MessagePlugin');
instance.saySomething('Hello World!');

消息插件.js

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
;(function($){

    function MessagePlugin(element,settings){ // The Plugin
        this.$elem = element;
        this._settings = settings;
        this.settings = $.extend(this._default,settings);
    }

    MessagePlugin.prototype = { // The Plugin prototype
        _default: {
            message: 'Generic message'
        },
        initialize: function(){},
        saySomething: function(message){
            message = message || this._default.message;
            return this.$elem.html(message);
        }
    };

    $.fn.MessagePlugin = function(settings){ // The Plugin call

        var instance = this.data('plugin_MessagePlugin'); // Get instance

        if(instance===undefined){ // Do instantiate if undefined
            settings = settings || {};
            this.data('plugin_MessagePlugin',new MessagePlugin(this,settings));
            return this;
        }

        if($.isFunction(MessagePlugin.prototype[settings])){ // Call method if argument is name of method
            var args = Array.prototype.slice.call(arguments); // Get the arguments as Array
            args.shift(); // Remove first argument (name of method)
            return MessagePlugin.prototype[settings].apply(instance, args); // Call the method
        }

        // Do error handling

        return this;
    }

})(jQuery);

试试这个：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
$.fn.extend({
"calendar":function(){
    console.log(this);
    var methods = {
           "add":function(){console.log("add"); return this;},
           "init":function(){console.log("init"); return this;},
           "sample":function(){console.log("sample"); return this;}
    };

    methods.init(); // you can call any method inside
    return methods;
}});
$.fn.calendar() // caller or
$.fn.calendar().sample().add().sample() ......; // call methods

以下插件结构利用jquery-data()方法为内部插件方法/设置提供公共接口(同时保持jquery的可链接性)：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
(function($, window, undefined) {

  $.fn.myPlugin = function(options) {

    // settings, e.g.:  
    var settings = $.extend({
      elementId: null,
      shape:"square",
      color:"aqua",
      borderWidth:"10px",
      borderColor:"DarkGray"
    }, options);

    // private methods, e.g.:
    var setBorder = function(color, width) {        
      settings.borderColor = color;
      settings.borderWidth = width;          
      drawShape();
    };

    var drawShape = function() {        
      $('#' + settings.elementId).attr('class', settings.shape +"" +"center");
      $('#' + settings.elementId).css({
        'background-color': settings.color,
        'border': settings.borderWidth + ' solid ' + settings.borderColor      
      });
      $('#' + settings.elementId).html(settings.color +"" + settings.shape);            
    };

    return this.each(function() { // jQuery chainability    
      // set stuff on ini, e.g.:
      settings.elementId = $(this).attr('id');
      drawShape();

      // PUBLIC INTERFACE
      // gives us stuff like:
      //
      //    $("#...").data('myPlugin').myPublicPluginMethod();
      //
      var myPlugin = {
        element: $(this),
        // access private plugin methods, e.g.:
        setBorder: function(color, width) {        
          setBorder(color, width);
          return this.element; // To ensure jQuery chainability
        },
        // access plugin settings, e.g.:
        color: function() {
          return settings.color;
        },        
        // access setting"shape"
        shape: function() {
          return settings.shape;
        },    
        // inspect settings
        inspectSettings: function() {
          msg ="inspecting settings for element '" + settings.elementId +"':";  
          msg +="
--- shape: '" + settings.shape +"'";
          msg +="
--- color: '" + settings.color +"'";
          msg +="
--- border: '" + settings.borderWidth + ' solid ' + settings.borderColor +"'";
          return msg;
        },              
        // do stuff on element, e.g.:  
        change: function(shape, color) {        
          settings.shape = shape;
          settings.color = color;
          drawShape();  
          return this.element; // To ensure jQuery chainability
        }
      };
      $(this).data("myPlugin", myPlugin);
    }); // return this.each
  }; // myPlugin
}(jQuery));

现在可以调用内部插件方法来访问或修改插件数据或相关元素，方法如下：

1
$("#...").data('myPlugin').myPublicPluginMethod();

只要从myPublicPluginMethod()jquery可链接性的实现内部返回当前元素(this)。将保留-因此以下工程：

1
$("#...").data('myPlugin').myPublicPluginMethod().css("color","red").html("....");

以下是一些示例(有关详细信息，请检查此小提琴)：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
// initialize plugin on elements, e.g.:
$("#shape1").myPlugin({shape: 'square', color: 'blue', borderColor: 'SteelBlue'});
$("#shape2").myPlugin({shape: 'rectangle', color: 'red', borderColor: '#ff4d4d'});
$("#shape3").myPlugin({shape: 'circle', color: 'green', borderColor: 'LimeGreen'});

// calling plugin methods to read element specific plugin settings:
console.log($("#shape1").data('myPlugin').inspectSettings());    
console.log($("#shape2").data('myPlugin').inspectSettings());    
console.log($("#shape3").data('myPlugin').inspectSettings());      

// calling plugin methods to modify elements, e.g.:
// (OMG! And they are chainable too!)
$("#shape1").data('myPlugin').change("circle","green").fadeOut(2000).fadeIn(2000);      
$("#shape1").data('myPlugin').setBorder('LimeGreen', '30px');

$("#shape2").data('myPlugin').change("rectangle","red");
$("#shape2").data('myPlugin').setBorder('#ff4d4d', '40px').css({
  'width': '350px',
  'font-size': '2em'
}).slideUp(2000).slideDown(2000);              

$("#shape3").data('myPlugin').change("square","blue").fadeOut(2000).fadeIn(2000);  
$("#shape3").data('myPlugin').setBorder('SteelBlue', '30px');

// etc. ...

这实际上可以通过使用defineProperty以一种"好"的方式来实现。其中"nice"意味着不必使用()获取插件名称空间，也不必通过字符串传递函数名。

兼容性NIT:defineProperty在IE8及以下的古浏览器中不起作用。注意：$.fn.color.blue.apply(foo, args)不起作用，你需要使用foo.color.blue.apply(foo, args)。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
function $_color(color)
{
    return this.css('color', color);
}

function $_color_blue()
{
    return this.css('color', 'blue');
}

Object.defineProperty($.fn, 'color',
{
    enumerable: true,
    get: function()
    {
        var self = this;

        var ret = function() { return $_color.apply(self, arguments); }
        ret.blue = function() { return $_color_blue.apply(self, arguments); }

        return ret;
    }
});

$('#foo').color('#f00');
$('#bar').color.blue();

JSFiddle连杆

根据jquery标准，可以创建如下插件：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
(function($) {

    //methods starts here....
    var methods = {
        init : function(method,options) {
             this.loadKeywords.settings = $.extend({}, this.loadKeywords.defaults, options);
             methods[method].apply( this, Array.prototype.slice.call( arguments, 1 ));
             $loadkeywordbase=$(this);
        },
        show : function() {
            //your code here.................
        },
        getData : function() {
           //your code here.................
        }

    } // do not put semi colon here otherwise it will not work in ie7
    //end of methods

    //main plugin function starts here...
    $.fn.loadKeywords = function(options,method) {
        if (methods[method]) {
            return methods[method].apply(this, Array.prototype.slice.call(
                    arguments, 1));
        } else if (typeof method === 'object' || !method) {
            return methods.init.apply(this, arguments);
        } else {
            $.error('Method ' + method + ' does not ecw-Keywords');
        }
    };
    $.fn.loadKeywords.defaults = {
            keyName:     'Messages',
            Options:     '1',
            callback: '',
    };
    $.fn.loadKeywords.settings = {};
    //end of plugin keyword function.

})(jQuery);

如何调用此插件？

1
1.$('your element').loadKeywords('show',{'callback':callbackdata,'keyName':'myKey'}); // show() will be called

参考文献：链接

我想这可能对你有帮助…

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
(function ( $ ) {
 
    $.fn.highlight = function( options ) {
 
        // This is the easiest way to have default options.
        var settings = $.extend({
            // These are the defaults.
            color:"#000",
            backgroundColor:"yellow"
        }, options );
 
        // Highlight the collection based on the settings variable.
        return this.css({
            color: settings.color,
            backgroundColor: settings.backgroundColor
        });
 
    };
 
}( jQuery ));

在上面的例子中，我创建了一个简单的jquery突出显示插件，我分享了一篇文章，其中讨论了如何从basic到advance创建自己的jquery插件。我想你应该看看…http://mycodingtricks.com/jquery/how-to-create-your-own-jquery-plugin/

下面是一个小插件，具有调试的警告方法。将此代码保存在jquery.debug.js文件中：JS：

1
2
3
4
5
jQuery.fn.warning = function() {
   return this.each(function() {
      alert('Tag Name:"' + $(this).prop("tagName") + '".');
   });
};

HTML：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
<html>
   <head>
      The jQuery Example

      <script type ="text/javascript"
         src ="http://ajax.googleapis.com/ajax/libs/jquery/2.1.3/jquery.min.js">

      <script src ="jquery.debug.js" type ="text/javascript">

      <script type ="text/javascript" language ="javascript">
         $(document).ready(function() {
            $("div").warning();
            $("p").warning();
         });
       
   </head>

   <body>
      <p>
This is paragraph
</p>
      This is division
   </body>

</html>

我是这样做的：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
(function ( $ ) {

$.fn.gridview = function( options ) {

    ..........
    ..........


    var factory = new htmlFactory();
    factory.header(...);

    ........

};

}( jQuery ));


var htmlFactory = function(){

    //header
     this.header = function(object){
       console.log(object);
  }
 }

您所做的基本上是用新方法扩展jquery.fn.MessagePlugin对象。这是有用的，但在你的情况下没有。

你要做的是使用这种技术

1
2
3
4
5
6
7
8
9
10
11
function methodA(args){ this // refers to object... }
function saySomething(message){ this.html(message);  to first function }

jQuery.fn.messagePlugin = function(opts) {
  if(opts=='methodA') methodA.call(this);
  if(opts=='saySomething') saySomething.call(this, arguments[0]); // arguments is an array of passed parameters
  return this.each(function(){
    alert(this);
  });

};

但是你可以实现你想要的，我的意思是有一种方法可以做到，$(mydiv").messageplugin().sayisomething("hello")；我的朋友他开始写关于lugins的文章，以及如何用你的功能链扩展它们这里是他博客的链接