कार्य का जावास्क्रिप्ट सरणी

Question

var array_of_functions = [
    first_function('a string'),
    second_function('a string'),
    third_function('a string'),
    forth_function('a string')
]

array_of_functions[0];

यह आशय के अनुसार काम नहीं करता है क्योंकि सरणी में प्रत्येक फ़ंक्शन को तब बनाया जाता है जब सरणी बनाई जाती है।

सरणी में किसी भी कार्य को करने का उचित तरीका क्या है:

array_of_functions[0];  // or, array_of_functions[1] etc.

धन्यवाद!

Comments

क्या 'a string'समय सरणी से भर जाता है पर जाना जाने की जरूरत है, या समारोह के फोन करने वाले में इसे पारित कर सकते हैं?

— वर्धमान ताजा

जो आप पूरा करने की कोशिश कर रहे हैं, उस पर और अधिक विवरण प्राप्त करना मुझे अच्छा लगेगा, क्योंकि इससे निपटने का एक बेहतर तरीका हो सकता है।

— जेफ

"कार्य की सरणी" - या जैसा कि हम इसे एक विधि के साथ एक वस्तु के रूप में कॉल करना पसंद करते हैं

— सिम्बियन

क्या आपको नहीं लगता कि आपको अधिक विवरण देना चाहिए? इसे संभालने का एक बेहतर तरीका हो सकता है ..

— IcyFlame

Answer 1

var array_of_functions = [
    first_function,
    second_function,
    third_function,
    forth_function
]

और फिर जब आप सरणी में दिए गए फ़ंक्शन को निष्पादित करना चाहते हैं:

array_of_functions[0]('a string');

Comments

टिप: ()बाद में रखना याद रखें array_of_functions[0], भले ही वह खाली हो। मैं 20min की तरह सिर्फ 'क्यों काम नहीं किया' खोजने के लिए खर्च करता हूं।

— होरासियो

आकर्षण की तरह काम किया!

— मोशे नेल्डा

Unction फर्स्ट फंक्शन ’जैसे स्ट्रिंग वैल्यू को पास करके आप किसी फंक्शन का इंडेक्स कैसे प्राप्त करेंगे ताकि यह गतिशील हो सके?

— ओ'डेन ब्रिसेट

Answer 2

मुझे लगता है कि मूल पोस्टर को पूरा करने का यही मतलब है:

var array_of_functions = [
    function() { first_function('a string') },
    function() { second_function('a string') },
    function() { third_function('a string') },
    function() { fourth_function('a string') }
]

for (i = 0; i < array_of_functions.length; i++) {
    array_of_functions[i]();
}

उम्मीद है कि यह दूसरों की मदद करेगा (जैसे मुझे 20 मिनट पहले :-) एक सरणी में JS फ़ंक्शन को कॉल करने के तरीके के बारे में कोई संकेत खोजने के लिए।

Comments

यह वही है जो मुझे चाहिए था, क्योंकि यह मुझे पैरामीटर कॉल को बदलने की अनुमति देता है, यह मानते हुए कि मेरे कार्य सभी समान पैरामीटर नहीं लेते हैं: P

— Jem

Answer 3

जो आप पूरा करने की कोशिश कर रहे हैं, उसके अधिक विवरण के बिना, हम थोड़े अनुमान लगा रहे हैं। लेकिन आप इस तरह से कुछ करने के लिए ऑब्जेक्ट नोटेशन का उपयोग करके दूर हो सकते हैं ...

var myFuncs = {
  firstFunc: function(string) {
    // do something
  },

  secondFunc: function(string) {
    // do something
  },

  thirdFunc: function(string) {
    // do something
  }
}

और उनमें से एक को कॉल करने के लिए ...

myFuncs.firstFunc('a string')

Comments

मुझे लगता है कि यह अधिक डेवलपर अनुकूल है क्योंकि हमें फ़ंक्शन के सूचकांक को याद रखने की आवश्यकता नहीं है। और यह भी, यदि हम किसी फ़ंक्शन को विशिष्ट इंडेक्स पर धकेलना चाहते हैं, तो यह उसके आगे सभी फ़ंक्शन के इंडेक्स को बदलने का कारण बनता है। तो बेहतर है कि इसका उपयोग करें

— dd619

Answer 4

या केवल:

var myFuncs = {
  firstFun: function(string) {
    // do something
  },

  secondFunc: function(string) {
    // do something
  },

  thirdFunc: function(string) {
    // do something
  }
}

Answer 5

मैं मूल रूप से यहाँ वर्णितshift() जावास्क्रिप्ट विधि का उपयोग करके एक एरे के भीतर विभिन्न कार्यों को निष्पादित करने के लिए एक आसान तरीका पोस्ट करके इस धागे को पूरक करूंगा

  var a = function(){ console.log("this is function: a") }
  var b = function(){ console.log("this is function: b") }
  var c = function(){ console.log("this is function: c") }

  var foo = [a,b,c];

  while (foo.length){
     foo.shift().call();
  }

