Değişkenin işlev türünde olup olmadığını kontrol edin

Aşağıdaki gibi tanımlanan herhangi bir değişkenim olduğunu varsayalım:

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

Değişkenin türünün işlev benzeri olup olmadığını kontrol eden bir işlev istiyorum. yani:

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

Değişkenin yukarıda tanımlandığı şekilde atür olup olmadığını nasıl kontrol edebilirim Function?

Emin alt çizginin yolu daha verimlidir, ancak verimlilik bir sorun olmadığında kontrol etmenin en iyi yolu, alt çizginin @Paul Rosania tarafından bağlanan sayfasında yazılır.

Alt çizgiden esinlenerek, son isFunction işlevi aşağıdaki gibidir:

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

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

Underscore.js daha ayrıntılı ancak yüksek performanslı bir test kullanır:

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

Bkz. Http://jsperf.com/alternative-isfunction-implementations

DÜZENLEME: güncellenen testler, yazım yönteminin daha hızlı olabileceğini düşündürmektedir, bkz. Http://jsperf.com/alternative-isfunction-implementations/4

Birkaç yol var, bu yüzden hepsini özetleyeceğim

1. En iyi yol:

   function foo (v) {if (v instanceof Function) {/ * bir şeyler yapın * /}};
   
   

   Çoğu performans (dize karşılaştırması yok) ve zarif çözüm - instanceof operatörü tarayıcılarda çok uzun zamandır desteklenmektedir, bu yüzden endişelenmeyin - IE 6'da çalışacaktır.
2. Bir sonraki en iyi yol:

   function foo (v) {if (typeof v === "function") {/ * bir şeyler yapın * /}};
   
   

   dezavantajı, typeofsessiz hataya duyarlı olması, kötü, bu yüzden bir yazım hatası varsa (örneğin "finction") - bu durumda `if 'sadece yanlış dönecek ve daha sonraya kadar bir hatanız olduğunu bilmeyeceksiniz senin kodun
3. Bir sonraki en iyi yol:

   function isFunction (functionToCheck) {
       var getType = {};
       return functionToCheck && getType.toString.call (functionToCheck) === '[nesne İşlevi]';
   }
   
   

   Bunun çözüm # 1 veya # 2'ye göre bir avantajı yoktur, ancak çok daha az okunabilir. Bunun geliştirilmiş bir sürümü

   işlev isFunction (x) {
       Object.prototype.toString.call (x) == '[nesne İşlevi]';
   }
   
   

   ancak çözüm # 1'den çok daha az anlamsal

jQuery (sürüm 3.3'ten beri kullanımdan kaldırıldı) Başvuru

$.isFunction(functionName);

AngularJS Referansı

angular.isFunction(value);

Lodash Referansı

_.isFunction(value);

Alt Çizgi Referansı

_.isFunction(object); 

Node.js, v4.0.0 başvurusundan beri kullanımdan kaldırıldı

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

@grandecomplex: Çözümünüzde makul miktarda ayrıntı var. Böyle yazılırsa çok daha açık olur:

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

instanceofİşleci deneyin : Tüm işlevler Functionsınıftan miras alıyor gibi görünüyor :

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

Daha fazla tarayıcı desteği olan ve aynı zamanda zaman uyumsuz işlevler içeren bir şey olabilir:

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

ve sonra şöyle test edin:

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

Başka bir basit yol:

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

İşlevsel stille ilgilenenler veya meta programlamada (tip kontrolü gibi) kullanmak için daha anlamlı bir yaklaşım arayanlar için, bu tür bir görevi yerine getirmek için Ramda kütüphanesini görmek ilginç olabilir .

Sonraki kod yalnızca saf ve noktasız işlevler içerir:

const R = require('ramda');

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

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

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

ES2017'den itibaren asyncfonksiyonlar mevcuttur, böylece bunlara karşı da kontrol edebiliriz:

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

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

Ve sonra bunları birleştirin:

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

Tabii ki, işlev "güvenli" hale getirmek için nullve undefineddeğerlere karşı korunmalıdır :

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

Ve özetlemek için snippet'i tamamlayın:

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

Bununla birlikte, bu çözümün, üst düzey işlevlerin yaygın kullanımı nedeniyle mevcut diğer seçeneklerden daha az performans gösterebileceğini unutmayın.

Lodash kullanıyorsanız _.isFunction ile yapabilirsiniz .

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

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

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

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

trueDeğer başka bir işlevse bu yöntem geri döner false.

Ben IE8'de yerel tarayıcı işlevlerini test ederken, kullanıyor ise toString, instanceofve typeofçalışma yoktu. İşte (bildiğim kadarıyla) IE8 iyi çalışan bir yöntem:

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

Alternatif olarak, aşağıdakileri kullanarak yerel işlevleri kontrol edebilirsiniz:

"getElementById" in document

Yine de, bir yerde bunun her zaman IE7 ve altında çalışmayacağını okudum.

Aşağıdakiler benim için de işe yarıyor gibi görünüyor (denenmiştir node.js):

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

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

İşlev prototipinde bir bayrak tanımlayabileceğinizi ve test etmek istediğiniz örneğin miras alıp almadığını kontrol edebileceğinizi düşünüyorum

bir bayrak tanımlayın:

Function.prototype.isFunction = true; 

ve sonra var olup olmadığını kontrol et

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

Dezavantajı, başka bir prototipin aynı bayrağı tanımlayabilmesidir ve daha sonra değersizdir, ancak dahil edilen modüller üzerinde tam kontrole sahipseniz, bu en kolay yoldur

V0.11 düğümünden bu yana, standart util işlevini kullanabilirsiniz:

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

js'de typeOfoperatör kullanmalısınız .

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

Önceki bazı cevapların gösterdiği çözüm, typeof kullanmaktır. NodeJs'de bir kod snippet'i aşağıdadır,

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