Como saber se uma função JavaScript está definida

Como você sabe se uma função em JavaScript está definida?

Eu quero fazer algo assim

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

Mas isso me dá um

retorno de chamada não é uma função

erro quando o retorno de chamada não está definido.

typeof callback === "function"

Todas as respostas atuais usam uma string literal, que eu prefiro não ter no meu código, se possível - isso não acontece (e fornece um significado semântico valioso para inicializar):

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

Pessoalmente, tento reduzir o número de strings penduradas no meu código ...

Além disso, embora eu saiba que typeofé um operador e não uma função, há pouco dano ao usar a sintaxe que a faz aparecer como a última.

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

Note-se que retorno de chamada (por si só) avalia que falsese é undefined, null, 0, ou false. Comparando com nullé excessivamente específico.

Esses métodos para saber se uma função é implementada também falham se a variável não estiver definida, por isso estamos usando algo mais poderoso que suporta o recebimento de uma string:

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

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

Novo no JavaScript Não tenho certeza se o comportamento mudou, mas a solução dada por Jason Bunting (6 anos atrás) não funcionará se a função FunctionFun não estiver definida.

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

Isso gerará um ReferenceError: possibleFunction is not definederro quando o mecanismo tentar resolver o símbolo possibleFunction (conforme mencionado nos comentários da resposta de Jason)

Para evitar esse comportamento, você só pode passar o nome da função que deseja verificar se ela existe. assim

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

Isso define uma variável para ser a função que você deseja verificar ou o objeto vazio, se não estiver definido, evitando assim os problemas mencionados acima.

Experimentar:

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

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

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

typeof(callback) == "function"

eu devo fazer

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

Eu sei que há uma resposta aceita, mas ninguém sugeriu isso. Não tenho muita certeza se isso se encaixa na descrição do idiomático, mas funciona para todos os casos.

Nos mecanismos JavaScript mais recentes, finallypode ser usado um.

Tente o seguinte:

callback instanceof Function

Se você olhar a fonte da biblioteca @Venkat Sudheer Reddy Aedama mencionada, underscorejs, poderá ver o seguinte:

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

Esta é apenas a minha DICA, DICA da resposta:>

Experimentar:

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

Se você usa http://underscorejs.org , tem: http://underscorejs.org/#isFunction

_.isFunction(callback);

Eu estava procurando como verificar se uma função jQuery foi definida e não a encontrei facilmente.

Talvez possa precisar;)

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

Se callback()você está chamando não apenas uma vez em uma função, você pode inicializar o argumento para reutilização:

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

Por exemplo:

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

    alert(text);

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

A limitação é que ele sempre executará o argumento de retorno de chamada, embora seja indefinido.

Para funções globais, você pode usar este em vez de evalsugerido em uma das respostas.

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

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

Você pode usar global.f instanceof Functiontambém, mas afaik. o valor de Functionserá diferente em quadros diferentes; portanto, ele funcionará apenas com um aplicativo de quadro único corretamente. É por isso que costumamos usar typeof. Observe que em alguns ambientes também pode haver anomalias typeof f, por exemplo, no MSIE 6-8, algumas das funções, por exemplo, alerttinham o tipo "objeto".

Por funções locais, você pode usar o da resposta aceita. Você pode testar se a função é local ou global também.

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

Para responder à pergunta, o código de exemplo está funcionando para mim sem erros nos navegadores mais recentes, então não tenho certeza de qual era o problema:

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

Nota: eu usaria em callback !== undefinedvez de callback != null, mas eles fazem quase o mesmo.

A maioria, senão todas as respostas anteriores, têm efeitos colaterais para invocar a função

aqui melhores práticas

você tem função

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

Se você deseja redefinir funções, é melhor usar variáveis ​​de função, definidas em sua ordem de ocorrência, uma vez que as funções são definidas globalmente, independentemente de onde elas ocorram.

Exemplo de criação de uma nova função que chama uma função anterior com o mesmo nome:

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

Isso funcionou para mim

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

Solução de uma linha:

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