तरीकों के साथ एक jQuery प्लगइन बनाने के लिए कैसे?


191

मैं एक jQuery प्लगइन लिखने की कोशिश कर रहा हूं जो उस वस्तु को अतिरिक्त फ़ंक्शन / तरीके प्रदान करेगा जो इसे कॉल करता है। मैंने जितने भी ट्यूटोरियल ऑनलाइन पढ़े हैं (पिछले 2 घंटों से ब्राउज़ कर रहे हैं) में शामिल हैं, सबसे ज्यादा, विकल्प कैसे जोड़ें, लेकिन अतिरिक्त कार्य नहीं।

यहाँ मैं देख रहा हूँ:

// प्रारूप div उस संदेश के लिए प्लगइन को कॉल करके एक संदेश कंटेनर होना चाहिए

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

या उनके जैसे की कुछ और। यहां यह बताया गया है: मैं प्लगइन को कॉल करता हूं, फिर मैं उस प्लगइन से जुड़े फ़ंक्शन को कॉल करता हूं। मुझे ऐसा करने का कोई तरीका नहीं मिल रहा है, और मैंने कई प्लगइन्स को पहले करते देखा है।

यहाँ मैं प्लगइन के लिए अब तक क्या है:

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

मैं ऐसा कुछ कैसे हासिल कर सकता हूं?

धन्यवाद!


18 नवंबर 2013 को अपडेट करें: मैंने हरि की निम्न टिप्पणियों और अपवोट्स का सही उत्तर बदल दिया है।

जवाबों:


310

