it-swarm-pt.tech

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

Como você diz se uma função em JavaScript é definida?

Eu quero fazer algo assim

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

Mas isso me ajuda

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

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

278
Aaron Lee
typeof callback === "function"
431
Tom Ritter

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

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

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


Além disso, embora esteja ciente de que typeof é um operador e não uma função, há pouco dano em usar a sintaxe que faz com que apareça como a última.

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

Observe que o retorno de chamada (por si só) é avaliado como false, se for undefined, null, 0 ou false. Comparar com null é excessivamente específico.

15
Robin like the bird

Esses métodos para saber se uma função é implementada também falharão se a variável não estiver definida, então 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);
}
7
patriciorocca

Novo no JavaScript Não tenho certeza se o comportamento mudou, mas a solução dada por Jason Bunting (há 6 anos) não funcionará se possibleFunction não estiver definido.

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

Isso lançará um erro ReferenceError: possibleFunction is not defined enquanto o mecanismo tenta resolver o símbolo possibleFunction (como mencionado nos comentários à 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.

6
NectarSoft

Experimentar:

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

Eu devo fazer

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

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

Nos motores JavaScript mais recentes, um finally pode ser usado em seu lugar.

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

Tente isto:

callback instanceof Function
2
eWolf

Experimentar:

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

Se você olhar para o source da biblioteca @Venkat Sudheer Reddy Aedama mencionado, underscorejs, você pode ver isto:

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

Esta é apenas a minha sugestão, DICA resposta:>

2
VentyCZ

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

_.isFunction(callback);
1
Venkat Sudheer Reddy Aedama

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

Talvez precise disso;)

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

Para funções globais, você pode usar este em vez de eval sugerido 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 Function também, mas afaik. o valor de Function será diferente em diferentes quadros, portanto, funcionará apenas com um aplicativo de quadro único corretamente. É por isso que geralmente usamos typeof. Observe que, em alguns ambientes, pode haver anomalias com typeof f também, por exemplo, pelo MSIE 6-8 algumas das funções, por exemplo, alert, tinham o tipo "object".

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 a pergunta, o código de exemplo está funcionando para mim sem erros nos últimos representantes, então não tenho certeza qual foi o problema com ele:

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

Nota: Eu usaria callback !== undefined em vez de callback != null, mas eles fazem quase o mesmo.

0
inf3rno

A maioria, se não todas as respostas anteriores, tem efeitos colaterais para invocar a função

aqui melhor prática

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

Se o callback() você está chamando não apenas por 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.

0
Nick Tsai