Answer 6

यह मूल रूप से समान है, Darin Dimitrov'sलेकिन यह दिखाता है कि आप इसका उपयोग गतिशील रूप से कैसे कर सकते हैं और कार्यों और तर्कों को स्टोर कर सकते हैं। मुझे आशा है कि यह आपके लिए उपयोगी है :)

var argsContainer = ['hello', 'you', 'there'];
var functionsContainer = [];

for (var i = 0; i < argsContainer.length; i++) {
var currentArg = argsContainer[i]; 

  functionsContainer.push(function(currentArg){
    console.log(currentArg);
  });
};

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

Comments

आपका जवाब जोड़ना ठीक है, चाहे उसमें कितने ही लोग हों। लेकिन कुछ स्पष्टीकरण जोड़ना बेहतर है जो दूसरों की तुलना में इसके बारे में अलग / बेहतर है

— बोडज़ोन

Answer 7

ऊपर हमने कुछ को पुनरावृति के साथ देखा। चलो एक ही बात का उपयोग कर forEach:

var funcs = [function () {
        console.log(1)
  },
  function () {
        console.log(2)
  }
];

funcs.forEach(function (func) {
  func(); // outputs  1, then 2
});
//for (i = 0; i < funcs.length; i++) funcs[i]();

Answer 8

यह सही है

var array_of_functions = {
            "all": function(flag) { 
                console.log(1+flag); 
              },
                "cic": function(flag) { 
                console.log(13+flag); 
              }                     
        };

array_of_functions.all(27);
array_of_functions.cic(7);

Comments

क्या आप सुनिश्चित हैं कि यह वह प्रश्न है जिस पर आप उत्तर देना चाहते थे? यह संबंधित नहीं है।

— बरगी

@ बर्गी वास्तव में, यह है। जवाब के operaसाथ बदलें array_of_functionsऔर आप एक ही बात है। अभी के बारे में कैसे?

— जेसी

@ जेसे धन्यवाद, अब मुझे कोड पोस्ट करने का एक विचार है, यह मेरी पहली प्रतिक्रिया है।

— लियोनार्डो सियासियो

लेकिन ओपी के पास एक सरणी थी, जबकि यह कुछ ऑब्जेक्ट (विषम संपत्ति नामों के साथ) है? और इस जवाब की क्या खबर है, क्यों न सिर्फ पजेसबेरा या रॉबिन के एक को उखाड़ फेंके?

— बर्गी

चर का भ्रामक नाम। कार्यों की एक सरणी नहीं है, लेकिन कार्यों का एक उद्देश्य

— Craicerjack

Answer 9

यदि आप कॉलबैक को गतिशील रूप से पारित करने की कोशिश कर रहे हैं जैसे आप एक तर्क के रूप में एक ही वस्तु को पारित कर सकते हैं। यह आपको बहुत अधिक नियंत्रण प्रदान करता है कि आप किस कार्य को किसी भी पैरामीटर के साथ निष्पादित करना चाहते हैं।

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

function func_two(arg) {
    console.log(arg+' make this different')
};

var obj = {
    callbacks: [func_one, func_two],
    params: ["something", "something else"];
};

function doSomething(obj) {
    var n = obj.counter
    for (n; n < (obj.callbacks.length - obj.len); n++) {
        obj.callbacks[n](obj.params[n]);
    }
};

obj.counter = 0;
obj.len = 0;
doSomething(obj); 

//something
//something else make this different

obj.counter = 1;
obj.len = 0;
doSomething(obj);

//something else make this different

Answer 10

ES6 कॉलबैक an के माध्यम से कई कार्यों का निष्पादन

const f = (funs) => {
  funs().forEach((fun) => fun)
}

f(() => [
  console.log(1),
  console.log(2),
  console.log(3)
])

Answer 11

शायद यह किसी की मदद कर सकता है।

<!DOCTYPE html>
<html>
<head lang="en">
    <meta charset="UTF-8">
    <title></title>
    <script type="text/javascript">
        window.manager = {
            curHandler: 0,
            handlers  : []
        };

        manager.run = function (n) {
            this.handlers[this.curHandler](n);
        };

        manager.changeHandler = function (n) {
            if (n >= this.handlers.length || n < 0) {
                throw new Error('n must be from 0 to ' + (this.handlers.length - 1), n);
            }
            this.curHandler = n;
        };

        var a = function (n) {
            console.log("Handler a. Argument value is " + n);
        };

        var b = function (n) {
            console.log("Handler b. Argument value is " + n);
        };

        var c = function foo(n) {
            for (var i=0; i<n; i++) {
                console.log(i);
            }
        };

        manager.handlers.push(a);
        manager.handlers.push(b);
        manager.handlers.push(c);
    </script>
