Cómo saber si una función de JavaScript está definida

¿Cómo saber si se define una función en JavaScript?

Quiero hacer algo como esto

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

Pero me da un

la devolución de llamada no es una función

error cuando la devolución de llamada no está definida.

typeof callback === "function"

Todas las respuestas actuales usan una cadena literal, que prefiero no tener en mi código si es posible; esto no (y proporciona un significado semántico valioso, para arrancar):

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

Personalmente, trato de reducir la cantidad de cadenas que cuelgan en mi código ...

Además, aunque soy consciente de que typeofes un operador y no una función, hay poco daño en el uso de la sintaxis que lo hace aparecer como este último.

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

Tenga en cuenta que de devolución de llamada (por sí mismo) se evalúa como falsesi se trata de undefined, null, 0, o false. En comparación con nulles demasiado específico.

Esos métodos para saber si se implementa una función también fallan si la variable no está definida, por lo que estamos usando algo más poderoso que admite recibir una cadena:

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

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

Nuevo en JavaScript No estoy seguro de si el comportamiento ha cambiado, pero la solución dada por Jason Bunting (hace 6 años) no funcionará si es posible La función no está definida.

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

Esto arrojará un ReferenceError: possibleFunction is not definederror cuando el motor intente resolver el símbolo posible Función (como se menciona en los comentarios a la respuesta de Jason)

Para evitar este comportamiento, solo puede pasar el nombre de la función que desea verificar si existe. Entonces

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

Esto establece que una variable sea la función que desea verificar o el objeto vacío si no está definido y, por lo tanto, evita los problemas mencionados anteriormente.

Tratar:

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

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

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

typeof(callback) == "function"

yo podría hacer

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

Sé que hay una respuesta aceptada, pero nadie sugirió esto. No estoy seguro de si esto se ajusta a la descripción de idiomático, pero funciona para todos los casos.

En los motores JavaScript más nuevos, finallyse puede utilizar a.

Prueba esto:

callback instanceof Function

Si nos fijamos en la fuente de la biblioteca @Venkat Sudheer Reddy Aedama mencionada, subrayado, puede ver esto:

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

Esta es solo mi SUGERENCIA, SUGERENCIA respuesta:>

Tratar:

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

Si usa http://underscorejs.org , tiene: http://underscorejs.org/#isFunction

_.isFunction(callback);

Estaba buscando cómo verificar si se definió una función jQuery y no la encontré fácilmente.

Quizás lo necesite;)

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

Si callback()está llamando no solo por una vez en una función, puede inicializar el argumento para su reutilización:

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

Por ejemplo:

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

    alert(text);

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

La limitación es que siempre ejecutará el argumento de devolución de llamada aunque no esté definido.

Para funciones globales, puede usar esta en lugar de la evalsugerida en una de las respuestas.

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

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

Puedes usar global.f instanceof Functiontambién, pero afaik. el valor de Functionserá diferente en diferentes cuadros, por lo que solo funcionará correctamente con una aplicación de un solo cuadro. Es por eso que generalmente usamos typeofen su lugar. Tenga en cuenta que en algunos entornos también puede haber anomalías typeof f, por ejemplo, por MSIE 6-8, algunas de las funciones, por ejemplo, alerttenían el tipo "objeto".

Por funciones locales puede usar el de la respuesta aceptada. Puede probar si la función es local o global también.

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 la pregunta, el código de ejemplo funciona para mí sin error en los últimos navegadores, por lo que no estoy seguro de cuál fue el problema:

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

Nota: usaría en callback !== undefinedlugar de callback != null, pero hacen casi lo mismo.

La mayoría de las respuestas anteriores, si no todas, tienen efectos secundarios para invocar la función

aquí las mejores prácticas

tienes funcion

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

Si desea redefinir funciones, es mejor utilizar variables de función, que se definen en su orden de aparición, ya que las funciones se definen globalmente, sin importar dónde ocurran.

Ejemplo de crear una nueva función que llama a una función anterior del mismo nombre:

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

Esto funciono para mi

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

Solución de una línea:

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