変数が関数型かどうかを確認します

次のように定義されている変数があるとします。

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

EDIT：更新されたテストは、参照、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以降非推奨）リファレンス

$.isFunction(functionName);

AngularJS リファレンス

angular.isFunction(value);

Lodash リファレンス

_.isFunction(value);

アンダースコア リファレンス

_.isFunction(object); 

Node.jsはv4.0.0 リファレンスから廃止予定

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

あなたはjsでtypeOf演算子を使うべきです

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