ජාවාස්ක්‍රිප්ට් ශ්‍රිතයක් එහි නමක් ලෙස මා සතුව ඇති විට එය ක්‍රියාත්මක කරන්නේ කෙසේද?

මට ජාවාස්ක්‍රිප්ට් හි ශ්‍රිතයක නමක් ඇත. මට එය පසුව ක්‍රියාකාරී ඇමතුමක් බවට පරිවර්තනය කරන්නේ කෙසේද?

තත්වයන් මත පදනම්ව, මට ක්‍රමයට විවිධ තර්ක ඉදිරිපත් කිරීමට අවශ්‍ය විය හැකිය.

සමහර ශ්‍රිතවල ස්වරූපය ගනී namespace.namespace.function(args[...]).

භාවිතා නොකරන්න evalඔබ මිස පරම, ධනාත්මක වෙනත් කිසිදු විකල්පයක් තියෙනවා.

සඳහන් කර ඇති පරිදි, මෙවැනි දෙයක් භාවිතා කිරීම හොඳම ක්‍රමය වනු ඇත:

window["functionName"](arguments);

කෙසේ වෙතත්, එය නාම අවකාශයේ ශ්‍රිතයක් සමඟ ක්‍රියා නොකරනු ඇත:

window["My.Namespace.functionName"](arguments); // fail

ඔබ එය කරන්නේ මෙයයි:

window["My"]["Namespace"]["functionName"](arguments); // succeeds

එය පහසු කිරීම සහ යම් නම්‍යතාවයක් ලබා දීම සඳහා, මෙහි පහසුව සඳහා ශ්‍රිතයක් ඇත:

function executeFunctionByName(functionName, context /*, args */) {
  var args = Array.prototype.slice.call(arguments, 2);
  var namespaces = functionName.split(".");
  var func = namespaces.pop();
  for(var i = 0; i < namespaces.length; i++) {
    context = context[namespaces[i]];
  }
  return context[func].apply(context, args);
}

ඔබ එය එසේ හඳුන්වනු ඇත:

executeFunctionByName("My.Namespace.functionName", window, arguments);

සටහන, ඔබට අවශ්‍ය ඕනෑම සන්දර්භයකින් ඔබට සමත් විය හැකිය, එබැවින් මෙය ඉහත ආකාරයටම කරනු ඇත:

executeFunctionByName("Namespace.functionName", My, arguments);

ජේසන් බන්ටිංගේ ඉතා ප්‍රයෝජනවත් ක්‍රියාකාරිත්වයේ තරමක් වෙනස් කළ අනුවාදයක් පළ කිරීමට සිතුවෙමි .

පළමුව, පෙත්ත () සඳහා දෙවන පරාමිතියක් සැපයීමෙන් මම පළමු ප්‍රකාශය සරල කර ඇත්තෙමි . මුල් අනුවාදය IE හැර අනෙකුත් සියලුම බ්‍රව්සර්වල හොඳින් ක්‍රියාත්මක විය.

දෙවනුව, මම මෙය ආපසු ප්‍රකාශයේ සන්දර්භය සමඟ ප්‍රතිස්ථාපනය කර ඇත ; එසේ නොමැති නම්, මෙය සැමවිටම ඉලක්ක ශ්‍රිතය ක්‍රියාත්මක වන විට කවුළුවට යොමු වේ .

function executeFunctionByName(functionName, context /*, args */) {
    var args = Array.prototype.slice.call(arguments, 2);
    var namespaces = functionName.split(".");
    var func = namespaces.pop();
    for (var i = 0; i < namespaces.length; i++) {
        context = context[namespaces[i]];
    }
    return context[func].apply(context, args);
}

මෙම අනෙක් ප්‍රශ්නයට පිළිතුර ඔබට එය කරන්නේ කෙසේදැයි පෙන්වයි: පයිතන්ගේ ප්‍රදේශවාසීන්ට සමාන ජාවාස්ක්‍රිප්ට් ()?

