Перевірте, чи є змінна функціонального типу

Припустимо, у мене є будь-яка змінна, яка визначається наступним чином:

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

Я хочу функцію, яка перевіряє, чи тип змінної є функціональним. тобто:

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

Як я можу перевірити, чи відповідає змінна aтипу Functionвказаним вище способом?

Звичайно, спосіб підкреслення є більш ефективним, але найкращий спосіб перевірити, коли ефективність не викликає проблем, написаний на сторінці підкреслення, яку посилається на @Paul Rosania.

Натхненний підкресленням, остаточна функція функціонування полягає в наступному:

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

EDIT: оновлені тести дозволяють припустити, що typeof може бути швидшим, див. Http://jsperf.com/alternative-isfunction-implementations/4

Існує кілька способів, тому я підсумую їх усі

1. Найкращий спосіб:

   function foo (v) {if (v instanceof Функція) {/ * робити щось * /}};
   
   

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

   function foo (v) {if (typeof v === "function") {/ * робити щось * /}};
   
   

   Недоліком typeofє те, що він чутливий до мовчазного відмови, погано, тому якщо у вас помилка друку (наприклад, "фініш") - у цьому випадку `if` просто поверне помилкове значення, і ви не будете знати, що маєте помилку до цього пізніше свій код
3. Наступний найкращий спосіб:

   функція isFunction (functionToCheck) {
       var getType = {};
       функція поверненняToCheck && getType.toString.call (functionToCheck) === '[функція об'єкта]';
   }
   
   

   Це не має переваги перед рішенням №1 або №2, але набагато менш читабельне. Вдосконалена версія цього є

   функція isFunction (x) {
       повернути Object.prototype.toString.call (x) == '[Функція об'єкта]';
   }
   
   

   але все ж набагато менш смисловий, ніж рішення №1

jQuery (застаріло з версії 3.3) Посилання

$.isFunction(functionName);

AngularJS Довідник

angular.isFunction(value);

Довідка Лодаша

_.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 і перевірити, чи спадкував це екземпляр, який ви хочете перевірити

визначте прапор:

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