Autoriser la fonction javascript à accepter n'importe quel nombre d'arguments

Question

Je souhaite que la fonction ci-dessous soit plus flexible et accepte plusieurs rappels à d'autres fonctions si elles sont définies dans les arguments.

$(function() { 
    function icisDashBox(colorElem, thisWidth, thisHeight, completeCallBack) { 
     $(colorElem).colorbox({ 
     transition: 'none', 
     innerWidth: thisWidth, 
     innerHeight: thisHeight, 
     opacity: '0.5', 
     onOpen: function() { 

     }, 
     onLoad: function() { 

     }, 
     onComplete:function() { 
      $('#cboxLoadedContent').wrap('<div id="icis_dialog_msg" />'); 

      completeCallBack(); 

     }, 
     onCleanup: function() { 

     },  
     onClosed: function() { 
      $('#cboxLoadedContent').unwrap(); 
     } 
    }); 
} 

icisDashBox('.example9', '500', '500', completeFunction); 

function completeFunction() { 

    var fooClass = $("#colorbox").addClass("FOO"); 

    var barClass = $("#colorbox").addClass("BAR"); 

    var ajaxCnt = $.ajax({ 
     type: "GET", 
     url: "http://www.payso.me.uk", 
     dataType: "html", 
     success: function(data) { 
      $("#colorbox").addClass("AJAX SUCCESS"); 
     } 
    }); 

    return { 
     x : fooClass, 
     y : barClass, 
     z : ajaxCnt       
    }; 
} 

Ainsi, dans un monde idéal ma fonction ressemblerait à ceci sans déclarer explicitement les arguments:

function icisDashBox() { function code here } 

Est-ce possible? Aussi, si les arguments ne sont pas définis, comment puis-je gérer cela? Par exemple, si un appel à la fonction a plusieurs callbacks définis et qu'un autre n'en a qu'un seul, il y a un moyen de gérer le manque de présence des callbacks.

Cheers,

:)

Answer 1

Vous pouvez utiliser le mot-clé arguments qui est un tableau des arguments passés, comme ceci:

function myFunc() { 
    if(arguments.length > 0)  //be sure to check if there are any... 
    var arg1 = arguments[0]; 
} 

Cependant, une bien meilleure approche consiste à accepter un objet, par exemple:

function myFunc(settings) { 
    settings = settings || {}; //in case it was called as just: myfunc() 
    var something = settings.something || "default value"; 
} 

Vous appelleriez comme ceci:

myFunc({ something: "value", somethingElse: "otherValue" }); 

Cette approche vous permet d'accepter un certain nombre d'arguments aussi bien, mais ont également tout optionnel, sans un tas d'appels de type myFunc(null, null, null, "value") pour fournir uniquement le paramètre que vous voulez, plus ils sont nommés en faisant beaucoup plus plus maintenable IMO. Here's an edited version of the plugin to demonstrate this.

Answer 2

boucle Un peu plus de l'objet arguments: https://developer.mozilla.org/en/JavaScript/Reference/Functions_and_function_scope/Arguments

Answer 3

Utilisez arguments variables.

function TestMe() 
{ 
    var args = arguments; 

    for (var a in args) 
    { 
    alert(args[a]); 
    } 
} 

Vous pouvez maintenant transmettre un certain nombre d'arguments à la fonction TestMe:

TestMe(1); 
TestMe(1,2,3); 
TestMe(1,2,3,4,5,6); 
TestMe.apply(this, [1,2,3,4,5]); 

etc.

Answer 4

Oui cela est possible, voici un exemple:

function myfunct() 
{ 

    var arguments = myfunct.arguments; 

    for (var i = 0; i < arguments.length; i++) 
     { 

       alert("Argument " + i + " value = " + arguments[i]); 

      } 

} 

Vous pouvez appeler cette fonction par un certain nombre d'arguments:

myfunct("foo"); 

myfunct("foo","bar"); 

Answer 5

En plus ces derniers temps, vous pouvez maintenant utiliser ou la propagation et repos opérateurs comme détaillé ici - Pass unknown number of arguments into javascript function