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

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

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

Personalmente, trato de reducir el número de cadenas que cuelgan en mi código...

También, aunque soy consciente de que typeof es un operador y no una función, hay poco daño en el uso de sintaxis que lo hace aparecer como el último.

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

Tenga en cuenta que la devolución de llamada (por sí misma) evalúa a false si es undefined, null, 0, o false. Comparar con null es demasiado específico.

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 no se define la función posible.

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

Esto lanzará un error ReferenceError: possibleFunction is not defined mientras el motor intenta resolver la función de símbolo posible (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 comprobar si existe. So

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

Esto establece que una variable sea función que desea comprobar o el objeto vacío si no está definido y así evita los problemas mencionados anteriormente.

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

Intenta:

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

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

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

typeof(callback) == "function"

Podría hacer

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

Sé que hay una respuesta aceptada, pero nadie sugirió esto. No estoy muy seguro de si esto encaja en la descripción de idiomatic, pero funciona para todos los casos.

En los motores JavaScript más nuevos se puede usar un finally en su lugar.

Prueba esto:

callback instanceof Function

Si miras la fuente de la biblioteca @Venkat Sudheer Reddy Aedama mencionada, underscorejs, puedes ver esto:

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

Esto es solo mi PISTA, PISTA respuesta: >

Intenta:

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

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

Tal vez podría necesitarlo;)

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

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

_.isFunction(callback);

Si el callback() que está llamando no solo por una vez en una función, podría inicializar el argumento para reutilizar:

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 callback aunque no esté definido.

Para funciones globales puede usar esta en lugar de eval sugerida 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
    };

También puedes usar global.f instanceof Function, pero afaik. el valor de Function será diferente en diferentes marcos, por lo que solo funcionará correctamente con una sola aplicación de marco. Es por eso que solemos usar typeof en su lugar. Tenga en cuenta que en algunos entornos puede haber anomalías con typeof f también, por ejemplo, por MSIE 6-8 algunas de las funciones por ejemplo alert tenían tipo "objeto".

Por local funciones puede utilizar la de la respuesta aceptada. También puede probar si la función es local o global.

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 está funcionando para mí sin error en los últimos navegadores, por lo que no estoy seguro de cuál fue el problema con él:

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

Nota: Usaría callback !== undefined en lugar de callback != null, pero hacen casi lo mismo.

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

Aquí las mejores prácticas

Tienes función

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

Solución de una línea:

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