ตรวจสอบว่าตัวแปรเป็นประเภทฟังก์ชั่น

สมมติว่าฉันมีตัวแปรใด ๆ ซึ่งถูกกำหนดดังนี้:

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

แก้ไข: การทดสอบที่ปรับปรุงแนะนำประเภทของที่อาจจะเร็วกว่าดูhttp://jsperf.com/alternative-isfunction-implementations/4

มีหลายวิธีดังนั้นฉันจะสรุปพวกเขาทั้งหมด

1. วิธีที่ดีที่สุดคือ:

   ฟังก์ชั่น foo (v) {ถ้า (v instanceof ฟังก์ชั่น) {/ * ทำอะไร * /}};
   
   

   นักแสดงส่วนใหญ่ (ไม่มีการเปรียบเทียบสตริง) และโซลูชันที่หรูหรา - ตัวดำเนินการอินสแตนซ์ได้รับการสนับสนุนในเบราว์เซอร์เป็นเวลานานดังนั้นไม่ต้องกังวล - มันจะทำงานใน IE 6
2. วิธีที่ดีที่สุดถัดไปคือ:

   ฟังก์ชั่น foo (v) {ถ้า (typeof v === "function") {/ * ทำบางสิ่งบางอย่าง * /}};
   
   

   ข้อเสียของtypeofคือมันเป็นความอ่อนแอต่อความล้มเหลวเงียบไม่ดีดังนั้นหากคุณมีการพิมพ์ผิด (เช่น "finction") - ในกรณีนี้ `if` จะเพิ่งกลับเท็จและคุณจะไม่ทราบว่าคุณมีข้อผิดพลาดจนกระทั่งในภายหลัง รหัสของคุณ
3. วิธีที่ดีที่สุดถัดไปคือ:

   ฟังก์ชั่น isFunction (functionToCheck) {
       var getType = {};
       ส่งคืน functionToCheck && getType.toString.call (functionToCheck) === '[ฟังก์ชั่นวัตถุ]';
   }
   
   

   สิ่งนี้ไม่มีข้อได้เปรียบเหนือโซลูชัน # 1 หรือ # 2 แต่อ่านได้น้อยกว่ามาก รุ่นที่ปรับปรุงแล้วของรุ่นนี้คือ

   ฟังก์ชั่น 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

บางอย่างที่รองรับเบราว์เซอร์มากขึ้นและยังรวมถึงฟังก์ชั่น async อาจเป็น:

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เพื่อทำงานให้สำเร็จ

โค้ดถัดไปมีฟังก์ชั่น pure และ pointfree เท่านั้น:

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

วิธีการนี้จะส่งกลับถ้าค่าเป็นฟังก์ชั่นอื่น ๆtruefalse

ฉันพบว่าเมื่อการทดสอบฟังก์ชั่นเบราว์เซอร์ใน 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]();
  }