Compruebe si una variable es del tipo de función

Supongamos que tengo alguna variable, que se define de la siguiente manera:

var a = function() {/* Statements */};

Quiero una función que verifique si el tipo de la variable es similar a una función. es decir:

function foo(v) {if (v is function type?) {/* do something */}};
foo(a);

¿Cómo puedo verificar si la variable aes de tipo Functionen la forma definida anteriormente?

Claro que la forma de subrayar es más eficiente, pero la mejor manera de verificar, cuando la eficiencia no es un problema, está escrita en la página de subrayado vinculada por @Paul Rosania.

Inspirada en el subrayado, la función final isFunction es la siguiente:

function isFunction(functionToCheck) {
 return functionToCheck && {}.toString.call(functionToCheck) === '[object Function]';
}

if (typeof v === "function") {
    // do something
}

Underscore.js utiliza una prueba más elaborada pero de alto rendimiento:

_.isFunction = function(obj) {
  return !!(obj && obj.constructor && obj.call && obj.apply);
};

Ver: http://jsperf.com/alternative-isfunction-implementations

EDITAR: las pruebas actualizadas sugieren que typeof podría ser más rápido, consulte http://jsperf.com/alternative-isfunction-implementations/4

Hay varias formas, así que las resumiré todas

1. La mejor manera es:

   function foo (v) {if (v instanceof Function) {/ * haz algo * /}};
   
   

   La solución más eficiente (sin comparación de cadenas) y elegante: la instancia del operador ha sido compatible con los navegadores durante mucho tiempo, así que no se preocupe, funcionará en IE 6.
2. La siguiente mejor manera es:

   function foo (v) {if (typeof v === "function") {/ * haz algo * /}};
   
   

   La desventaja de esto typeofes que es susceptible a fallas silenciosas, mal, así que si tiene un error tipográfico (por ejemplo, "finction"), en este caso, el `if` simplemente devolverá falso y no sabrá que tiene un error hasta más tarde tu codigo
3. La siguiente mejor manera es:

   function isFunction (functionToCheck) {
       var getType = {};
       return functionToCheck && getType.toString.call (functionToCheck) === '[Función de objeto]';
   }
   
   

   Esto no tiene ninguna ventaja sobre la solución n. ° 1 o n. ° 2, pero es mucho menos legible. Una versión mejorada de esto es

   function isFunction (x) {
       return Object.prototype.toString.call (x) == '[función de objeto]';
   }
   
   

   pero aún menos semántica que la solución n. ° 1

jQuery (en desuso desde la versión 3.3) Referencia

$.isFunction(functionName);

AngularJS Referencia de

angular.isFunction(value);

Lodash Referencia de

_.isFunction(value);

Guion bajo Referencia de

_.isFunction(object); 

Node.js en desuso desde v4.0.0 Referencia

var util = require('util');
util.isFunction(object);

@grandecomplex: Hay una buena cantidad de verbosidad en su solución. Sería mucho más claro si se escribiera así:

function isFunction(x) {
  return Object.prototype.toString.call(x) == '[object Function]';
}

Pruebe el instanceofoperador: parece que todas las funciones heredan de la Functionclase:

// Test data
var f1 = function () { alert("test"); }
var o1 = { Name: "Object_1" };
F_est = function () { };
var o2 = new F_est();

// Results
alert(f1 instanceof Function); // true
alert(o1 instanceof Function); // false
alert(o2 instanceof Function); // false

Algo con más compatibilidad con el navegador y también incluye funciones asíncronas podría ser:

const isFunction = value => value && (Object.prototype.toString.call(value) === "[object Function]" || "function" === typeof value || value instanceof Function);

y luego probarlo como:

isFunction(isFunction); //true
isFunction(function(){}); //true
isFunction(()=> {}); //true
isFunction(()=> {return 1}); //true
isFunction(async function asyncFunction(){}); //true
isFunction(Array); //true
isFunction(Date); //true
isFunction(Object); //true
isFunction(Number); //true
isFunction(String); //true
isFunction(Symbol); //true
isFunction({}); //false
isFunction([]); //false
isFunction("function"); //false
isFunction(true); //false
isFunction(1); //false
isFunction("Alireza Dezfoolian"); //false

Otra forma sencilla:

var fn = function () {}
if (fn.constructor === Function) {
  // true
} else {
  // false
}

