විචල්‍යයක් ශ්‍රිත වර්ගයට අයත් දැයි පරීක්ෂා කරන්න

මට කිසියම් විචල්‍යයක් ඇතැයි සිතමු, එය පහත පරිදි අර්ථ දැක්වේ:

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

මට අවශ්‍ය වන්නේ විචල්‍යයේ වර්ගය ශ්‍රිතයට සමාන දැයි පරීක්ෂා කරන ශ්‍රිතයකි. එනම්:

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

ඉහත අර්ථ දක්වා ඇති ආකාරයට විචල්‍යය aවර්ග තිබේදැයි පරීක්ෂා කරන්නේ Functionකෙසේද?

අවතක්සේරු කිරීමේ ක්‍රමය වඩා කාර්යක්ෂම බව සහතිකයි, නමුත් කාර්යක්ෂමතාව ගැටළුවක් නොවන විට පරීක්ෂා කිරීමට හොඳම ක්‍රමය @ පෝල් රොසානියා විසින් සම්බන්ධ කර ඇති යටි ඉරි පිටුවේ ලියා ඇත.

අවධාරනය මගින් දේවානුභාවයෙන්, අවසාන 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

සංස්කරණය කරන්න: යාවත්කාලීන කරන ලද පරීක්ෂණ මඟින් යතුරු ලියනය වේගවත් විය හැකි බව බලන්න, http://jsperf.com/alternative-isfunction-implementations/4 බලන්න

ක්‍රම කිහිපයක් තිබේ, එබැවින් මම ඒවා සියල්ලම සාරාංශ කරමි

1. හොඳම ක්‍රමය නම්:

   ශ්‍රිතය foo (v) {if (v instanceof function) {/ * යමක් කරන්න * /}};
   
   

   බොහෝ කාර්ය සාධනය (නූල් සැසඳීමක් නැත) සහ අලංකාර විසඳුම - නිදර්ශන ක්‍රියාකරුට බ්‍රව්සර්වල දීර් time කාලයක් තිස්සේ සහය ලබා දී ඇත, එබැවින් කරදර නොවන්න - එය IE 6 හි ක්‍රියා කරනු ඇත.
2. ඊළඟ හොඳම ක්‍රමය නම්:

   ශ්‍රිතය foo (v) {if (typeof v === "function") {/ * යමක් කරන්න * /}};
   
   

   හි අවාසිය typeof නම් එය නිහ silent අසාර්ථකත්වයට ගොදුරු වීමයි, නරකයි, එබැවින් ඔබට අක්ෂර වින්‍යාසයක් තිබේ නම් (උදා: "ෆින්ෂන්") - මේ අවස්ථාවේ දී `if` වැරදියට නැවත පැමිණෙනු ඇති අතර පසුව ඔබට දෝෂයක් ඇති බව ඔබ නොදනී. ඔබේ කේතය
3. ඊළඟ හොඳම ක්‍රමය නම්:

   ශ්‍රිතය isFunction (functionToCheck) {
       var getType = {};
       return functionToCheck && getType.toString.call (functionToCheck) === '[වස්තු ක්‍රියාකාරිත්වය]';
   }
   
   

   මෙය විසඳුම # 1 හෝ # 2 ට වඩා වාසියක් නැති නමුත් කියවිය හැකි ප්‍රමාණයට වඩා අඩුය. මෙහි වැඩිදියුණු කළ අනුවාදයකි

   ශ්‍රිතය isFunction (x) {
       ආපසු Object.prototype.toString.call (x) == '[වස්තු ශ්‍රිතය]';
   }
   
   

   නමුත් තවමත් විසඳුම # 1 ට වඩා අඩු අර්ථකථනයක් ඇත

jQuery (3.3 අනුවාදයෙන් ඉවත් කරන ලදි) යොමුව

$.isFunction(functionName);

AngularJS යොමුව

angular.isFunction(value);

ලොඩාෂ් යොමුව

_.isFunction(value);

යටි ඉරි යොමු කිරීම

_.isFunction(object); 

V4.0.0 යොමුව සිට Node.js අවලංගු කරන ලදි

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
}

ක්‍රියාකාරී ශෛලිය ගැන උනන්දුවක් දක්වන හෝ මෙටා ක්‍රමලේඛනය සඳහා භාවිතා කිරීමට වඩාත් ප්‍රකාශන ප්‍රවේශයක් සොයන අයට (වර්ගය පරීක්ෂා කිරීම වැනි), රාම්ඩා දැකීම සිත්ගන්නාසුළු විය හැකිය එවැනි කාර්යයක් ඉටු පුස්තකාලය .

ඊළඟ කේතයේ අඩංගු වන්නේ පිරිසිදු හා ලක්ෂ්‍ය රහිත කාර්යයන් පමණි:

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

කෙසේ වෙතත්, ඉහළ ඇණවුම් කාර්යයන් පුළුල් ලෙස භාවිතා කිරීම හේතුවෙන් මෙම විසඳුම වෙනත් පවතින විකල්පයන්ට වඩා අඩු කාර්ය සාධනයක් පෙන්විය හැකි බව සලකන්න.

ඔබ ලොඩාෂ් භාවිතා කරන්නේ නම් ඔබට එය _.isFunction සමඟ කළ හැකිය .

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

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

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

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

trueඅගය ශ්‍රිතයක් නම් මෙම ක්‍රමය නැවත පැමිණේ false.

මම භාවිතා 8 යනු ස්වදේශික බ්රවුසරය කාර්යයන් පරීක්ෂා කරන විට බව සොයා 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

අවාසිය නම් වෙනත් මූලාකෘතියකට එකම ධජය නිර්වචනය කළ හැකි අතර එය නිෂ් less ල ය, නමුත් ඇතුළත් කළ මොඩියුලයන් පිළිබඳ පූර්ණ පාලනයක් ඔබට තිබේ නම් එය පහසුම ක්‍රමයයි

V0.11 නෝඩ් සිට ඔබට සම්මත උපයෝගීතා ශ්‍රිතය භාවිතා කළ හැකිය:

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

ඔබ js හි typeOfක්‍රියාකරු භාවිතා කළ යුතුය .

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

මීට පෙර සමහර පිළිතුරු පෙන්වා ඇති පරිදි විසඳුම ටයිප් ඕෆ් භාවිතා කිරීමයි. පහත දැක්වෙන්නේ කේත ස්නිපටයක් වන 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]();
  }