</head>
<body>
<input type="button" onclick="window.manager.run(2)" value="Run handler with parameter 2">
<input type="button" onclick="window.manager.run(4)" value="Run handler with parameter 4">
<p>
<div>
    <select name="featured" size="1" id="item1">
        <option value="0">First handler</option>
        <option value="1">Second handler</option>
        <option value="2">Third handler</option>
    </select>
    <input type="button" onclick="manager.changeHandler(document.getElementById('item1').value);" value="Change handler">
</div>
</p>
</body>
</html>

Answer 12

उन्हें चलाने के लिए एक छोटा तरीका:

[first_function, ..., nth_function].forEach (function(f) {
    f('a string');
}); 

Answer 13

फ़ंक्शन के इन सरणी की समस्या "सरणी रूप" में नहीं है, लेकिन जिस तरह से इन कार्यों को कहा जाता है ... तो ... इस प्रयास करें .. एक सरल eval () के साथ ...

array_of_function = ["fx1()","fx2()","fx3()",.."fxN()"]
var zzz=[];
for (var i=0; i<array_of_function.length; i++)
     { var zzz += eval( array_of_function[i] ); }

यह यहाँ काम करता है, जहाँ कुछ भी ऊपरी तौर पर घर पर काम नहीं कर रहा था ... उम्मीद है कि यह मदद करेगा

Comments

क्या आप बता सकते हैं कि अन्य उत्तर आपके लिए काम क्यों नहीं करते हैं, और आपका क्यों करता है? धन्यवाद!

— फैबियो का कहना है कि

यह कभी भी मुझे वापस लौटाता है, अपरिभाषित समारोह, या वे मूल रूप से जावास्क्रिप्ट द्वारा नहीं निकाले जाते हैं ... (मुझे नहीं पता, लेकिन इससे मेरी समस्या हल हो गई)

— क्वेटज़ल

भयानक सलाह। stackoverflow.com/questions/86513/…

— आंद्रेई सविन

हाँ, भयानक, हमेशा की तरह, लेकिन शॉट सॉल्यूशन, और विशेष रूप से उपयोग करने के लिए बहुत आसान है अगर एक "इनपुट" से बहुत दूर ... यहाँ यह सिर्फ एक छोटे तरीके से एक आंतरिक जावास्क्रिप्ट असंभव हल ...

— Quetzal

Answer 14

Function.prototype.bind () का उपयोग करना

var array_of_functions = [
        first_function.bind(null,'a string'),
        second_function.bind(null,'a string'),
        third_function.bind(null,'a string'),
        forth_function.bind(null,'a string')
    ]

Answer 15

मुझे इसे हल करने की कोशिश में कई समस्याएं हैं ... स्पष्ट कोशिश की, लेकिन काम नहीं किया। यह किसी भी तरह एक खाली फ़ंक्शन को जोड़ देता है।

array_of_functions.push(function() { first_function('a string') });

मैंने इसे स्ट्रिंग के एक सरणी का उपयोग करके हल किया, और बाद में eval के साथ:

array_of_functions.push("first_function('a string')");

for (var Func of array_of_functions) {
   eval(Func);
   }

Answer 16

आह यार इतने अजीब जवाब हैं ...

const execute = (fn) => fn()
const arrayOfFunctions = [fn1, fn2, fn3]

const results = arrayOfFunctions.map(execute)

or if you want to sequentially feed each functions result to the next:
compose(fn3, fn2, fn1)

compose डिफ़ॉल्ट रूप से समर्थित नहीं है, लेकिन रमाडा, लॉश, या यहां तक ​​कि रिडक्स जैसे पुस्तकालय भी हैं जो इस उपकरण को प्रदान करते हैं

Answer 17

आपको ऊपर कुछ उत्तर मिले। यह उसी का एक और संस्करण है।

var dictFun = {
     FunOne: function(string) {
     console.log("first function");
  },

   FuncTwo: function(string) {
   console.log("second function");
 },

  FuncThree: function(string) {
   console.log("third function");
}

}

Comments

सवाल एक के लिए था सरणी कार्यों की, नहीं एक वस्तु।

— त्रिनोट

Answer 18

/* PlanetGreeter */

class PlanetGreeter {
    hello   : { () : void; } [] = [];
    planet_1 : string = "World";
    planet_2 : string = "Mars";
    planet_3 : string = "Venus";
    planet_4 : string = "Uranus";
    planet_5 : string = "Pluto";
    constructor() {
        this.hello.push( () => { this.greet(this.planet_1); } );
        this.hello.push( () => { this.greet(this.planet_2); } );
        this.hello.push( () => { this.greet(this.planet_3); } );
        this.hello.push( () => { this.greet(this.planet_4); } );
        this.hello.push( () => { this.greet(this.planet_5); } );
    } 
    greet(a: string) : void { alert("Hello " + a); }
    greetRandomPlanet() : void { 
        this.hello [ Math.floor( 5 * Math.random() ) ] (); 
    } 
} 
new PlanetGreeter().greetRandomPlanet();