Verifique se uma variável é do tipo de função

Suponha que eu tenha qualquer variável, definida da seguinte maneira:

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

Eu quero uma função que verifica se o tipo da variável é semelhante a uma função. ou seja:

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

Como posso verificar se a variável aé do tipo Functionda maneira definida acima?

O caminho do sublinhado é mais eficiente, mas a melhor maneira de verificar, quando a eficiência não é um problema, está escrita na página do sublinhado vinculada por @Paul Rosania.

Inspirada no sublinhado, a função final isFunction é a seguinte:

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

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

O Underscore.js usa um teste mais elaborado, mas de alto desempenho:

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

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

EDIT: testes atualizados sugerem que o typeof pode ser mais rápido, consulte http://jsperf.com/alternative-isfunction-implementations/4

Existem várias maneiras, então vou resumir todas elas

1. A melhor maneira é:

   function foo (v) {if (v instanceof Function) {/ * faça algo * /}};
   
   

   Solução com melhor desempenho (sem comparação de cadeias) e elegante - a instância do operador é suportada nos navegadores há muito tempo, portanto, não se preocupe - funcionará no IE 6.
2. A melhor maneira seguinte é:

   function foo (v) {if (typeof v === "function") {/ * faça algo * /}};
   
   

   A desvantagem typeofé que ele é suscetível a falhas silenciosas, ruim; portanto, se você tiver um erro de digitação (por exemplo, "fusion") - nesse caso, o `if` retornará falso e você não saberá que há um erro até mais tarde. seu código
3. A próxima melhor maneira é:

   função isFunction (functionToCheck) {
       var getType = {};
       retornar functionToCheck && getType.toString.call (functionToCheck) === '[função do objeto]';
   }
   
   

   Isso não tem vantagem sobre a solução 1 ou 2, mas é muito menos legível. Uma versão melhorada disso é

   função isFunction (x) {
       retornar Object.prototype.toString.call (x) == '[função do objeto]';
   }
   
   

   mas ainda muito menos semântica que a solução nº 1

jQuery (descontinuado desde a versão 3.3) Referência

$.isFunction(functionName);

Referência do AngularJS

angular.isFunction(value);

Referência Lodash

_.isFunction(value);

Referência de sublinhado

_.isFunction(object); 

Node.js descontinuado desde a v4.0.0 Referência

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

@grandecomplex: Há uma quantidade razoável de verbosidade na sua solução. Seria muito mais claro se escrito assim:

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

Experimente o instanceofoperador: parece que todas as funções herdam da Functionclasse:

// 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 com mais suporte ao navegador e também inclui funções assíncronas pode ser:

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

e depois teste 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

Uma outra maneira simples:

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

Para quem está interessado em estilo funcional ou procura uma abordagem mais expressiva para utilizar em metaprogramação (como verificação de tipo), pode ser interessante ver a biblioteca Ramda para realizar essa tarefa.

O código seguinte contém apenas funções puras e sem ponto:

const R = require('ramda');

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

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

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

No ES2017, as asyncfunções estão disponíveis, para que possamos verificar também:

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

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

E depois combine-os:

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

Obviamente, a função deve ser protegida contra nulle undefinedvalores, para torná-la "segura":

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

E, complete o snippet 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 ));

No entanto, observe que esta solução pode mostrar menos desempenho do que outras opções disponíveis devido ao uso extensivo de funções de ordem superior.

Se você usa o Lodash, pode fazê-lo com _.isFunction .

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

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

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

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

Este método retorna truese value for uma função, caso contrário false.

Descobri que ao testar funções do navegador nativo no IE8, usando toString, instanceofe typeofnão funcionou. Aqui está um método que funciona bem no IE8 (tanto quanto eu sei):

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

Como alternativa, você pode verificar as funções nativas usando:

"getElementById" in document

No entanto, li em algum lugar que isso nem sempre funcionará no IE7 e abaixo.

O abaixo parece funcionar para mim também (testado a partir de node.js):

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

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

Eu acho que você pode apenas definir um sinalizador no protótipo Function e verificar se a instância que você deseja testar herdou esse

defina uma bandeira:

Function.prototype.isFunction = true; 

e depois verifique se existe

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

A desvantagem é que outro protótipo pode definir o mesmo sinalizador e, em seguida, é inútil, mas se você tiver controle total sobre os módulos incluídos, é a maneira mais fácil

Desde o nó v0.11, você pode usar a função util padrão:

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

você deve usar o typeOfoperador em js.

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

A solução, como algumas respostas anteriores mostraram, é usar typeof. a seguir está um trecho de código Nos 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]();
  }