JQuery प्लगइन संलेखन पृष्ठ ( http://docs.jquery.com/Plugins/Authoring ) के अनुसार, यह jQuery और jQuery.fn नामस्थानों को मैला करने के लिए सबसे अच्छा नहीं है। वे इस विधि का सुझाव देते हैं:

(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") के लिए यदि पैरामीटर एक ऑब्जेक्ट (या अशक्त) है।

तब आप इस तरह से तरीकों को कॉल कर सकते हैं ...

$('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

जावास्क्रिप्ट "तर्क" चर सभी तर्कों का एक सरणी है जो पारित हो गया है इसलिए यह फ़ंक्शन मापदंडों की मनमानी लंबाई के साथ काम करता है।


2
यह मेरे द्वारा उपयोग की जाने वाली विधि है। आप $ .fn.tooltip ('methodname', params) के माध्यम से विधियों को स्थिर रूप से भी कॉल कर सकते हैं;
राके ३६ R

1
बहुत काम की वास्तुकला। मैंने init मेथड को कॉल करने से पहले इस लाइन को भी जोड़ा: this.data('tooltip', $.extend(true, {}, $.fn.tooltip.defaults, methodOrOptions));इसलिए, अब जब भी इनिशियलाइज़ेशन के बाद मैं चाहूँ तो ऑप्शन पर पहुँच सकता हूँ।
ivkremer

16
मेरे जैसे किसी के लिए जिसने पहली बार कहा था "तर्क चर कहां से आए" - developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… - मैं हमेशा के लिए जेएस का उपयोग कर रहा हूं और यह कभी नहीं जानता था। आप हर दिन कुछ नया सीखते हैं!
स्ट्रीटलॉगिक्स

2
@DiH, मैं इस एक पर तुम्हारे साथ हूँ। यह दृष्टिकोण बहुत अच्छा लगता है, लेकिन यह आपको अपनी वैश्विक सेटिंग्स के अलावा कहीं से भी एक्सेस नहीं देता है init
स्टीफन कॉलिन्स

4
इस तकनीक के साथ एक बड़ी समस्या है! यह चयनकर्ता में प्रत्येक तत्व के लिए एक नया उदाहरण नहीं बनाता है जैसा कि आप सोचते हैं कि आप कर रहे हैं, इसके बजाय यह चयनकर्ता से जुड़ा केवल एक ही उदाहरण बनाता है। समाधान के लिए मेरा उत्तर देखें ।
केविन जुरकोव्स्की

56

यहाँ मैं पैटर्न है जो अतिरिक्त तरीकों के साथ प्लगइन्स बनाने के लिए उपयोग किया है। आप इसका उपयोग इस तरह करेंगे:

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

या, एक विधि को सीधे लागू करने के लिए,

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

उदाहरण:

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

9
jquery-ui के रूप में एक ही पैटर्न, मुझे सभी जादू तार पसंद नहीं है लेकिन क्या कोई अन्य तरीका है!
दोपहर

8
यह चीजों को करने के एक गैर-मानक तरीके की तरह लगता है - क्या इसके अलावा कुछ भी सरल है, जैसे कि फ़ंक्शंस का पीछा करना? धन्यवाद!
युवल कर्मी

2
@ ओवल - आम तौर पर jQuery प्लगइन्स jQuery या एक मान लौटाते हैं, न कि प्लगइन। इसीलिए जब आप प्लगइन को इनवाइट करना चाहते हैं तो मेथड का नाम प्लगइन के तर्क के रूप में दिया जाता है। आप किसी भी तर्क को पारित कर सकते हैं, लेकिन आपको फ़ंक्शंस और तर्क पार्सिंग को समायोजित करना होगा। जैसा कि आपने दिखाया था शायद उन्हें एक अनाम वस्तु में सेट करने के लिए सबसे अच्छा है।
tvanfosson

1
;आपकी पहली पंक्ति में क्या अर्थ है ? कृपया मुझे समझाएं :)
GusDeCooL

4
@GusDeCooL यह सिर्फ यह सुनिश्चित करता है कि हम एक नया बयान शुरू कर रहे हैं ताकि हमारी फ़ंक्शन परिभाषा किसी अन्य व्यक्ति के खराब स्वरूपित जावास्क्रिप्ट के तर्क के रूप में व्याख्या न की जाए (यानी, प्रारंभिक पारे को फ़ंक्शन मंगलाचरण ऑपरेटर के रूप में नहीं लिया जाता है)। देखें stackoverflow.com/questions/7365172/...
tvanfosson

35

इस दृष्टिकोण के बारे में क्या:

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

चयनित ऑब्जेक्ट्स मैसेजप्लगिन क्लोजर में संग्रहीत किए जाते हैं, और वह फ़ंक्शन एक ऑब्जेक्ट देता है जिसमें प्लगइन से जुड़े फ़ंक्शन होते हैं, प्रत्येक फ़ंक्शन में आप वर्तमान में चयनित ऑब्जेक्ट्स के लिए वांछित कार्रवाई कर सकते हैं।

आप यहां कोड के साथ परीक्षण और खेल सकते हैं

संपादित करें: jQuery चेनबिलिटी की शक्ति को संरक्षित करने के लिए अद्यतित कोड।


1
मुझे यह समझने में थोड़ी मुश्किल हो रही है कि यह कैसा दिखेगा। यह मानते हुए कि मेरे पास पहली बार चलने वाले कोड को निष्पादित करने की आवश्यकता है, मुझे पहले इसे अपने कोड में इनिशियलाइज़ करना होगा - कुछ इस तरह: $ ('p')। messagePlugin (); फिर बाद में कोड में मैं फ़ंक्शन को कॉल करना चाहूंगा इस तरह $ ('p')। messagePlin ()! saySomething ('कुछ'); क्या यह प्लगइन को फिर से इनिशियलाइज़ नहीं करेगा और फिर फ़ंक्शन को कॉल करेगा? यह बाड़े और विकल्पों के साथ कैसा दिखेगा? आपका बहुत बहुत धन्यवाद। -युवल
कर्मी

1
यद्यपि jQuery के श्रृंखलाबद्धता प्रतिमान को तोड़ता है।
tvanfosson

शायद यह सबसे अच्छा जवाब होना चाहिए
खींचें

3
हर बार जब आप messagePlugin () कहते हैं, तो यह उन दो कार्यों के साथ एक नई वस्तु बनाएगा, नहीं?
w00t

4
इस दृष्टिकोण के साथ मुख्य मुद्दा यह है कि $('p').messagePlugin()जब तक आप इसे वापस करने वाले दो कार्यों में से एक को कॉल नहीं करते हैं, तब तक यह चेनबिलिटी को संरक्षित नहीं कर सकता है।
जोशुआ बमब्रिक

18

वर्तमान में चयनित उत्तर के साथ समस्या यह है कि आप वास्तव में चयनकर्ता में हर तत्व के लिए कस्टम प्लगइन का एक नया उदाहरण नहीं बना रहे हैं, जैसे आपको लगता है कि आप कर रहे हैं ... आप वास्तव में केवल एक उदाहरण बना रहे हैं और पास कर रहे हैं चयनकर्ता गुंजाइश के रूप में।

देखें इस बेला एक गहरी व्याख्या के लिए।

इसके बजाय, आपको jQuery.each का उपयोग करके चयनकर्ता के माध्यम से लूप करना होगा और चयनकर्ता में प्रत्येक तत्व के लिए कस्टम प्लगइन का एक नया उदाहरण त्वरित करना होगा।

ऐसे:

(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 को छोड़कर क्योंकि यह randomizer हमेशा 1 के लिए लाइन 89 पर सेट है)। ऐसा इसलिए है क्योंकि अब हम ठीक से चयनकर्ता में हर तत्व के लिए एक नया कस्टम प्लगइन इंस्टेंट बना रहे हैं। प्रत्येक तत्व का अपना विकल्प ऑब्जेक्ट होता है और चयनकर्ता में सहेजा नहीं जाता है, लेकिन कस्टम प्लगइन के उदाहरण में ही।

इसका मतलब है कि आप नए jQuery के चयनकर्ताओं से DOM में एक विशिष्ट तत्व पर त्वरित कस्टम प्लगइन के तरीकों का उपयोग करने में सक्षम होंगे और उन्हें पहले कैश करने के लिए मजबूर नहीं किया जाएगा।

उदाहरण के लिए, यह दूसरी फ़िडेल में तकनीक का उपयोग करके सभी विकल्प ऑब्जेक्ट्स की एक सरणी लौटाएगा। यह पहले में अपरिभाषित लौट आएगा।

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

यह है कि आपको पहली फ़िडल में विकल्प ऑब्जेक्ट तक कैसे पहुंचना होगा, और केवल एक ही ऑब्जेक्ट लौटाएगा, उनमें से नहीं:

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

मैं ऊपर दी गई तकनीक का उपयोग करने का सुझाव देता हूं, वर्तमान में चयनित उत्तर से नहीं।


धन्यवाद, इससे मुझे बहुत मदद मिली, विशेष रूप से .data () पद्धति का परिचय। बेहद सुविधाजनक। FWIW आप गुमनाम तरीकों का उपयोग करके अपने कुछ कोड को भी सरल बना सकते हैं।
डालमेक

jQuery chainability इस पद्धति का उपयोग नहीं कर रहा है ... $('.my-elements').find('.first-input').customPlugin('update'‌​, 'first value').end().find('.second-input').customPlugin('update', 'second value'); returns Cannot read property 'end' of undefinedjsfiddle.net/h8v1k2pL
एलेक्स G

16

jQuery ने विजेट फैक्टरी की शुरुआत के साथ इसे बहुत आसान बना दिया है ।

उदाहरण:

$.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();
$('#my-element').myPlugin( {defaultValue:10} );

विधि कॉलिंग:

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

(यह है कि कैसे jQuery यूआई पुस्तकालय बनाया गया है।)


@ daniel.sedlacek a) "बहुत खराब आर्किटेक्चर" - यह jQuery के मानक विजेट आर्किटेक्चर है b) "संकलन समय पर अखंडता के लिए जाँच" - जावास्क्रिप्ट एक गतिशील भाषा है c) "टाइपस्क्रिप्ट" - wha?
यारिन

