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 fait

le rappel n'est pas une fonction

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

typeof callback === "function"

Toutes les réponses actuelles utilisent une chaîne littérale, que je préfère ne pas avoir dans mon code si possible - cela ne fonctionne 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 qu'il typeofs'agit d'un opérateur et non d'une fonction, il y a peu de mal à utiliser la syntaxe qui la fait apparaître comme cette dernière.

if (callback && typeof(callback) == "function")

Notez que le rappel (par lui - même) Evalue à falsesi elle est undefined, null, 0, ou false. La comparaison avec nullest trop spécifique.

Ces méthodes pour 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);
}

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 jettera un ReferenceError: possibleFunction is not defined erreur lorsque le moteur tentera de résoudre le symbole possibleFunction (comme mentionné dans les commentaires de la réponse de Jason)

Pour éviter ce comportement, vous ne pouvez transmettre que le nom de la fonction que vous souhaitez vérifier si elle existe. Alors

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

Cela définit une variable comme étant la fonction que vous souhaitez vérifier ou l'objet vide si elle n'est pas définie et évite ainsi les problèmes mentionnés ci-dessus.

Essayer:

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

function something_cool(text, callback){
    alert(text);
    if(typeof(callback)=='function'){ 
        callback(); 
    };
}

if ('function' === typeof callback) ...

typeof(callback) == "function"

Je pourrais faire

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

Je sais qu'il y a une réponse acceptée, mais personne ne l'a suggérée. Je ne sais pas vraiment si cela correspond à la description d'idiomatique, mais cela fonctionne dans tous les cas.

Dans les moteurs JavaScript plus récents, a finallypeut être utilisé à la place.

Essaye ça:

callback instanceof Function

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

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

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

Essayer:

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

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

_.isFunction(callback);

Je cherchais comment vérifier si une fonction jQuery était définie et je ne l'ai pas trouvée facilement.

Peut-être en aurais-je besoin;)

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

Si callback()vous n'appelez pas juste une fois dans une fonction, vous pouvez initialiser l'argument à 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.

Pour les fonctions globales, vous pouvez utiliser celle-ci au lieu de evalsuggérée 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 également l'utiliser global.f instanceof Function, mais afaik. la valeur de Functionsera différente dans différents cadres, donc cela ne fonctionnera correctement qu'avec une seule application de cadre. C'est pourquoi nous utilisons habituellement à la typeofplace. Notez que dans certains environnements, il peut y avoir des anomalies avec typeof f, par exemple par MSIE 6-8 certaines des fonctions par exemplealert avaient le type "objet".

Par fonctions locales, vous pouvez utiliser celle de la réponse acceptée. Vous pouvez également tester 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, donc je ne sais pas quel était le problème:

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

Remarque: j'utiliserais callback !== undefinedau lieu de callback != null, mais ils font presque la même chose.

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

ici meilleure pratique

tu as une 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');

Si vous souhaitez redéfinir des fonctions, il est préférable d'utiliser des variables de fonction, qui sont définies dans leur ordre d'occurrence, car les fonctions sont définies globalement, peu importe où elles se produisent.

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

Cela a fonctionné pour moi

if( cb && typeof( eval( cb ) ) === "function" ){
    eval( cb + "()" );
}

Solution en une ligne:

function something_cool(text, callback){
    callback && callback();
}