Jak stwierdzić, czy zdefiniowano funkcję JavaScript

Jak rozpoznać, czy funkcja w JavaScript jest zdefiniowana?

Chcę zrobić coś takiego

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

Ale to mnie rozumie

oddzwanianie nie jest funkcją

błąd, gdy wywołanie zwrotne nie jest zdefiniowane.

typeof callback === "function"

Wszystkie obecne odpowiedzi używają dosłownego ciągu, którego wolę nie mieć w kodzie, jeśli to możliwe - to nie (i zapewnia cenne znaczenie semantyczne, aby uruchomić):

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

Osobiście staram się zmniejszyć liczbę ciągów znaków w moim kodzie ...

Ponadto, chociaż zdaję sobie sprawę, że typeofjest to operator, a nie funkcja, korzystanie ze składni, która sprawia, że ​​wygląda ona na tę drugą, jest niewielkie.

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

Należy zauważyć, że wywołania zwrotnego (przez siebie) ma wartość false, jeśli jest undefined, null, 0, lub false. Porównywanie do nulljest zbyt specyficzne.

Te metody określania, czy funkcja jest zaimplementowana, również zawodzą, jeśli zmienna nie jest zdefiniowana, dlatego używamy czegoś mocniejszego, który obsługuje otrzymywanie łańcucha:

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

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

Nowość w JavaScript Nie jestem pewien, czy zachowanie się zmieniło, ale rozwiązanie podane przez Jasona Buntinga (6 lat temu) nie będzie działać, jeśli to możliwe Funkcja nie jest zdefiniowana.

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

Spowoduje to wygenerowanie ReferenceError: possibleFunction is not definedbłędu, gdy silnik spróbuje rozwiązać możliwy symbol Funkcja (jak wspomniano w komentarzach do odpowiedzi Jasona)

Aby uniknąć tego zachowania, możesz przekazać tylko nazwę funkcji, którą chcesz sprawdzić, czy istnieje. Więc

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

Ustawia zmienną na funkcję, którą chcesz sprawdzić, lub pusty obiekt, jeśli nie jest zdefiniowany, dzięki czemu unika się wyżej wymienionych problemów.

Próbować:

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

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

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

typeof(callback) == "function"

mogę zrobić

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

Wiem, że istnieje akceptowana odpowiedź, ale nikt tego nie sugerował. Nie jestem do końca pewien, czy pasuje to do opisu idiomatic, ale działa we wszystkich przypadkach.

W nowszych silnikach JavaScript finallymożna zamiast tego użyć.

Spróbuj tego:

callback instanceof Function

Jeśli spojrzysz na źródło biblioteki @Venkat Sudheer Reddy Aedama wspomniane, underscorejs, możesz zobaczyć:

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

To tylko moja WSKAZÓWKA, WSKAZÓWKA odpowiedź:>

Próbować:

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

Jeśli używasz http://underscorejs.org , masz: http://underscorejs.org/#isFunction

_.isFunction(callback);

Szukałem, jak sprawdzić, czy funkcja jQuery została zdefiniowana i nie znalazłem jej łatwo.

Być może może tego potrzebować;)

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

Jeśli callback()wywołujesz nie tylko raz w funkcji, możesz zainicjować argument do ponownego użycia:

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

Na przykład:

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

    alert(text);

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

Ograniczeniem jest to, że zawsze wykona argument wywołania zwrotnego, chociaż jest niezdefiniowany.

W przypadku funkcji globalnych możesz użyć tej zamiast evalsugerowanej w jednej z odpowiedzi.

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

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

Możesz także użyć global.f instanceof Function, ale afaik. wartość Functionbędzie różna w różnych ramkach, więc będzie działać poprawnie tylko z aplikacją na pojedynczą ramkę. Dlatego zwykle używamy typeofzamiast tego. Zauważ, że w niektórych środowiskach mogą również występować anomalie typeof f, np. Przez MSIE 6-8 niektóre funkcje na przykładalert miały typ „obiektowy”.

Za pomocą funkcji lokalnych możesz użyć tej z zaakceptowanej odpowiedzi. Możesz sprawdzić, czy funkcja jest lokalna czy globalna.

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

Aby odpowiedzieć na pytanie, przykładowy kod działa dla mnie bez błędów w najnowszych przeglądarkach, więc nie jestem pewien, z czym był problem:

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

Uwaga: użyłbym callback !== undefinedzamiast callback != null, ale robią prawie to samo.

Większość, jeśli nie wszystkie poprzednie odpowiedzi, wywołują funkcję uboczną

tutaj najlepsza praktyka

masz funkcję

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

Jeśli chcesz przedefiniować funkcje, najlepiej użyć zmiennych funkcyjnych, które są zdefiniowane w kolejności ich występowania, ponieważ funkcje są definiowane globalnie, bez względu na to, gdzie występują.

Przykład tworzenia nowej funkcji, która wywołuje poprzednią funkcję o tej samej nazwie:

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

To zadziałało dla mnie

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

Rozwiązanie jednowierszowe:

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