a) वह दलील ऐड पोपुलम है, b) हर बेहतर JS IDE में कोड पूरा या
लाइनिंग है

यह शुद्ध भ्रम है, श्री सेडलेस्क।
23

डॉक्स के अनुसार: इस प्रणाली को विजेट फैक्टरी कहा जाता है और इसे jQuery.widget के रूप में jQuery UI 1.8 के हिस्से के रूप में उजागर किया जाता है; हालाँकि, इसे jQuery UI के स्वतंत्र रूप से उपयोग किया जा सकता है। JQuery UI के बिना $ .widget का उपयोग कैसे किया जाता है ?
1954 में Airn5475

13

एक सरल दृष्टिकोण नेस्टेड फ़ंक्शन का उपयोग करना है। फिर आप उन्हें ऑब्जेक्ट-ओरिएंटेड फैशन में चेन कर सकते हैं। उदाहरण:

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

और यहाँ है इसे कैसे कॉल करें:

var pluginContainer = $("#divSomeContainer");
pluginContainer.MyPlugin();
pluginContainer.MyPlugin.DoSomething();
pluginContainer.MyPlugin.DoSomething.DoEvenMore();

हालांकि सावधान रहें। जब तक यह बनाया नहीं गया है आप एक नेस्टेड फ़ंक्शन को कॉल नहीं कर सकते। तो आप ऐसा नहीं कर सकते:

