Bir JavaScript işlevinin tanımlanıp tanımlanmadığı nasıl anlaşılır

JavaScript'te bir işlevin tanımlanıp tanımlanmadığını nasıl anlarsınız?

Böyle bir şey yapmak istiyorum

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

Ama bu bana

geri arama bir işlev değildir

geri arama tanımlanmadığında hata.

typeof callback === "function"

Geçerli yanıtların tümü, mümkünse kodumda olmamayı tercih ettiğim değişmez bir dize kullanır - bu yoktur (ve önyükleme yapmak için değerli anlamsal anlam sağlar):

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

Şahsen, kodumda takılan dizelerin sayısını azaltmaya çalışıyorum ...

Ayrıca, typeofbir işlevin değil, bir işleç olduğunun farkında olduğum halde, sözdizimini kullanmanın, ikincisi olarak görünmesini sağlayan çok az zarar vardır.

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

Değerlendirir için (tek başına) olup bir geri arama Not falsebu ise undefined, null, 0ya da false. İle karşılaştırmak nullaşırı belirgin.

Bir işlevin uygulanıp uygulanmadığını söylemek için kullanılan yöntemler, değişken tanımlanmadıysa da başarısız olur, böylece bir dize almayı destekleyen daha güçlü bir şey kullanırız:

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

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

JavaScript'te yeni Davranışın değişip değişmediğinden emin değilim, ancak Jason Bunting (6 yıl önce) tarafından verilen çözüm mümkünse çalışmaz.

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

Bu bir ReferenceError: possibleFunction is not defined , motor olası sembolü çözmeye çalıştığında hata (yorumlarda Jason'ın cevabına belirtildiği gibi)

Bu davranışı önlemek için yalnızca var olup olmadığını kontrol etmek istediğiniz işlevin adını iletebilirsiniz. Yani

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

Bu, bir değişkeni kontrol etmek istediğiniz işlev veya tanımlanmamışsa boş nesne olarak ayarlar ve bu nedenle yukarıda belirtilen sorunları önler.

Deneyin:

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

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

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

typeof(callback) == "function"

yapabilirim

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

Kabul edilmiş bir cevap olduğunu biliyorum, ama kimse bunu önermedi. Bunun deyimsel açıklamaya uyup uymadığından emin değilim, ancak tüm durumlar için çalışıyor.

Daha yeni JavaScript motorlarında finallybunun yerine a kullanılabilir.

Bunu dene:

callback instanceof Function

@Venkat Sudheer Reddy Aedama'nın bahsettiği kütüphanenin kaynağına bakarsanız , underscorejs, bunu görebilirsiniz:

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

Bu sadece benim İPUCU, İPUCU cevabım:

Deneyin:

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

Eğer kullanırsanız http://underscorejs.org , sahip: http://underscorejs.org/#isFunction

_.isFunction(callback);

Nasıl bir jQuery işlevi tanımlanmış olup olmadığını kontrol etmek için bakıyordu ve ben kolayca bulamadık.

Belki de buna ihtiyaç duyabilir;)

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

Eğer callback()bir fonksiyonun içinde sadece bir kez değil çağırarak, sen yeniden kullanım için argüman ilklendireceğiniz:

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

Örneğin:

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

    alert(text);

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

Sınırlama, tanımlanmamış olmasına rağmen her zaman geri çağrı bağımsız değişkenini yürütmesidir.

Global işlevler için eval, cevaplardan birinde önerilen yerine bunu kullanabilirsiniz .

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

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

global.f instanceof FunctionAfaik de kullanabilirsiniz . değerinin değeri Functionfarklı çerçevelerde farklı olacaktır, bu nedenle yalnızca tek bir çerçeve uygulamasıyla düzgün çalışacaktır. Bu yüzden genellikle kullanıyoruz typeof. Bazı ortamlarda typeof f, örneğin MSIE 6-8 ile bazı fonksiyonların alert"nesne" tipine sahip olabileceğini unutmayın .

Yerel işlevlerle kabul edilen cevaptaki işlevi kullanabilirsiniz. Fonksiyonun yerel mi yoksa global mi olduğunu test edebilirsiniz.

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

Soruyu cevaplamak için, örnek kod en son tarayıcılarda hatasız benim için çalışıyor, bu yüzden sorunun ne olduğundan emin değilim:

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

Not: Bunun callback !== undefinedyerine kullanırdım callback != null, ama neredeyse aynı şeyi yapıyorlar.

Daha önceki tüm cevapların işlevi çağırmak için yan etkileri olmasa da çoğu

burada en iyi uygulama

fonksiyonun var

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

İşlevleri yeniden tanımlamak isterseniz, işlevler, gerçekleştikleri yere bakılmaksızın, küresel olarak tanımlandığından, gerçekleşme sıralarında tanımlanan işlev değişkenlerini kullanmak en iyisidir.

Aynı adda önceki bir işlevi çağıran yeni bir işlev oluşturma örneği:

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

Bu benim için çalıştı

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

Tek hat çözümü:

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