web-dev-qa-db-fra.com

Comment savoir si une fonction JavaScript est définie

Comment savoir si une fonction en JavaScript est définie?

Je veux faire quelque chose comme ça

function something_cool(text, callback) {
    alert(text);
    if( callback != null ) callback();
}

Mais ça me procure un

le rappel n'est pas une fonction

erreur lorsque le rappel n'est pas défini.

javascriptreflection
281
Aaron Lee
typeof callback === "function"
438
Tom Ritter

Toutes les réponses actuelles utilisent une chaîne littérale, que je préfère ne pas avoir dans mon code si possible - ce n'est pas (et fournit une signification sémantique précieuse, pour démarrer):

function isFunction(possibleFunction) {
  return typeof(possibleFunction) === typeof(Function);
}

Personnellement, j'essaie de réduire le nombre de chaînes qui traînent dans mon code ...

De plus, bien que je sache que typeof est un opérateur et non une fonction, il y a peu de mal à utiliser la syntaxe qui la fait apparaître comme cette dernière.

232
Jason Bunting
if (callback && typeof(callback) == "function")

Notez que le rappel (par lui-même) est évalué à false s'il est undefined, null, 0 ou false. Comparer à null est trop spécifique.

15
Robin like the bird

Les méthodes permettant de savoir si une fonction est implémentée échouent également si la variable n'est pas définie. Nous utilisons donc quelque chose de plus puissant qui prend en charge la réception d'une chaîne:

function isFunctionDefined(functionName) {
    if(eval("typeof(" + functionName + ") == typeof(Function)")) {
        return true;
    }
}

if (isFunctionDefined('myFunction')) {
    myFunction(foo);
}
8
patriciorocca

Nouveau sur JavaScript, je ne sais pas si le comportement a changé, mais la solution proposée par Jason Bunting (il y a 6 ans) ne fonctionnera pas si possible. La fonction n'est pas définie.

function isFunction(possibleFunction) {
  return (typeof(possibleFunction) == typeof(Function));
}

Cela provoquera une erreur ReferenceError: possibleFunction is not defined alors que le moteur tentera de résoudre le symbole possibleFunction (comme indiqué dans les commentaires relatifs à la réponse de Jason).

Pour éviter ce problème, vous ne pouvez que transmettre le nom de la fonction à vérifier, le cas échéant. Alors

var possibleFunction = possibleFunction || {};
if (!isFunction(possibleFunction)) return false;

Cela définit une variable comme étant la fonction à vérifier ou l’objet vide s’il n’est pas défini, ce qui évite les problèmes mentionnés ci-dessus.

6
NectarSoft

Essayer:

if (typeof(callback) == 'function')
5
bdukes

Je pourrais faire

try{
    callback();
}catch(e){};

Je sais que la réponse est acceptée, mais personne ne l'a suggéré. Je ne suis pas vraiment sûr que cela corresponde à la description de idiomatique, mais cela fonctionne dans tous les cas.

Dans les nouveaux moteurs JavaScript, un finally peut être utilisé à la place.

4
Quentin Engles
if ('function' === typeof callback) ...
4
Andrew Hedges
function something_cool(text, callback){
    alert(text);
    if(typeof(callback)=='function'){ 
        callback(); 
    };
}
3
ConroyP

Essaye ça:

callback instanceof Function
2
eWolf

Essayer:

if (!(typeof(callback)=='undefined')) {...}
2
Brian

Si vous regardez le source de la bibliothèque @Venkat Sudheer Reddy Aedama mentionné, underscorejs, vous pouvez voir ceci:

_.isFunction = function(obj) {
  return typeof obj == 'function' || false;
};

Ceci est juste mon indice, astuce réponse:>

2
VentyCZ

Si vous utilisez http://underscorejs.org , vous avez: http://underscorejs.org/#isFunction

_.isFunction(callback);
1
Venkat Sudheer Reddy Aedama

Je cherchais comment vérifier si une fonction jQuery était définie et je ne la trouvais pas facilement.

Peut-être en aurait-il besoin;)

if(typeof jQuery.fn.datepicker !== "undefined")
1
miguelmpn

Si vous souhaitez redéfinir les fonctions, utilisez de préférence les variables de fonction, définies dans leur ordre d'occurrence, car les fonctions sont définies globalement, quel que soit leur emplacement.

Exemple de création d'une nouvelle fonction qui appelle une fonction précédente du même nom:

A=function() {...} // first definition
...
if (typeof A==='function')
   oldA=A;
A=function() {...oldA()...} // new definition
0
David Spector

Pour les fonctions globales, vous pouvez utiliser celle-ci au lieu de eval suggéré dans l'une des réponses.

var global = (function (){
    return this;
})();

if (typeof(global.f) != "function")
    global.f = function f1_shim (){
        // commonly used by polyfill libs
    };

Vous pouvez aussi utiliser global.f instanceof Function, mais autant que je sache. la valeur de Function sera différente dans différentes images, de sorte qu'elle ne fonctionnera correctement qu'avec une application à une seule image. C'est pourquoi nous utilisons généralement typeof à la place. Notez que dans certains environnements, il peut également y avoir des anomalies avec typeof f, par exemple. par MSIE 6-8 certaines des fonctions par exemple alert avaient le type "objet".

Par fonctions locales, vous pouvez utiliser celui de la réponse acceptée. Vous pouvez également vérifier si la fonction est locale ou globale.

if (typeof(f) == "function")
    if (global.f === f)
        console.log("f is a global function");
    else
        console.log("f is a local function");

Pour répondre à la question, l'exemple de code fonctionne pour moi sans erreur dans les derniers navigateurs. Je ne sais donc pas quel était le problème.

function something_cool(text, callback) {
    alert(text);
    if( callback != null ) callback();
}

Remarque: je voudrais utiliser callback !== undefined au lieu de callback != null, mais ils font presque la même chose.

0
inf3rno

La plupart sinon toutes les réponses précédentes ont des effets secondaires pour invoquer la fonction

ici la meilleure pratique

vous avez fonction

function myFunction() {
        var x=1;
    }
//direct way
        if( (typeof window.myFunction)=='function')
            alert('myFunction is function')
        else
            alert('myFunction is not defined');
//byString
        var strFunctionName='myFunction'
        if( (typeof window[strFunctionName])=='function')
            alert(s+' is function');
        else
            alert(s+' is not defined');
0
TexWiller

Si le callback() que vous appelez pas seulement une fois dans une fonction, vous pouvez initialiser l'argument pour le réutiliser:

callback = (typeof callback === "function") ? callback : function(){};

Par exemple:

function something_cool(text, callback) {
    // Initialize arguments
    callback = (typeof callback === "function") ? callback : function(){};

    alert(text);

    if (text==='waitAnotherAJAX') {
        anotherAJAX(callback);
    } else {
        callback();
    }
}

La limitation est qu'il exécutera toujours l'argument de rappel même s'il n'est pas défini.

0
Nick Tsai