මූලික වශයෙන්, ඔබට පැවසිය හැකිය

window["foo"](arg1, arg2);

හෝ වෙනත් බොහෝ අය යෝජනා කර ඇති පරිදි, ඔබට eval භාවිතා කළ හැකිය:

eval(fname)(arg1, arg2);

ඔබ අතිශයින්ම අනාරක්ෂිත වුවත්, ඔබ කළ යුත්තේ කුමක්ද යන්න පිළිබඳව ඔබට පූර්ණ විශ්වාසයක් නොමැති නම්.

ඔබට මෙය කළ නොහැකිද:

var codeToExecute = "My.Namespace.functionName()";
var tmpFunc = new Function(codeToExecute);
tmpFunc();

ඔබට මෙම ක්‍රමය භාවිතා කර වෙනත් ඕනෑම ජාවාස්ක්‍රිප්ට් ක්‍රියාත්මක කළ හැකිය.

මම හිතන්නේ මෙය කිරීමට අලංකාර ක්‍රමයක් වන්නේ හැෂ් වස්තුවක ඔබේ කාර්යයන් නිර්වචනය කිරීමයි. එවිට ඔබට එම ශ්‍රිතයන් ගැන හැෂ් වෙතින් නූලක් භාවිතා කළ හැකිය. උදා

var customObject = {
  customFunction: function(param){...}
};

එවිට ඔබට ඇමතිය හැකිය:

customObject['customFunction'](param);

එහිදී CustomFunction යනු ඔබේ වස්තුවෙහි අර්ථ දක්වා ඇති ශ්‍රිතයකට ගැලපෙන නූලකි.

ES6 සමඟ ඔබට නම අනුව පන්ති ක්‍රම වෙත පිවිසිය හැකිය:

class X {
  method1(){
    console.log("1");
  }
  method2(){
    this['method1']();
    console.log("2");
  }
}
let x  = new X();
x['method2']();

ප්‍රතිදානය වනුයේ:

1
2

කරුණු දෙකක්:

• එවාල් වළක්වා ගන්න, එය භයානක හා මන්දගාමී ය

• දෙවනුව, ඔබේ ක්‍රියාකාරිත්වය පවතින්නේ කොතැනද යන්න ගැටළුවක් නොවේ, “ගෝලීය” බව අදාළ නොවේ. x.y.foo()හරහා සක්රිය කළ හැකිය x.y['foo']()හෝ x['y']['foo']()හෝ window['x']['y']['foo'](). ඔබට මේ ආකාරයට දින නියමයක් නොමැතිව දම්වැල දැමිය හැකිය.

සියලුම පිළිතුරු උපකල්පනය කරන්නේ ගෝලීය විෂය පථය (කවුළුව) හරහා කාර්යයන් වෙත ප්‍රවේශ විය හැකි බවයි. කෙසේ වෙතත්, OP මෙම උපකල්පනය සිදු කළේ නැත.

කාර්යයන් දේශීය විෂය පථයක (හෝ වසා දැමීම) ජීවත් වන්නේ නම් සහ වෙනත් දේශීය වස්තුවක් මගින් යොමු නොකෙරේ නම්, අවාසනාව: ඔබට eval()AFAIK භාවිතා කළ යුතුය , ජාවාස්ක්‍රිප්ට් හි දේශීය ක්‍රියාකාරිත්වය ගතිකව අමතන්න බලන්න

ඔබ සිටින ස්ථානය අනුව ඔබටද භාවිතා කළ හැකිය:

this["funcname"]();
self["funcname"]();
window["funcname"]();
top["funcname"]();
globalThis["funcname"]();

හෝ, nodejs වලින්

global["funcname"]()

ඔබට අවශ්‍ය වන්නේ ඔබේ නූල දර්ශකයකට පරිවර්තනය කිරීමයි window[<method name>]. උදාහරණයක්:

var function_name = "string";
function_name = window[function_name];

දැන් ඔබට එය දර්ශකයක් මෙන් භාවිතා කළ හැකිය.

ජේසන් බන්ටිංගේ / ඇලෙක්ස් නසරොව්ගේ විශිෂ් answer පිළිතුරු සඳහා මගේ දායකත්වය මෙන්න, එහිදී ක්‍රෂාලොට් විසින් ඉල්ලා ඇති දෝෂ පරීක්ෂා කිරීම ඇතුළත් වේ.

මෙම (සංක්ෂිප්ත) පෙරවදන අනුව:

a = function( args ) {
    console.log( 'global func passed:' );
    for( var i = 0; i < arguments.length; i++ ) {
        console.log( '-> ' + arguments[ i ] );
    }
};
ns = {};
ns.a = function( args ) {
    console.log( 'namespace func passed:' );
    for( var i = 0; i < arguments.length; i++ ) {
        console.log( '-> ' + arguments[ i ] ); 
    }
};
name = 'nsa';
n_s_a = [ 'Snowden' ];
noSuchAgency = function(){};

ඉන්පසු පහත ශ්‍රිතය:

function executeFunctionByName( functionName, context /*, args */ ) {
    var args, namespaces, func;

    if( typeof functionName === 'undefined' ) { throw 'function name not specified'; }

    if( typeof eval( functionName ) !== 'function' ) { throw functionName + ' is not a function'; }

    if( typeof context !== 'undefined' ) { 
        if( typeof context === 'object' && context instanceof Array === false ) { 
            if( typeof context[ functionName ] !== 'function' ) {
                throw context + '.' + functionName + ' is not a function';
            }
            args = Array.prototype.slice.call( arguments, 2 );

        } else {
            args = Array.prototype.slice.call( arguments, 1 );
            context = window;
        }

    } else {
        context = window;
    }

    namespaces = functionName.split( "." );
    func = namespaces.pop();

    for( var i = 0; i < namespaces.length; i++ ) {
        context = context[ namespaces[ i ] ];
    }

    return context[ func ].apply( context, args );
}

ජාවාස්ක්‍රිප්ට් ශ්‍රිතයක් නමින් ගබඩා කර ඇති නමකින් හෝ ගෝලීයව, තර්ක සමඟ හෝ රහිතව (අරාව වස්තු ඇතුළුව) ඇමතීමට ඔබට ඉඩ සලසයි.

නියැදි ප්‍රතිදානය එය ක්‍රියා කරන ආකාරය පෙන්වයි:

// calling a global function without parms
executeFunctionByName( 'a' );
  /* OUTPUT:
  global func passed:
  */

// calling a global function passing a number (with implicit window context)
executeFunctionByName( 'a', 123 );
  /* OUTPUT:
  global func passed:
  -> 123
  */

// calling a namespaced function without parms
executeFunctionByName( 'ns.a' );
  /* OUTPUT:
  namespace func passed:
  */

// calling a namespaced function passing a string literal
executeFunctionByName( 'ns.a', 'No Such Agency!' );
  /* OUTPUT:
  namespace func passed:
  -> No Such Agency!
  */

// calling a namespaced function, with explicit context as separate arg, passing a string literal and array 
executeFunctionByName( 'a', ns, 'No Such Agency!', [ 007, 'is the man' ] );
  /* OUTPUT:
  namespace func passed:
  -> No Such Agency!
  -> 7,is the man
  */

// calling a global function passing a string variable (with implicit window context)
executeFunctionByName( 'a', name );
  /* OUTPUT:
  global func passed:
  -> nsa
  */

// calling a non-existing function via string literal
executeFunctionByName( 'n_s_a' );
  /* OUTPUT:
  Uncaught n_s_a is not a function
  */

// calling a non-existing function by string variable
executeFunctionByName( n_s_a );
  /* OUTPUT:
  Uncaught Snowden is not a function
  */

