Plug-in jQuery: Adicionando funcionalidade de retorno de chamada

Estou tentando dar ao meu plug-in a funcionalidade de retorno de chamada e gostaria que ele operasse de uma maneira um tanto tradicional:

myPlugin({options}, function() {
    /* code to execute */
});

ou

myPlugin({options}, anotherFunction());

Como faço para lidar com esse parâmetro no código? É tratado como uma entidade completa? Tenho quase certeza de que sei onde colocaria o código executório, mas como faço para que o código seja executado? Não consigo encontrar muita literatura sobre o assunto.

Basta executar o callback no plugin:

$.fn.myPlugin = function(options, callback) {
    if (typeof callback == 'function') { // make sure the callback is a function
        callback.call(this); // brings the scope to the callback
    }
};

Você também pode ter o retorno de chamada no objeto de opções:

$.fn.myPlugin = function() {

    // extend the options from pre-defined values:
    var options = $.extend({
        callback: function() {}
    }, arguments[0] || {});

    // call the callback and apply the scope:
    options.callback.call(this);

};

Use-o assim:

$('.elem').myPlugin({
    callback: function() {
        // some action
    }
});

Não sei se entendi sua pergunta corretamente. Mas para a segunda versão: isso ligaria anotherFunctionimediatamente.

Basicamente, seu plug-in deve ser algum tipo de função semelhante a esta:

var myPlugin = function(options, callback) {
    //do something with options here
    //call callback
    if(callback) callback();
} 

Você deve fornecer um objeto de função como retorno de chamada, portanto function(){...}ou anotherFunction(sem ()).

Trazendo de volta uma explosão do passado.

É importante notar que se você tiver dois argumentos passados, por exemplo:

$.fn.plugin = function(options, callback) { ... };

Em seguida, você chama o plug-in sem o argumento de opções, mas com um retorno de chamada, então você terá problemas:

$(selector).plugin(function() {...});

Eu uso isso para torná-lo um pouco mais flexível:

if($.isFunction(options)) { callback = options }

Eu acho que isso pode te ajudar

// Create closure.
(function( $ ) {
  
   // This is the easiest way to have default options.
 
        var settings = $.extend({
            // These are the defaults.
 
            onready: function(){},
 
            //Rest of the Settings goes here...
        }, options );
 
    // Plugin definition.
    $.fn.hilight = function( options ) {
 
        //Here's the Callback
        settings.onready.call(this);
 
        //Your plugin code goes Here
    };
  
// End of closure.
  
})( jQuery );

Eu compartilhei um artigo sobre como criar seu próprio plug-in jQuery. Acho que você deveria verificar se http://mycodingtricks.com/jquery/how-to-create-your-own-jquery-plugin/

Altere a função do plugin para usar um segundo parâmetro. Supondo que o usuário passe uma função, esse parâmetro pode ser tratado como uma função regular.
Observe que você também pode tornar o retorno de chamada uma propriedade do parâmetro options.

Por exemplo:

$.fn.myPlugin = function(options, callback) {
    ...

    if(callback)        //If the caller supplied a callback
        callback(someParam);

    ...
});

Um exemplo um pouco tarde, mas pode ser útil. O uso de argumentos pode criar a mesma funcionalidade.

$.fn.myPlugin = function() {
    var el = $(this[0]);
    var args = arguments[0] || {};
    var callBack = arguments[1];
    .....
    if (typeof callback == 'function') {
        callback.call(this);
    }
}