var pluginContainer = $("#divSomeContainer");
pluginContainer.MyPlugin();
pluginContainer.MyPlugin.DoSomething.DoEvenMore();
pluginContainer.MyPlugin.DoSomething();

DoEvenMore फ़ंक्शन भी मौजूद नहीं है क्योंकि DoSomething फ़ंक्शन को अभी तक नहीं चलाया गया है जो DoEvenMore फ़ंक्शन बनाने के लिए आवश्यक है। अधिकांश jQuery प्लगइन्स के लिए, आप वास्तव में केवल एक स्तर पर नेस्टेड फ़ंक्शन करने जा रहे हैं और दो नहीं, जैसा कि मैंने यहां दिखाया है।
बस यह सुनिश्चित करें कि जब आप नेस्टेड फ़ंक्शन बनाते हैं, तो आप इन फ़ंक्शन को उनके पैरेंट फ़ंक्शन के आरंभ में किसी अन्य कोड के निष्पादित होने से पहले परिभाषित करते हैं।

अंत में, ध्यान दें कि "यह" सदस्य "_this" नामक एक चर में संग्रहीत है। नेस्टेड फ़ंक्शन के लिए, आपको कॉलिंग क्लाइंट में उदाहरण के लिए संदर्भ की आवश्यकता होने पर "_this" वापस करना चाहिए। आप केवल नेस्टेड फ़ंक्शन में "इसे" वापस नहीं कर सकते क्योंकि यह फ़ंक्शन का संदर्भ लौटाएगा न कि jQuery उदाहरण। एक jQuery संदर्भ लौटना आपको रिटर्न पर आंतरिक jQuery तरीकों को चेन करने की अनुमति देता है।


2
यह बहुत अच्छा है - मुझे केवल आश्चर्य है कि jQuery को .plugin ('मेथड') पैटर्न के नाम से विधियों को कॉल करने के पक्ष में क्यों लगता है?
w00t

6
यह काम नहीं करता। यदि आप दो अलग-अलग कंटेनरों पर प्लग इनवॉइस करते हैं, तो आंतरिक चर ओवरराइड हो जाते हैं (अर्थात _this)
mbrochh

विफल: pluginContainer.yPlugin.DoEvenMore ()। DoSomething () की अनुमति नहीं देता है;
पॉल स्वेटज़

9

मैंने इसे jQuery प्लगिन बॉयलरप्लेट से प्राप्त किया

यह भी jQuery प्लगइन Boilerplate में वर्णित है , आश्चर्य

// 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 श्रृंखलन: $('.first-input').data('pluginName').publicMethod('new value').css('color', red);रिटर्न Cannot read property 'css' of undefined jsfiddle.net/h8v1k2pL/1
एलेक्स जी

@AlexG ने इस उदाहरण को दिया, आप इसे return $elementइस उदाहरण में जोड़ेंगे, आप इसे plugin.foo_public_method = function() {/* Your Code */ return $element;}मेरी मदद करने के लिए @ धन्यवाद में बदल देंगे ... github.com/AndreaLombardo/BootSideMenu/pull/34
CrandellWS

6

बहुत देर से लेकिन शायद यह किसी को एक दिन मदद कर सकता है।

मैं उसी स्थिति में था जैसे, कुछ तरीकों के साथ एक jQuery प्लगइन बनाना, और कुछ लेख और कुछ टायर पढ़ने के बाद मैं एक jQuery प्लगइन बॉयलरप्लेट ( https://github.com/acanimal/jQuery-Plugin-Boilerplate ) बनाता हूं ।

इसके अलावा, मैं टैग ( https://github.com/acanimal/tagger.js ) को प्रबंधित करने के लिए इसे एक प्लगइन के साथ विकसित करता हूं और एक दो ब्लॉग पोस्ट लिखा है, जिसमें एक jQuery प्लगइन ( http: // acuriousanimal) के निर्माण के बारे में बताया गया है । com / ब्लॉग / 2013/01/15 / चीजें-मैं-सीखा-बनाने-एक-jquery-plugin-part-i / )।


संभवतः सबसे अच्छी पोस्ट मैं अभी तक jQuery प्लगइन्स को एक शुरुआत के रूप में बनाने के बारे में आया हूं - धन्यवाद;)
डेक्स डेव

5

तुम कर सकते हो:

(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]();
        }
      }
    });
  };
});