// calling an existing function with the wrong namespace reference
executeFunctionByName( 'a', {} );
  /* OUTPUT:
  Uncaught [object Object].a is not a function
  */

// calling no function
executeFunctionByName();
  /* OUTPUT:
  Uncaught function name not specified
  */

// calling by empty string
executeFunctionByName( '' );
  /* OUTPUT:
  Uncaught  is not a function
  */

// calling an existing global function with a namespace reference
executeFunctionByName( 'noSuchAgency', ns );
  /* OUTPUT:
  Uncaught [object Object].noSuchAgency is not a function
  */

ඔබට ගෝලීය ශ්‍රිතයක් වෙනුවට වස්තුවක ශ්‍රිතයක් ඇමතීමට අවශ්‍ය නම් window["functionName"]. ඔබට එය එසේ කළ හැකිය;

var myObject=new Object();
myObject["functionName"](arguments);

උදාහරණයක්:

var now=new Date();
now["getFullYear"]()

පරෙස්සම් වෙන්න!!!

හේතු දෙකක් නිසා ජාවාස්ක්‍රිප්ට් හි නූලක් මඟින් ශ්‍රිතයක් ඇමතීමෙන් වැළකී සිටීමට උත්සාහ කළ යුතුය:

හේතුව 1: සමහර කේත අපැහැදිලි කරන්නන් ඔබේ කේතය විනාශ කරනු ඇත, මන්ද ඔවුන් ක්‍රියාකාරී නම් වෙනස් කරන අතර එමඟින් නූල අවලංගු වේ.

හේතුව 2: මෙම ක්‍රමවේදය භාවිතා කරන කේතය නඩත්තු කිරීම වඩා දුෂ්කර බැවින් නූලකින් හැඳින්වෙන ක්‍රමවල භාවිතයන් සොයා ගැනීම වඩා දුෂ්කර ය.

මෙන්න මගේ Es6 ප්‍රවේශය මඟින් ඔබේ ශ්‍රිතය එහි නම ලෙස හෝ එහි ක්‍රියාකාරී නාමයෙන් ඇමතීමට ඔබට හැකියාව ලබා දෙන අතර විවිධ වර්ගයේ තර්ක ගණනකට විවිධ වර්ගවල ශ්‍රිත වෙත යැවීමට ඔබට හැකි වේ:

function fnCall(fn, ...args)
{
  let func = (typeof fn =="string")?window[fn]:fn;
  if (typeof func == "function") func(...args);
  else throw new Error(`${fn} is Not a function!`);
}


function example1(arg1){console.log(arg1)}
function example2(arg1, arg2){console.log(arg1 + "  and   " + arg2)}
function example3(){console.log("No arguments!")}

fnCall("example1", "test_1");
fnCall("example2", "test_2", "test3");
fnCall(example3);
fnCall("example4"); // should raise an error in console

SetTimeout ගැන සඳහනක් නොකිරීම පුදුමයට කරුණකි.

තර්කයකින් තොරව ශ්‍රිතයක් ක්‍රියාත්මක කිරීමට:

var functionWithoutArguments = function(){
    console.log("Executing functionWithoutArguments");
}
setTimeout("functionWithoutArguments()", 0);

තර්ක සමඟ ක්‍රියා කිරීම සඳහා:

var functionWithArguments = function(arg1, arg2) {
    console.log("Executing functionWithArguments", arg1, arg2);
}
setTimeout("functionWithArguments(10, 20)");

ගැඹුරින් නාම අවකාශ ශ්‍රිතය ක්‍රියාත්මක කිරීම සඳහා:

var _very = {
    _deeply: {
        _defined: {
            _function: function(num1, num2) {
                console.log("Execution _very _deeply _defined _function : ", num1, num2);
            }
        }
    }
}
setTimeout("_very._deeply._defined._function(40,50)", 0);

