Шаблон разработки плагина jQuery (обычная практика?) для работы с частными функциями

Прежде всего: если вы хотите вызвать что-то вроде this.fill('red');, где this является экземпляром jQuery, вам необходимо расширить прототип jQuery и сделать fill() "общедоступным". jQuery предоставляет рекомендации по расширению своего прототипа с помощью так называемых «подключаемых модулей», которые могут быть добавлены с помощью $.fn.fill, что аналогично jQuery.prototype.fill.

В обратных вызовах jQuery this часто является ссылкой на элемент HTML, и вы не можете добавлять к ним прототипы (пока). Это одна из причин, по которой jQuery обертывает элементы и возвращает экземпляры jQuery, которые можно легко расширить.

Используя синтаксис (function(){})();, вы можете создавать и выполнять «частный» javascript на лету, и все это исчезает, когда это будет сделано. Используя эту технику, вы можете создать свой собственный синтаксис, подобный jQuery, который превращает jQuery в ваш собственный частный объект с цепочкой.

(function(){
    var P = function(elem) {
        return new Private(elem);
    };
    var Private = function(elem) {
        this.elem = jQuery(elem);
    }
    Private.prototype = {
        elem: null,
        fill: function(col) {
            this.elem.css('background',col);
            return this;
        },
        color: function(col) {
            this.elem.css('color', col);
            return this;
        }
    }

    $.fn.myplugin = function() {
        P(this).fill('red');
    };
    $.fn.myotherplugin = function() {
        P(this).fill('yellow').color('green');
    };

})();

$('.foo').myplugin();
$('.bar').myotherplugin();

console.log(typeof P === 'undefined') // should print 'true'

Таким образом, P обозначает ваш собственный набор «частных» функций. Они не будут доступны где-либо еще в коде или в пространстве имен jQuery, если вы не прикрепите их куда-нибудь. Вы можете добавить столько методов, сколько захотите, в частный объект, и пока вы возвращаете this, вы также можете связать их в стиле jQuery, как я сделал в примере.

Как насчет (в рамках плагина):

var fill = function ()
{
    (function (color) 
    {
        this.css ('backgrorund-color', color);
        //.. your stuff here ...
    }).apply (this, arguments);
}

$.fn.myplugin = function ()
{
    fill ('green');
}

Таким образом, fill сохранит контекст jQuery, в котором вы находитесь, и останется приватным для вашего плагина.

Изменено: приведенное выше неверно относительно scoping, попробуйте вместо этого следующее:

var fill = function (color)
{
    if (!$this) return; // break if not within correct context

    $this.css ('backgrorund-color', color);
    //.. your stuff here ...
}

$.fn.myplugin = function ()
{
    var $this = $(this); // local ref to current context
    fill ('green');
}

Вы можете посмотреть, как реализована jQuery UI Widget Factory.

Базовый подход такой:

(function($){
    $.fn.myplugin = function(method)
    {
        if (mp[method]) // map $('foo').myplugin('bar', 'baz') to mp.bar('baz')
        {
            return mp[method].apply(this, Array.prototype.slice.call(arguments, 1));
        }
        else if (typeof method === 'object' || ! method)
        {
            return mp.init.apply(this, arguments); // if called without arguments, init
        }
        else
        {
            $.error('Method ' +  method + ' does not exist on $.myplugin');
        }
    };

    // private methods, internally accessible via this.foo, this.bar
    var foo = function() { … };
    var bar = function() { … };

    var private = { // alternative approach to private methods, accessible via this.private.foo
        foo : function() { … },
        bar : function() { … }
    }

    var mp = { // public methods, externally accessible via $.myplugin('foo', 'bar')
        init : function( options )
        {
            return this.each(function()
            {
                // do init stuff
            }
        },
        foo : function() { … },
        bar : function() { … }
    };
})(jQuery);

К сожалению, «частные» методы (или любое свойство в этом отношении) нельзя никогда вызывать с префиксом this в javascript. Все, что называется this.myFunc(myArgs), должно быть общедоступным.

А «частные» методы можно вызывать только из той области, в которой они были определены.

Ваше оригинальное решение - единственное, что будет работать. Да, это боль, которую нужно передать this, но многословия не больше, чем было бы, если бы ваш невозможный запрос был возможен:

this.fill('green');
//or
fill(this,'green');

Как видите, оба они занимают одинаковое количество символов в вашем коде.

Извините, но вы застряли в этом как на решении, если только вы не хотите создать новое пространство имен и сделать его не закрытым, что просто добавит к количеству кода, который вам нужен напишите, то есть то, что вы косвенно назвали "не подвергается прямому воздействию":

this.myplugin.fill('green');

... более многословен, таким образом, как бы поражает цель.

Javascript не похож на другие языки, в нем нет "частных" членов как таковых, только члены, доступные в рамках замыканий, которые иногда могут использоваться аналогично закрытым членам, но это скорее "обходной путь", а не " настоящие "частные участники", которых вы ищете.

С этим может быть трудно смириться (я часто борюсь), но не пытайтесь превратить javascript в то, что вы понимаете из других языков, принимайте его таким, какой он есть ...