इस तरह से आपके प्लगइन्स ऑब्जेक्ट को आपके तत्व में डेटा मान के रूप में संग्रहीत किया जाता है।

//Initialization without option
$('#myId').yourPlugin();

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

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

3

ट्रिगर्स का उपयोग करने के बारे में क्या? क्या किसी को इनका उपयोग करने में कोई कमी पता है? लाभ यह है कि सभी आंतरिक चर ट्रिगर के माध्यम से सुलभ हैं, और कोड बहुत सरल है।

Jsfiddle पर देखें

उदाहरण उपयोग

<div id="mydiv">This is the message container...</div>

<script>
    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");
</script>

लगाना

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

    });

}

1
सीएफ आपकी टिप्पणी। एकमात्र समस्या जो मुझे यहाँ दिखाई दे रही है, यकीनन घटना प्रणाली का दुरुपयोग है। एक समारोह को लागू करने के लिए विशुद्ध रूप से घटनाओं का उपयोग करना असामान्य है; यह ओवरकिल की तरह लगता है और आसानी से टूट सकता है। आम तौर पर, आप एक प्रकाशित-सदस्यता वाले फैशन में घटनाओं का उपयोग करेंगे, उदाहरण के लिए, एक फ़ंक्शन प्रकाशित करता है कि कुछ स्थिति "ए" हुई है। अन्य संस्थाएं, "ए" में रुचि रखते हैं, इस संदेश को सुनें कि "ए" हुआ है, फिर कुछ करें। आप इसके बजाय इसे "कमांड" के रूप में उपयोग कर रहे हैं, लेकिन लगता है कि केवल एक श्रोता है। आप सावधान रहना चाहते हैं कि श्रोताओं को जोड़ने से आपके शब्दार्थ (अन्य) टूटे नहीं हैं।
tvanfosson

@tvanfosson आपकी टिप्पणी के लिए धन्यवाद। मैं समझता हूं कि यह सामान्य तकनीक नहीं है और यह समस्याओं का कारण बन सकता है यदि कोई गलती से एक घटना श्रोता को जोड़ देता है, लेकिन अगर इसे प्लगइन के नाम पर रखा गया है, तो यह बहुत संभावना नहीं है। मैं किसी भी प्रदर्शन से संबंधित मुद्दों के बारे में नहीं जानता, लेकिन कोड खुद को अन्य समाधानों की तुलना में मेरे लिए बहुत सरल लगता है, लेकिन मुझे कुछ याद आ रहा है।
इस्तवान उज्ज-मेसर्जोस

3

यहां मैं तर्कों के साथ सरल प्लगइन बनाने के लिए सुझाव देना चाहता हूं।

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

$('.cls-title').myFirstPlugin({ text : 'Argument Title' });
<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>
<h1 class="cls-title"></h1>

यहां, हमने डिफ़ॉल्ट ऑब्जेक्ट को जोड़ा है paramsऔर उपयोग करने वाले विकल्पों के डिफ़ॉल्ट मान सेट किए हैंextend फ़ंक्शन । इसलिए, यदि हम रिक्त तर्क पास करते हैं तो यह डिफ़ॉल्ट मान सेट करेगा, अन्यथा यह सेट हो जाएगा।

और पढ़ें: JQuery प्लगइन कैसे बनाएं


हाय गोपाल जोशी, कृपया अगले स्तर jquery प्लगइन निर्माण दें। हम आपके जरूरतमंद जवाब से उम्मीद करते हैं।
साक्षी कार्तिक

नमस्कार @SakthiKarthik, Off cource मैं अपने ब्लॉग में जल्द ही नया ट्यूटोरियल प्रकाशित करूँगा
गोपाल जोशी

1
Hi @SakthiKarthik, आप अगले स्तर के jquery प्लगइन पर नया लेख देखें यहाँ sgeek.org/…
गोपाल जोशी

