Kiểm tra xem một biến có thuộc loại chức năng không

Giả sử tôi có bất kỳ biến nào, được định nghĩa như sau:

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

Tôi muốn một hàm kiểm tra xem loại của biến có giống như hàm không. I E :

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

Làm cách nào để kiểm tra xem biến acó thuộc loại Functionđược xác định ở trên không?

Chắc chắn cách gạch dưới là hiệu quả hơn, nhưng cách tốt nhất để kiểm tra, khi hiệu quả không phải là vấn đề, được viết trên trang gạch dưới được liên kết bởi @Paul Rosania.

Lấy cảm hứng từ gạch dưới, chức năng isFactor cuối cùng như sau:

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

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

Underscore.js sử dụng một bài kiểm tra phức tạp hơn nhưng hiệu suất cao hơn:

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

Xem: http://jsperf.com/alternative-isfeft-im THỰCations

EDIT: các thử nghiệm được cập nhật cho thấy typeof có thể nhanh hơn, xem http://jsperf.com/alternative-isfeft-im THỰCations / 4

Có một số cách vì vậy tôi sẽ tóm tắt tất cả

1. Cách tốt nhất là:

   hàm foo (v) {if (v instanceof Hàm) {/ * làm gì đó * /}};
   
   

   Hầu hết hiệu năng (không so sánh chuỗi) và giải pháp tao nhã - toán tử instanceof đã được hỗ trợ trong các trình duyệt trong một thời gian rất dài, vì vậy đừng lo lắng - nó sẽ hoạt động trong IE 6.
2. Cách tốt nhất tiếp theo là:

   hàm foo (v) {if (typeof v === "function") {/ * làm gì đó * /}};
   
   

   Nhược điểm của typeofnó là dễ bị lỗi im lặng, xấu, vì vậy nếu bạn mắc lỗi đánh máy (ví dụ: "fifying") - trong trường hợp này, `if` sẽ trả về sai và bạn sẽ không biết mình có lỗi cho đến sau này ma cua ban
3. Cách tốt nhất tiếp theo là:

   Hàm isFunction (functionToCheck) {
       var getType = {};
       return functionToCheck && getType.toString.call (functionToCheck) === '[Hàm đối tượng]';
   }
   
   

   Điều này không có lợi thế so với giải pháp số 1 hoặc số 2 nhưng ít đọc hơn nhiều. Một phiên bản cải tiến của điều này là

   hàm isFunction (x) {
       return Object.prototype.toString.call (x) == '[Hàm đối tượng]';
   }
   
   

   nhưng vẫn còn ít ngữ nghĩa hơn giải pháp số 1

Tham chiếu jQuery (không dùng nữa từ phiên bản 3.3)

$.isFunction(functionName);

Tham khảo AngularJS

angular.isFunction(value);

Lodash Reference

_.isFunction(value);

Tham khảo gạch dưới

_.isFunction(object); 

Node.js không dùng nữa kể từ Tham chiếu v4.0.0

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

@grandecomplex: Có một lượng dài bằng lời cho giải pháp của bạn. Sẽ rõ ràng hơn nhiều nếu được viết như thế này:

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

Hãy thử instanceoftoán tử: có vẻ như tất cả các hàm kế thừa từ Functionlớp:

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

Một cái gì đó có nhiều hỗ trợ trình duyệt hơn và cũng bao gồm các chức năng async có thể là:

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

và sau đó kiểm tra nó như sau:

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

Một cách khác đơn giản:

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

Đối với những người quan tâm đến phong cách chức năng, hoặc tìm kiếm cách tiếp cận biểu cảm hơn để sử dụng trong lập trình meta (chẳng hạn như kiểm tra kiểu), thật thú vị khi xem Ramda thư viện thực hiện nhiệm vụ đó.

Mã tiếp theo chỉ chứa các hàm thuần túy và không có điểm:

const R = require('ramda');

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

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

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

Kể từ ES2017, các asyncchức năng cũng có sẵn, vì vậy chúng tôi cũng có thể kiểm tra lại chúng:

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

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

Và sau đó kết hợp chúng lại với nhau:

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

Tất nhiên, chức năng nên được bảo vệ chống lại nullvà undefinedcác giá trị, vì vậy để làm cho nó "an toàn":

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

Và, hoàn thành đoạn trích để tổng hợp:

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

Tuy nhiên, lưu ý rằng giải pháp này có thể hiển thị ít hiệu suất hơn các tùy chọn khả dụng khác do sử dụng rộng rãi các chức năng bậc cao hơn.

Nếu bạn sử dụng Lodash, bạn có thể làm điều đó với _.isFunction .

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

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

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

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

Phương thức này trả về truenếu giá trị là một hàm, khác false.

Tôi thấy rằng khi kiểm tra chức năng trình duyệt có nguồn gốc trong IE8, sử dụng toString, instanceofvà typeofkhông làm việc. Đây là một phương pháp hoạt động tốt trong IE8 (theo như tôi biết):

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

Ngoài ra, bạn có thể kiểm tra các chức năng gốc bằng cách sử dụng:

"getElementById" in document

Mặc dù vậy, tôi đã đọc được ở đâu đó rằng điều này sẽ không luôn luôn hoạt động trong IE7 trở xuống.

Dưới đây dường như cũng làm việc cho tôi (được thử nghiệm từ node.js):

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

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

Tôi nghĩ rằng bạn chỉ có thể xác định một cờ trên nguyên mẫu Hàm và kiểm tra xem trường hợp bạn muốn kiểm tra có kế thừa không

xác định một cờ:

Function.prototype.isFunction = true; 

và sau đó kiểm tra nếu nó tồn tại

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

Nhược điểm là một nguyên mẫu khác có thể định nghĩa cùng một cờ và sau đó nó vô dụng, nhưng nếu bạn có toàn quyền kiểm soát các mô-đun đi kèm thì đó là cách dễ nhất

Vì nút v0.11, bạn có thể sử dụng chức năng sử dụng tiêu chuẩn:

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

bạn nên sử dụng typeOftoán tử trong js.

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

Giải pháp như một số câu trả lời trước đây đã chỉ ra là sử dụng typeof. sau đây là đoạn mã trong 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]();
  }