Проверьте, имеет ли переменная тип функции

Предположим, у меня есть любая переменная, которая определяется следующим образом:

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

Я хочу функцию, которая проверяет, является ли тип переменной как функция. т.е.

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

Как я могу проверить, имеет ли переменная aтип Functionописанным выше способом?

Конечно, способ подчеркивания более эффективен, но лучший способ проверить, когда эффективность не является проблемой, написан на странице подчеркивания, на которую ссылается @Paul Rosania.

Вдохновленная подчеркиванием, заключительная функция isFunction выглядит следующим образом:

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

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

Underscore.js использует более сложный, но высокопроизводительный тест:

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

Смотрите: http://jsperf.com/alternative-isfunction-implementations

РЕДАКТИРОВАТЬ: обновленные тесты показывают, что typeof может быть быстрее, см. Http://jsperf.com/alternative-isfunction-implementations/4

Есть несколько способов, поэтому я обобщу их все

1. Лучший способ это:

   function foo (v) {if (v instanceof Function) {/ * сделать что-то * /}};
   
   

   Наиболее производительное (без сравнения строк) и элегантное решение - оператор instanceof поддерживается в браузерах очень долгое время, так что не волнуйтесь - он будет работать в IE 6.
2. Следующий лучший способ:

   function foo (v) {if (typeof v === "function") {/ * сделать что-то * /}};
   
   

   недостатком typeofявляется то, что он подвержен тихому отказу, что плохо, поэтому, если у вас есть опечатка (например, «finction») - в этом случае `if` просто вернет false, и вы не будете знать, что у вас будет ошибка, пока позже в ваш код
3. Следующий лучший способ:

   function isFunction (functionToCheck) {
       var getType = {};
       return functionToCheck && getType.toString.call (functionToCheck) === '[Функция объекта]';
   }
   
   

   Это не имеет никакого преимущества перед решением № 1 или № 2, но намного менее читабельно. Улучшенная версия этого

   function isFunction (x) {
       return Object.prototype.toString.call (x) == '[Функция объекта]';
   }
   
   

   но все же намного менее семантически, чем решение № 1

JQuery ( не рекомендуется начиная с версии 3.3) Reference

$.isFunction(functionName);

AngularJS Ссылка

angular.isFunction(value);

Lodash Ссылка

_.isFunction(value);

Подчеркнуть Ссылка

_.isFunction(object); 

Node.js устаревшим с V4.0.0 Reference

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

@grandecomplex: в вашем решении довольно много подробностей. Было бы намного понятнее, если бы написано так:

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

Попробуйте instanceofоператор: кажется, что все функции наследуются от Functionкласса:

// 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

Что-то с большей поддержкой браузера, а также с асинхронными функциями может быть:

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

а затем проверить это как:

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

Другой простой способ:

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

Для тех, кто интересуется функциональным стилем или ищет более выразительный подход для использования в метапрограммировании (например, проверку типов), было бы интересно увидеть библиотеку Ramda для выполнения такой задачи.

Следующий код содержит только чистые и точечные функции:

const R = require('ramda');

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

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

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

Начиная с ES2017, asyncфункции доступны, поэтому мы также можем проверить их:

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

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

А затем объединить их вместе:

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

Конечно, функция должна быть защищена от nullи undefinedзначений, чтобы сделать ее «безопасной»:

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

И полный фрагмент, чтобы подвести итог:

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

Однако обратите внимание, что это решение может показывать меньшую производительность, чем другие доступные опции, из-за широкого использования функций более высокого порядка.

Если вы используете Lodash, вы можете сделать это с помощью _.isFunction .

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

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

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

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

Этот метод возвращает, trueесли значение является функцией, иначе false.

Я обнаружил , что при тестировании встроенных функций браузера в IE8, используя toString, instanceofи typeofне работой. Вот метод, который отлично работает в IE8 (насколько я знаю):

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

Кроме того, вы можете проверить наличие встроенных функций, используя:

"getElementById" in document

Хотя я где-то читал, что это не всегда будет работать в IE7 и ниже.

Ниже, кажется, работает для меня (проверено от node.js):

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

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

Я думаю, что вы можете просто определить флаг в прототипе функции и проверить, если экземпляр, который вы хотите проверить, унаследовал это

определить флаг:

Function.prototype.isFunction = true; 

а затем проверьте, существует ли он

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

Недостатком является то, что другой прототип может определять тот же флаг, и тогда он бесполезен, но если у вас есть полный контроль над включенными модулями, это самый простой способ

Начиная с узла v0.11 вы можете использовать стандартную функцию util:

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

Вы должны использовать typeOfоператор в JS.

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

Решение, как показали некоторые предыдущие ответы, заключается в использовании typeof. ниже приведен фрагмент кода в 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]();
  }