Sprawdź, czy zmienna jest typu funkcji

Załóżmy, że mam dowolną zmienną, która jest zdefiniowana w następujący sposób:

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

Chcę funkcji, która sprawdza, czy typ zmiennej jest podobny do funkcji. tj .:

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

Jak mogę sprawdzić, czy zmienna ajest typu Functionw sposób określony powyżej?

Oczywiście sposób podkreślenia jest bardziej wydajny, ale najlepszy sposób sprawdzenia, kiedy wydajność nie jest problemem, jest napisany na stronie podkreślonej przez @Paul Rosania.

Zainspirowany podkreśleniem, końcowa funkcja isFunction jest następująca:

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

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

Underscore.js używa bardziej złożonego, ale wysoce wydajnego testu:

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

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

EDYCJA: zaktualizowane testy sugerują, że typeof może być szybszy, patrz http://jsperf.com/alternative-isfunction-implementations/4

Istnieje kilka sposobów, dlatego streszczę je wszystkie

1. Najlepszym sposobem jest:

   function foo (v) {if (v instanceof Function) {/ * zrób coś * /}};
   
   

   Najbardziej wydajne (bez porównania ciągów) i eleganckie rozwiązanie - operator instanceof jest obsługiwany w przeglądarkach od bardzo dawna, więc nie martw się - będzie działał w IE 6.
2. Następnym najlepszym sposobem jest:

   function foo (v) {if (typeof v === "function") {/ * zrób coś * /}};
   
   

   wadą typeofjest to, że jest podatny na cichą awarię, źle, więc jeśli masz literówkę (np. „zakończenie”) - w tym przypadku „if” po prostu zwróci fałsz i nie będziesz wiedział, że masz błąd, dopóki nie Twój kod
3. Kolejny najlepszy sposób to:

   funkcja isFunction (functionToCheck) {
       var getType = {};
       return functionToCheck && getType.toString.call (functionToCheck) === '[Object Function]';
   }
   
   

   Nie ma to przewagi nad rozwiązaniem nr 1 lub nr 2, ale jest o wiele mniej czytelne. Udoskonalona wersja tego

   funkcja isFunction (x) {
       return Object.prototype.toString.call (x) == '[funkcja obiektu]';
   }
   
   

   ale wciąż znacznie mniej semantyczny niż rozwiązanie nr 1

jQuery (przestarzałe od wersji 3.3) Odniesienie

$.isFunction(functionName);

Odniesienie AngularJS

angular.isFunction(value);

Referencje Lodash

_.isFunction(value);

Odniesienie do podkreślenia

_.isFunction(object); 

Node.js jest przestarzałe od wersji 4.0.0 Reference

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

@grandecomplex: W twoim rozwiązaniu jest sporo gadatliwości. Byłoby o wiele jaśniej, gdyby napisano w ten sposób:

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

Wypróbuj instanceofoperator: wygląda na to, że wszystkie funkcje dziedziczą po Functionklasie:

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

Coś z większą obsługą przeglądarki i funkcjami asynchronicznymi może być:

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

a następnie przetestuj:

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

Innym prostym sposobem:

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

Dla tych, którzy są zainteresowani stylem funkcjonalnym lub szukają bardziej wyrazistego podejścia do wykorzystania w metaprogramowaniu (takim jak sprawdzanie typów), interesujące może być obejrzenie biblioteki Ramda, aby wykonać takie zadanie.

Następny kod zawiera tylko czyste i bezcelowe funkcje:

const R = require('ramda');

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

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

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

Począwszy od ES2017, asyncfunkcje są dostępne, więc możemy je również sprawdzić:

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

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

A następnie połącz je razem:

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

Oczywiście funkcja powinna być chroniona przed wartościami nulli undefinedwartościami, aby była „bezpieczna”:

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

I uzupełnij fragment kodu, aby podsumować:

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

Należy jednak pamiętać, że to rozwiązanie może wykazywać mniejszą wydajność niż inne dostępne opcje z powodu szerokiego użycia funkcji wyższego rzędu.

Jeśli używasz Lodash, możesz to zrobić za pomocą _.isFunkcji .

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

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

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

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

Ta metoda zwraca, truejeśli wartość jest funkcją, w przeciwnym razie false.

Okazało się, że podczas testowania natywne funkcje przeglądarki w IE8, używając toString, instanceofi typeofnie działa. Oto metoda, która działa dobrze w IE8 (o ile mi wiadomo):

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

Alternatywnie możesz sprawdzić funkcje natywne, używając:

"getElementById" in document

Chociaż gdzieś przeczytałem, że nie zawsze będzie to działać w IE7 i niższych wersjach.

Poniższe wydaje się również działać dla mnie (testowane z node.js):

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

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

Myślę, że możesz po prostu zdefiniować flagę na prototypie funkcji i sprawdzić, czy instancja, którą chcesz przetestować, odziedziczyła to

zdefiniuj flagę:

Function.prototype.isFunction = true; 

a następnie sprawdź, czy istnieje

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

Minusem jest to, że inny prototyp może zdefiniować tę samą flagę, a następnie jest bezwartościowy, ale jeśli masz pełną kontrolę nad dołączonymi modułami, jest to najprostszy sposób

Od węzła v0.11 możesz użyć standardowej funkcji util:

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

powinieneś użyć typeOfoperatora w js.

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

Rozwiązaniem, jak pokazały niektóre poprzednie odpowiedzi, jest użycie typeof. Oto fragment kodu W 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]();
  }