එබැවින්, අනෙක් අය පැවසූ පරිදි, අනිවාර්යයෙන්ම හොඳම විකල්පය නම්:

window['myfunction'](arguments)

හා සමාන ජේසන් Bunting පවසයි ඔබේ කාර්යය නම වස්තුවක් ඇතුළත් නම් එය වැඩ කරන්නේ නැහැ,:

window['myobject.myfunction'](arguments); // won't work
window['myobject']['myfunction'](arguments); // will work

ඉතින් මගේ ශ්‍රිතයේ අනුවාදය මෙන්න සියලු කාර්යයන් නාමයෙන් ක්‍රියාත්මක කරනු ඇත (වස්තුවක් ඇතුළුව හෝ නැත):

my = {
    code : {
        is : {
            nice : function(a, b){ alert(a + "," + b); }
        }
    }
};

guy = function(){ alert('awesome'); }

function executeFunctionByName(str, args)
{
    var arr = str.split('.');
    var fn = window[ arr[0] ];
    
    for (var i = 1; i < arr.length; i++)
    { fn = fn[ arr[i] ]; }
    fn.apply(window, args);
}

executeFunctionByName('my.code.is.nice', ['arg1', 'arg2']);
executeFunctionByName('guy');

  let t0 = () => { alert('red0') }
  var t1 = () =>{ alert('red1') }
  var t2 = () =>{ alert('red2') }
  var t3 = () =>{ alert('red3') }
  var t4 = () =>{ alert('red4') }
  var t5 = () =>{ alert('red5') }
  var t6 = () =>{ alert('red6') }

  function getSelection(type) {
    var evalSelection = {
      'title0': t0,
      'title1': t1,
      'title2': t2,
      'title3': t3,
      'title4': t4,
      'title5': t5,
      'title6': t6,
      'default': function() {
        return 'Default';
      }
    };
    return (evalSelection[type] || evalSelection['default'])();
  }
  getSelection('title1');

තවත් OOP විසඳුමක් ...

ජේසන් සහ ඇලෙක්ස්ගේ සටහන් පිළිබඳ තවත් එක් විස්තරයක්. සන්දර්භයට පෙරනිමි අගයක් එක් කිරීම ප්‍රයෝජනවත් බව මට පෙනී ගියේය. context = context == undefined? window:context;ශ්‍රිතයේ ආරම්භයේදීම තබන්න . ඔබ windowකැමති ඕනෑම සන්දර්භයකට වෙනස් කළ හැකිය , එවිට ඔබේ පෙරනිමි සන්දර්භය තුළ ඔබ මෙය අමතන සෑම අවස්ථාවකම එකම විචල්‍යයකින් සමත් වීමට අවශ්‍ය නොවේ.

