Wie erkennt man, ob eine JavaScript-Funktion definiert ist?

Woran erkennt man, ob eine Funktion in JavaScript definiert ist?

Ich möchte so etwas tun

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

Aber es bringt mir ein

Rückruf ist keine Funktion

Fehler, wenn Rückruf nicht definiert ist.

typeof callback === "function"

Alle aktuellen Antworten verwenden eine Literalzeichenfolge, die ich nach Möglichkeit lieber nicht in meinem Code habe - dies ist nicht der Fall (und bietet zum Booten eine wertvolle semantische Bedeutung):

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

Persönlich versuche ich, die Anzahl der Zeichenfolgen in meinem Code zu reduzieren ...

Auch wenn mir bewusst ist, dass typeofes sich um einen Operator und nicht um eine Funktion handelt, kann die Verwendung der Syntax, die sie als letztere erscheinen lässt, wenig schaden.

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

Beachten Sie, dass Rückruf (von selbst) auswertet , um , falsewenn es undefined, null, 0, oder false. Der Vergleich mit nullist zu spezifisch.

Diese Methoden, um festzustellen, ob eine Funktion implementiert ist, schlagen auch fehl, wenn keine Variable definiert ist. Daher verwenden wir etwas Stärkeres, das das Empfangen einer Zeichenfolge unterstützt:

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

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

Neu in JavaScript Ich bin nicht sicher, ob sich das Verhalten geändert hat, aber die von Jason Bunting (vor 6 Jahren) gegebene Lösung funktioniert nicht, wenn möglich. Die Funktion ist nicht definiert.

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

Dies wird einen ReferenceError: possibleFunction is not definedFehler auslösen, wenn die Engine versucht, das Symbol "mögliche Funktion" aufzulösen (wie in den Kommentaren zu Jasons Antwort erwähnt).

Um dieses Verhalten zu vermeiden, können Sie nur den Namen der Funktion übergeben, die Sie überprüfen möchten, ob sie vorhanden ist. Damit

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

Dadurch wird eine Variable entweder als die zu überprüfende Funktion oder als leeres Objekt festgelegt, wenn sie nicht definiert ist, und so werden die oben genannten Probleme vermieden.

Versuchen:

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

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

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

typeof(callback) == "function"

Ich könnte tun

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

Ich weiß, dass es eine akzeptierte Antwort gibt, aber niemand hat dies vorgeschlagen. Ich bin mir nicht sicher, ob dies zur Beschreibung von idiomatisch passt, aber es funktioniert in allen Fällen.

In neueren JavaScript-Engines finallykann stattdessen a verwendet werden.

Versuche dies:

callback instanceof Function

Wenn Sie sich die Quelle der Bibliothek @Venkat Sudheer Reddy Aedama ansehen, die unterstrichen ist, können Sie Folgendes sehen:

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

Dies ist nur mein TIPP, TIPP Antwort:>

Versuchen:

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

Wenn Sie http://underscorejs.org verwenden , haben Sie: http://underscorejs.org/#isFunction

_.isFunction(callback);

Ich suchte nach einer Möglichkeit, zu überprüfen, ob eine jQuery-Funktion definiert wurde, und fand sie nicht einfach.

Vielleicht braucht es das;)

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

Wenn callback()Sie eine Funktion nicht nur einmal aufrufen, können Sie das Argument für die Wiederverwendung initialisieren:

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

Zum Beispiel:

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

    alert(text);

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

Die Einschränkung besteht darin, dass das Rückrufargument immer ausgeführt wird, obwohl es nicht definiert ist.

Für globale Funktionen können Sie diese verwenden, anstatt evalsie in einer der Antworten vorzuschlagen.

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

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

Sie können auch verwenden global.f instanceof Function, aber afaik. Der Wert von Functionist in verschiedenen Frames unterschiedlich, sodass er nur mit einer einzelnen Frame-Anwendung ordnungsgemäß funktioniert. Deshalb verwenden wir normalerweise typeofstattdessen. Beachten Sie, dass in einigen Umgebungen auch Anomalien auftreten können typeof f, z. B. bei MSIE 6-8. Einige der Funktionen hatten beispielsweise alertden Typ "Objekt".

Durch lokale Funktionen können Sie die in der akzeptierten Antwort verwenden. Sie können testen, ob die Funktion auch lokal oder global ist.

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

Um die Frage zu beantworten, funktioniert der Beispielcode in den neuesten Browsern fehlerfrei für mich, daher bin ich mir nicht sicher, wo das Problem lag:

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

Hinweis: Ich würde callback !== undefinedanstelle von verwenden callback != null, aber sie tun fast das gleiche.

Die meisten, wenn nicht alle vorherigen Antworten haben Nebenwirkungen, um die Funktion aufzurufen

hier Best Practice

Sie haben Funktion

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');

Wenn Sie Funktionen neu definieren möchten, verwenden Sie am besten Funktionsvariablen, die in der Reihenfolge ihres Auftretens definiert sind, da Funktionen global definiert sind, unabhängig davon, wo sie auftreten.

Beispiel für die Erstellung einer neuen Funktion, die eine vorherige gleichnamige Funktion aufruft:

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

Das hat bei mir funktioniert

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

Einzeilige Lösung:

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