2

इसको आजमाओ:

$.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

1

यहां मेरा नंगे-हड्डियों का संस्करण है। इससे पहले वाले पोस्ट के समान, आप कॉल करेंगे:

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

सीधे उदाहरण @ का उपयोग करें plugin_MessagePlugin

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

MessagePlugin.js

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

निम्न प्लग इन-संरचना का इस्तेमाल करता jQuery- data()-method आंतरिक प्लगइन-तरीकों / -settings के लिए एक सार्वजनिक इंटरफेस प्रदान करने (जबकि jQuery-chainability संरक्षण):

(function($, window, undefined) { 
  const defaults = {
    elementId   : null,
    shape       : "square",
    color       : "aqua",
    borderWidth : "10px",
    borderColor : "DarkGray"
  };

  $.fn.myPlugin = function(options) {
    // settings, e.g.:  
    var settings = $.extend({}, defaults, 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 += "\n--- shape: '" + settings.shape + "'";
          msg += "\n--- color: '" + settings.color + "'";
          msg += "\n--- 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));

अब आप प्लगइन डेटा या इस सिंटैक्स का उपयोग करके संबंधित तत्व को संशोधित या संशोधित करने के लिए आंतरिक प्लगइन-विधियों को कॉल कर सकते हैं:

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

जब तक आप myPublicPluginMethod()jQuery-chainability के अपने कार्यान्वयन के अंदर से वर्तमान तत्व (यह) वापस करते हैं, तब तक संरक्षित किया जाएगा - इसलिए निम्नलिखित काम करता है:

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

यहां कुछ उदाहरण दिए गए हैं (विवरण के लिए इस फिडेल को चेक करें ):

// 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. ...     

0

यह वास्तव में "अच्छा" तरीके से काम करने के लिए बनाया जा सकता है defineProperty। जहां "नाइस" का अर्थ है बिना ()प्लगइन नेमस्पेस प्राप्त करने के लिए उपयोग करना और न ही स्ट्रिंग द्वारा फ़ंक्शन नाम को पास करना।

संगतता नाइट: defineProperty IE8 और नीचे जैसे प्राचीन ब्राउज़रों में काम नहीं करता है। कैविएट: $.fn.color.blue.apply(foo, args) काम नहीं करेगा, आपको उपयोग करने की आवश्यकता है foo.color.blue.apply(foo, args)

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 लिंक


0

Jquery मानक के अनुसार आप निम्नानुसार प्लगइन बना सकते हैं:

(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.$('your element').loadKeywords('show',{'callback':callbackdata,'keyName':'myKey'}); // show() will be called

संदर्भ: लिंक


0

मुझे लगता है कि यह आपकी मदद कर सकता है ...

(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 हाइलाइट प्लगइन बनाया था। मैंने एक लेख साझा किया था जिसमें मैंने बेसिक से एडवांस के लिए अपना खुद का jQuery प्लगइन बनाने के बारे में चर्चा की थी । मुझे लगता है कि आपको इसकी जांच करनी चाहिए ... http://mycodingtricks.com/jquery/how-to-create-your-own-jquery-plugin/


0

डिबगिंग उद्देश्य के लिए चेतावनी विधि के लिए एक छोटा प्लग-इन निम्नलिखित है। इस कोड को jquery.debug.js फ़ाइल में रखें: JS:

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

HTML:

<html>
   <head>
      <title>The jQuery Example</title>

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

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

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

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

</html>

0

यहाँ है मैं इसे कैसे करते हैं:

(function ( $ ) {

$.fn.gridview = function( options ) {

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


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

    ........

};

}( jQuery ));


var htmlFactory = function(){

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

-2

आपने जो किया वह मूल रूप से jQuery.fn.messagePlugin ऑब्जेक्ट का विस्तार है को नई विधि । जो उपयोगी है लेकिन आपके मामले में नहीं है।

आपको इस तकनीक का उपयोग करना होगा

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") करने का एक तरीका है। messagePlin ()! SaySomething ("hello"); मेरे मित्र उन्होंने लूगिन्स के बारे में लिखना शुरू कर दिया और उन्हें अपने कार्यों की श्रृंखला के साथ कैसे आगे बढ़ाया जाए, यह उनके ब्लॉग की कड़ी है

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.