Para aquellos que están interesados ​​en el estilo funcional, o buscan un enfoque más expresivo para utilizar en la meta programación (como la verificación de tipos), podría ser interesante ver a Ramda biblioteca para realizar dicha tarea.

El siguiente código contiene solo funciones puras y sin puntos:

const R = require('ramda');

const isPrototypeEquals = R.pipe(Object.getPrototypeOf, R.equals);

const equalsSyncFunction = isPrototypeEquals(() => {});

const isSyncFunction = R.pipe(Object.getPrototypeOf, equalsSyncFunction);

A partir de ES2017, las asyncfunciones están disponibles, por lo que también podemos verificarlas:

const equalsAsyncFunction = isPrototypeEquals(async () => {});

const isAsyncFunction = R.pipe(Object.getPrototypeOf, equalsAsyncFunction);

Y luego combinarlos juntos:

const isFunction = R.either(isSyncFunction, isAsyncFunction);

Por supuesto, la función debe protegerse contra nully los undefinedvalores, para que sea "segura":

const safeIsFunction = R.unless(R.isNil, isFunction);

Y, fragmento completo para resumir:

const R = require('ramda');

const isPrototypeEquals = R.pipe(Object.getPrototypeOf, R.equals);

const equalsSyncFunction = isPrototypeEquals(() => {});
const equalsAsyncFunction = isPrototypeEquals(async () => {});

const isSyncFunction = R.pipe(Object.getPrototypeOf, equalsSyncFunction);
const isAsyncFunction = R.pipe(Object.getPrototypeOf, equalsAsyncFunction);

const isFunction = R.either(isSyncFunction, isAsyncFunction);

const safeIsFunction = R.unless(R.isNil, isFunction);

// ---

console.log(safeIsFunction( function () {} ));
console.log(safeIsFunction( () => {} ));
console.log(safeIsFunction( (async () => {}) ));
console.log(safeIsFunction( new class {} ));
console.log(safeIsFunction( {} ));
console.log(safeIsFunction( [] ));
console.log(safeIsFunction( 'a' ));
console.log(safeIsFunction( 1 ));
console.log(safeIsFunction( null ));
console.log(safeIsFunction( undefined ));

Sin embargo, tenga en cuenta que esta solución podría mostrar menos rendimiento que otras opciones disponibles debido al uso extensivo de funciones de orden superior.

Si usa Lodash, puede hacerlo con _.isFunction .

_.isFunction(function(){});
// => true

_.isFunction(/abc/);
// => false

_.isFunction(true);
// => false

_.isFunction(null);
// => false

Este método devuelve truesi el valor es una función, de lo contrario false.

He descubierto que al probar las funciones del navegador nativo en IE8, usando toString, instanceofy typeofno funcionó. Aquí hay un método que funciona bien en IE8 (que yo sepa):

function isFn(f){
    return !!(f && f.call && f.apply);
}
//Returns true in IE7/8
isFn(document.getElementById);

Alternativamente, puede verificar las funciones nativas usando:

"getElementById" in document

Sin embargo, he leído en alguna parte que esto no siempre funcionará en IE7 y versiones inferiores.

Lo siguiente parece funcionar para mí también (probado desde node.js):

var isFunction = function(o) {
     return Function.prototype.isPrototypeOf(o);
};

console.log(isFunction(function(){})); // true
console.log(isFunction({})); // false

Creo que puede definir un indicador en el prototipo de Función y verificar si la instancia que desea probar heredó eso

definir una bandera:

Function.prototype.isFunction = true; 

y luego verifica si existe

var foo = function(){};
foo.isFunction; // will return true

La desventaja es que otro prototipo puede definir la misma bandera y luego no vale nada, pero si tiene control total sobre los módulos incluidos, es la forma más fácil

Desde el nodo v0.11 puede usar la función de utilidad estándar:

var util = require('util');
util.isFunction('foo');

deberías usar typeOfoperator en js.

var a=function(){
    alert("fun a");
}
alert(typeof a);// alerts "function"

La solución, como han mostrado algunas respuestas anteriores, es usar typeof. el siguiente es un fragmento de código en NodeJs,

    function startx() {
      console.log("startx function called.");
    }

 var fct= {};
 fct["/startx"] = startx;

if (typeof fct[/startx] === 'function') { //check if function then execute it
    fct[/startx]();
  }