it-swarm-eu.dev

Feststellen, ob eine JavaScript-Funktion definiert ist

Wie erkennen Sie, ob eine Funktion in JavaScript definiert ist?

Ich möchte so etwas machen

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.

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

Alle aktuellen Antworten verwenden eine Literalzeichenfolge, die ich nach Möglichkeit lieber nicht in meinem Code habe.

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

Persönlich versuche ich, die Anzahl der in meinem Code herumhängenden Zeichenfolgen zu verringern ...


Auch wenn mir bewusst ist, dass typeof ein Operator und keine Funktion ist, kann die Syntax nur wenig schaden, wenn sie als letztere angezeigt wird.

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

Beachten Sie, dass Rückruf (für sich) zu false ausgewertet wird, wenn es sich um undefined, null, 0 Oder false handelt. Der Vergleich mit null ist zu spezifisch.

15

Diese Methoden zum Ermitteln, ob eine Funktion implementiert ist, schlagen auch fehl, wenn keine Variable definiert ist. Daher verwenden wir eine leistungsstärkere Methode, die das Empfangen einer Zeichenfolge unterstützt:

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

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

Neu bei 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 possibleFunction nicht definiert ist.

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

Dies wird einen ReferenceError: possibleFunction is not defined - Fehler auslösen, wenn die Engine versucht, das Symbol possibleFunction 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, deren Existenz Sie überprüfen möchten. Damit

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

Dies setzt eine Variable entweder als die zu überprüfende Funktion oder als leeres Objekt, wenn es nicht definiert ist, und vermeidet so die oben genannten Probleme.

6
NectarSoft

Versuchen:

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

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 der Beschreibung von Idiomatik entspricht, aber es funktioniert in allen Fällen.

In neueren JavaScript-Engines kann stattdessen ein finally verwendet werden.

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

Versuche dies:

callback instanceof Function
2
eWolf

Versuchen:

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

Wenn Sie sich die Quelle der Bibliothek @Venkat Sudheer Reddy Aedama ansehen, die erwähnt wurde, underscorejs, können Sie dies sehen:

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

Dies ist nur mein TIPP, TIPP Antwort:>

2
VentyCZ

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

_.isFunction(callback);

Ich suchte nach einer Methode, um zu überprüfen, ob eine jQuery-Funktion definiert wurde, und fand sie nicht leicht.

Vielleicht könnte es brauchen;)

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

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

Beispiel für das Erstellen einer neuen Funktion, die eine frühere Funktion mit demselben Namen aufruft:

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

Für globale Funktionen können Sie diese anstelle von eval verwenden, die in einer der Antworten vorgeschlagen wurden.

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

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

Sie können auch global.f instanceof Function Verwenden, aber afaik. Der Wert von Function ist in verschiedenen Frames unterschiedlich, sodass er nur mit einer einzelnen Frame-Anwendung ordnungsgemäß funktioniert. Deshalb verwenden wir normalerweise typeof. Beachten Sie, dass in einigen Umgebungen auch Anomalien mit typeof f Auftreten können, z. Nach MSIE 6-8 hatten einige der Funktionen, zum Beispiel alert, den Typ "Objekt".

Durch lokale Funktionen können Sie die in der angenommenen 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");

Zur Beantwortung der Frage funktioniert der Beispielcode in den neuesten Browsern fehlerfrei, 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 !== undefined Anstelle von callback != null Verwenden, aber sie tun fast dasselbe.

0
inf3rno

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

hier Best Practice

du hast 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');
0
TexWiller

Wenn Sie callback() nicht nur einmal in einer Funktion 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 undefiniert ist.

0
Nick Tsai