ජේසන් බන්ටිංගේ පිළිතුරට එකතු කිරීම සඳහා, ඔබ නෝඩ්ජ් හෝ වෙනත් දෙයක් භාවිතා කරන්නේ නම් (මෙය ඩොම් ජේඑස් වලද ක්‍රියාත්මක වේ), ඔබට thisඒ වෙනුවට භාවිතා කළ හැකිය window(මතක තබා ගන්න: එවාල් නපුර :

this['fun'+'ctionName']();

මගේ කේතයේ බොහෝ සමාන දෙයක් තිබේ. තෙවන පාර්ශවීය පුස්තකාලයක් සඳහා ඇමතුමක් ලෙස මට යැවිය යුතු ශ්‍රිත නාමයක් අඩංගු සේවාදායකයෙන් ජනනය කරන ලද නූලක් මා සතුව ඇත. ඒ නිසා මට කේතයක් ඇති අතර එය නූල ගෙන ශ්‍රිතයට “දර්ශකයක්” ලබා දෙයි, නැතහොත් එය සොයාගත නොහැකි නම් ශුන්‍ය වේ.

මගේ විසඳුම " ජේසන් බන්ටිංගේ ඉතා ප්‍රයෝජනවත් කාර්යයට " බොහෝ සෙයින් සමාන විය . එය ස්වයංක්රීය-ක්රියාත්මක නොවන මුත්, හා සන්දර්භය සෑම විටම කවුළුව මත වේ. නමුත් මෙය පහසුවෙන් වෙනස් කළ හැකිය.

මෙය යමෙකුට ප්‍රයෝජනවත් වනු ඇතැයි අපේක්‍ෂා කරමු.

/**
 * Converts a string containing a function or object method name to a function pointer.
 * @param  string   func
 * @return function
 */
function getFuncFromString(func) {
    // if already a function, return
    if (typeof func === 'function') return func;

    // if string, try to find function or method of object (of "obj.func" format)
    if (typeof func === 'string') {
        if (!func.length) return null;
        var target = window;
        var func = func.split('.');
        while (func.length) {
            var ns = func.shift();
            if (typeof target[ns] === 'undefined') return null;
            target = target[ns];
        }
        if (typeof target === 'function') return target;
    }

    // return null if could not parse
    return null;
}

ඔබට සංකීර්ණ අතරමැදි කාර්යයන් අවශ්‍ය යැයි මම නොසිතමි. නැතහොත් කවුළුව වැනි ගෝලීය විචල්‍යයන් මත රඳා පවතී.

function fun1(arg) {
  console.log(arg);
}

function fun2(arg) {
  console.log(arg);
}

const operations = {
  fun1,
  fun2
};

operations["fun1"]("Hello World");
operations.fun2("Hello World");

// You can use intermediate variables, if you like
let temp = "fun1";
operations[temp]("Hello World");

ආනයනික කාර්යයන් සමඟ ද එය ක්‍රියා කරනු ඇත:

// mode.js
export function fun1(arg) {
  console.log(arg);
}

export function fun2(arg) {
  console.log(arg);
}

// index.js
import { fun1, fun2 } from "./mod";

const operations = {
  fun1,
  fun2
};

operations["fun1"]("Hello World");
operations["fun2"]("Hello World");

එය දේපල ප්‍රවේශය භාවිතා කරන බැවින්, ඔබ මෙහි සොයා ගන්නා සමහර පිළිතුරු වලට පටහැනිව, එය අවම කිරීම හෝ අපැහැදිලි වීම නොනැසී පවතිනු ඇත.

ඉතා ප්‍රයෝජනවත් ක්‍රමයක් ද තිබේ.

http://devlicio.us/blogs/sergio_pereira/archive/2009/02/09/javascript-5-ways-to-call-a-function.aspx

var arrayMaker = {  
    someProperty: 'some value here',  
    make: function (arg1, arg2) {  
        return [ this, arg1, arg2 ];  
    },
    execute: function_name
};

වෙනත් උපක්‍රමයක් සඳහන් කිරීම මට විරුද්ධ විය නොහැක, එය ඔබට නොදන්නා තර්ක ගණනක් තිබේ නම් එය ක්‍රියාකාරී නාමය අඩංගු නූලෙහි කොටසක් ලෙස සම්මත වේ. උදාහරණයක් වශයෙන්:

var annoyingstring = 'call_my_func(123, true, "blah")';

ඔබගේ ජාවාස්ක්‍රිප්ට් HTML පිටුවක ක්‍රියාත්මක වන්නේ නම්, ඔබට අවශ්‍ය වන්නේ අදෘශ්‍යමාන සබැඳියකි; ඔබට ගුණාංගයට නූලක් යැවිය හැකි අතර onclick, ඇමතුම් clickක්‍රමය.

<a href="#" id="link_secret"><!-- invisible --></a>

$('#link_secret').attr('onclick', annoyingstring);
$('#link_secret').click();

නැතහොත් <a>ධාවන වේලාවේදී මූලද්‍රව්‍යය සාදන්න .

පහසුම ක්‍රමය නම් මූලද්‍රව්‍යය ඇති ආකාරයට ප්‍රවේශ වීමයි

window.ClientSideValidations.forms.location_form

සමාන වේ

window.ClientSideValidations.forms['location_form']

ඔබට ජාවාස්ක්‍රිප්ට් ශ්‍රිතය ඇමතිය eval("functionname as string")හැකිය. පහත පරිදි: (eval යනු පිරිසිදු ජාවාස්ක්‍රිප්ට් ශ්‍රිතයකි)

function testfunc(){
    return "hello world";
}

$( document ).ready(function() {

     $("div").html(eval("testfunc"));
});

වැඩ කරන උදාහරණය: https://jsfiddle.net/suatatan/24ms0fna/4/

මෙය මා වෙනුවෙන් වැඩ කරයි:

var command = "Add";
var tempFunction = new Function("Arg1","Arg2", "window." + command + "(Arg1,Arg2)");
tempFunction(x,y);

මම හිතනවා මේක වැඩ කරයි කියලා.

භාවිතයෙන් තොරව eval('function()')ඔබට නව ශ්‍රිතයක් නිර්මාණය කළ හැකිය new Function(strName). පහත කේතය FF, Chrome, IE භාවිතයෙන් පරීක්ෂා කරන ලදී.

<html>
<body>
<button onclick="test()">Try it</button>
</body>
</html>
<script type="text/javascript">

  function test() {
    try {    
        var fnName = "myFunction()";
        var fn = new Function(fnName);
        fn();
      } catch (err) {
        console.log("error:"+err.message);
      }
  }

  function myFunction() {
    console.log('Executing myFunction()');
  }

</script>

use this

function executeFunctionByName(functionName, context /*, args */) {
      var args = [].slice.call(arguments).splice(2);
      var namespaces = functionName.split(".");
      var func = namespaces.pop();
      for(var i = 0; i < namespaces.length; i++) {
        context = context[namespaces[i]];
      }
      return context[func].apply(context, args);
    }

මූලික බලන්න:

var namefunction = 'jspure'; // String

function jspure(msg1 = '', msg2 = '') { 
  console.log(msg1+(msg2!=''?'/'+msg2:''));
} // multiple argument

// Results ur test
window[namefunction]('hello','hello again'); // something...
eval[namefunction] = 'hello'; // use string or something, but its eval just one argument and not exist multiple

පවත්නා වෙනත් වර්ගයේ ශ්‍රිතය පංතිය වන අතර උදාහරණ ලෙස නිල්ස් පීටර්සෝන් බලන්න

ඉතා ප්‍රයෝජනවත් පිළිතුරට ස්තූතියි. මම පාවිච්චි කරන්නේ ජේසන් බන්ටිංගේ ක්‍රියාකාරිත්වය මගේ ව්‍යාපෘති වල කරමි.

විකල්ප කල් ඉකුත් වීමක් සමඟ එය භාවිතා කිරීම සඳහා මම එය දිගු කළෙමි, මන්ද කල් ඉකුත්වීම සැකසීමේ සාමාන්‍ය ක්‍රමය ක්‍රියාත්මක නොවන බැවිනි. අභිෂේකිස්නොට්ගේ ප්‍රශ්නය බලන්න

function executeFunctionByName(functionName, context, timeout /*, args */ ) {
	var args = Array.prototype.slice.call(arguments, 3);
	var namespaces = functionName.split(".");
	var func = namespaces.pop();
	for (var i = 0; i < namespaces.length; i++) {
		context = context[namespaces[i]];
	}
	var timeoutID = setTimeout(
		function(){ context[func].apply(context, args)},
		timeout
	);
    return timeoutID;
}

var _very = {
    _deeply: {
        _defined: {
            _function: function(num1, num2) {
                console.log("Execution _very _deeply _defined _function : ", num1, num2);
            }
        }
    }
}

console.log('now wait')
executeFunctionByName("_very._deeply._defined._function", window, 2000, 40, 50 );