JavaScript
कार्य

परिचय

वाक्य - विन्यास

• फ़ंक्शन उदाहरण (x) {रिटर्न x}

• var उदाहरण = function (x) {रिटर्न x}

• (समारोह() { ... })(); // तुरंत लागू समारोह अभिव्यक्ति (IIFE)

• var उदाहरण = नया उदाहरण (x);

• तरीके

• fn.apply (valueForThis [, arrayOfArgs])

• fn.bind (valueForThis [, arg1 [, arg2, ...]]]

• fn.call (valueForThis [, arg1 [, arg2, ...]]]

• ES2015 + (ES6 +):

• const उदाहरण = x => {रिटर्न x}; // एरो फंक्शन स्पष्ट रिटर्न

• const उदाहरण = x => x; // एरो फंक्शन इंपैक्ट रिटर्न

• const उदाहरण = (x, y, z) => {...} // एरो फ़ंक्शन कई तर्क देता है

• (() => {...}) (); // IIFE एक तीर फ़ंक्शन का उपयोग करके

टिप्पणियों

एक चर के रूप में कार्य

एक सामान्य कार्य घोषणा इस तरह दिखाई देती है:

function foo(){
}

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

var name = 'Cameron';
var spouse;

if ( name === 'Taylor' ) spouse = { name: 'Jordan' };
else if ( name === 'Cameron' ) spouse = { name: 'Casey' };

var spouseName = spouse.name;

जावास्क्रिप्ट में, आप कार्यों के साथ एक ही काम कर सकते हैं:

// Example 1
var hashAlgorithm = 'sha1';
var hash;

if ( hashAlgorithm === 'sha1' ) hash = function(value){ /*...*/ };
else if ( hashAlgorithm === 'md5' ) hash = function(value){ /*...*/ };

hash('Fred');

ऊपर दिए गए उदाहरण में, hash एक सामान्य चर है। इसे एक फ़ंक्शन का संदर्भ दिया जाता है, जिसके बाद यह फ़ंक्शन संदर्भों को एक सामान्य फ़ंक्शन घोषणा की तरह, कोष्ठक का उपयोग करके लागू किया जा सकता है।

ऊपर दिए गए उदाहरण अनाम फ़ंक्शंस ... फ़ंक्शंस जिनमें अपना नाम नहीं है। नामित कार्यों को संदर्भित करने के लिए आप चर का उपयोग भी कर सकते हैं। ऊपर दिए गए उदाहरण को फिर से लिखा जा सकता है:

// Example 2
var hashAlgorithm = 'sha1';
var hash;

if ( hashAlgorithm === 'sha1' ) hash = sha1Hash;
else if ( hashAlgorithm === 'md5' ) hash = md5Hash;

hash('Fred');

function md5Hash(value){
    // ...
}

function sha1Hash(value){
    // ...
}

या, आप ऑब्जेक्ट प्रॉपर्टीज से फंक्शन रेफरेंस असाइन कर सकते हैं:

// Example 3
var hashAlgorithms = {
    sha1: function(value) { /**/ },
    md5: function(value) { /**/ }
};

var hashAlgorithm = 'sha1';
var hash;

if ( hashAlgorithm === 'sha1' ) hash = hashAlgorithms.sha1;
else if ( hashAlgorithm === 'md5' ) hash = hashAlgorithms.md5;

hash('Fred');

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

// Example 4
var a = getValue;
var b = a; // b is now a reference to getValue.
var c = b(); // b is invoked, so c now holds the value returned by getValue (41)

function getValue(){
    return 41;
}

किसी फ़ंक्शन का संदर्भ किसी अन्य मान की तरह है। जैसा कि आपने देखा है, एक संदर्भ एक चर को सौंपा जा सकता है, और उस चर का संदर्भ मूल्य बाद में अन्य चर को सौंपा जा सकता है। आप किसी फ़ंक्शन के संदर्भ में किसी अन्य मान को पास कर सकते हैं, जिसमें एक फ़ंक्शन के संदर्भ को किसी अन्य फ़ंक्शन के रिटर्न मान के रूप में पास करना शामिल है। उदाहरण के लिए:

// Example 5
// getHashingFunction returns a function, which is assigned
// to hash for later use:
var hash = getHashingFunction( 'sha1' );
// ...
hash('Fred');


// return the function corresponding to the given algorithmName
function getHashingFunction( algorithmName ){
    // return a reference to an anonymous function
    if (algorithmName === 'sha1') return function(value){ /**/ };
    // return a reference to a declared function
    else if (algorithmName === 'md5') return md5;
}

function md5Hash(value){
    // ...
}

इसे लागू करने के लिए आपको किसी चर के लिए एक फ़ंक्शन संदर्भ निर्दिष्ट करने की आवश्यकता नहीं है। यह उदाहरण, उदाहरण 5 का निर्माण, getHashingFunction को कॉल करेगा और फिर तुरंत लौटाए गए फ़ंक्शन को आमंत्रित करेगा और इसके रिटर्न मान को hashedValue में पास करेगा।

// Example 6
var hashedValue = getHashingFunction( 'sha1' )( 'Fred' );

उत्थापन पर एक नोट

ध्यान रखें कि, सामान्य फ़ंक्शन घोषणाओं के विपरीत, चर जो संदर्भ फ़ंक्शन "लहराए" नहीं हैं। उदाहरण 2 में, md5Hash और sha1Hash फ़ंक्शन स्क्रिप्ट के निचले भाग में परिभाषित किए गए हैं, लेकिन तुरंत हर जगह उपलब्ध हैं। कोई फर्क नहीं पड़ता कि आप किसी फ़ंक्शन को कैसे परिभाषित करते हैं, दुभाषिया इसे "स्कोप्स" करता है, इसे इसके दायरे के शीर्ष पर रखता है, जिससे यह तुरंत उपलब्ध हो जाता है। यह चर परिभाषाओं के मामले में नहीं है, इसलिए निम्नलिखित जैसा कोड टूट जाएगा:

var functionVariable;

hoistedFunction(); // works, because the function is "hoisted" to the top of its scope
functionVariable(); // error: undefined is not a function.

function hoistedFunction(){}
functionVariable = function(){};

अनाम क्रिया

एक अनाम फ़ंक्शन को परिभाषित करना

जब कोई फ़ंक्शन परिभाषित होता है, तो आप अक्सर इसे एक नाम देते हैं और फिर उस नाम का उपयोग करके इसे लागू करते हैं, जैसे:

foo();

function foo(){
    // ...
}

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

function() {
    // ...
}

जब कोई फ़ंक्शन बिना नाम के परिभाषित किया जाता है, तो इसे एक अनाम फ़ंक्शन के रूप में जाना जाता है। फ़ंक्शन को मेमोरी में संग्रहीत किया जाता है, लेकिन रनटाइम स्वचालित रूप से आपके लिए इसका संदर्भ नहीं बनाता है। पहली नज़र में, ऐसा प्रतीत हो सकता है कि इस तरह की चीज़ का कोई उपयोग नहीं होगा, लेकिन ऐसे कई परिदृश्य हैं जहां अनाम कार्य बहुत सुविधाजनक हैं।

एक चर के लिए एक बेनामी समारोह निरुपित

अनाम फ़ंक्शंस का एक बहुत ही सामान्य उपयोग उन्हें एक चर में असाइन करना है:

var foo = function(){ /*...*/ };

foo();

अनाम फ़ंक्शंस का यह उपयोग फ़ंक्शंस में एक चर के रूप में अधिक विस्तार से कवर किया गया है

एक अन्य फ़ंक्शन के लिए एक पैरामीटर के रूप में एक बेनामी फ़ंक्शन की आपूर्ति करना

कुछ फ़ंक्शन पैरामीटर के रूप में फ़ंक्शन के संदर्भ को स्वीकार कर सकते हैं। इन्हें कभी-कभी "निर्भरता इंजेक्शन" या "कॉलबैक" के रूप में संदर्भित किया जाता है, क्योंकि यह फ़ंक्शन को आपके कॉल को आपके कोड में "कॉल बैक" करने की अनुमति देता है, जिससे आपको कॉल करने के तरीके को बदलने का अवसर मिलता है। उदाहरण के लिए, ऐरे ऑब्जेक्ट का मानचित्र फ़ंक्शन आपको किसी सरणी के प्रत्येक तत्व पर पुनरावृति करने की अनुमति देता है, फिर प्रत्येक तत्व में एक परिवर्तन फ़ंक्शन लागू करके एक नई सरणी का निर्माण करता है।

var nums = [0,1,2];
var doubledNums = nums.map( function(element){ return element * 2; } ); // [0,2,4]

एक नामित फ़ंक्शन बनाने के लिए यह थकाऊ, मैला और अनावश्यक होगा, जो केवल एक ही स्थान पर आवश्यक फ़ंक्शन के साथ आपके दायरे को अव्यवस्थित कर देगा और आपके कोड के प्राकृतिक प्रवाह और रीडिंग को तोड़ देगा (एक सहयोगी को आपका कोड खोजने के लिए इस कोड को छोड़ना होगा यह समझने के लिए कि क्या चल रहा है)।

दूसरे फंक्शन से बेनामी फंक्शन लौटाना

कभी-कभी किसी फ़ंक्शन को दूसरे फ़ंक्शन के परिणामस्वरूप वापस करना उपयोगी होता है। उदाहरण के लिए:

var hash = getHashFunction( 'sha1' );
var hashValue = hash( 'Secret Value' );

function getHashFunction( algorithm ){

    if ( algorithm === 'sha1' ) return function( value ){ /*...*/ };
    else if ( algorithm === 'md5' ) return function( value ){ /*...*/ };

}

तुरंत एक अनाम फ़ंक्शन को लागू करना

कई अन्य भाषाओं के विपरीत, जावास्क्रिप्ट में स्कूपिंग कार्य-स्तर है, न कि ब्लॉक-स्तर। ( फंक्शन स्कूपिंग देखें)। हालांकि, कुछ मामलों में, एक नया दायरा बनाना आवश्यक है। उदाहरण के लिए, एक नया स्कोप बनाना आम बात है जब कोड को <script> टैग के माध्यम से जोड़ा जा सकता है, बजाय इसके कि वैरिएबल नामों को वैश्विक स्कोप में परिभाषित किया जाए (जो आपके वैरिएबल नामों से टकराने वाली अन्य लिपियों के जोखिम को चलाता है)। इस स्थिति को संभालने के लिए एक सामान्य तरीका एक नए अनाम फ़ंक्शन को परिभाषित करना है और फिर तुरंत इसे लागू करना है, गुमनाम फ़ंक्शन के दायरे के भीतर आपको चर को सुरक्षित रूप से छिपाते हुए और एक लीक फ़ंक्शन नाम के माध्यम से आपके कोड को तृतीय-पक्ष के लिए सुलभ बनाने के बिना। उदाहरण के लिए:

<!-- My Script -->
<script>
function initialize(){
    // foo is safely hidden within initialize, but...
    var foo = '';
}

// ...my initialize function is now accessible from global scope.
// There's a risk someone could call it again, probably by accident.
initialize();
</script>

<script>
// Using an anonymous function, and then immediately
// invoking it, hides my foo variable and guarantees
// no one else can call it a second time.
(function(){
    var foo = '';
}()) // <--- the parentheses invokes the function immediately
</script>

सेल्फ रेफरेंशियल बेनामी फंक्शंस

कभी-कभी यह एक अनाम फ़ंक्शन के लिए उपयोगी होता है जो स्वयं को संदर्भित करने में सक्षम होता है। उदाहरण के लिए, फ़ंक्शन को स्वयं को पुन: कॉल करने या गुणों को जोड़ने की आवश्यकता हो सकती है। यदि फ़ंक्शन अनाम है, हालांकि, यह बहुत मुश्किल हो सकता है क्योंकि इसके लिए उस चर के ज्ञान की आवश्यकता होती है जिसे फ़ंक्शन को सौंपा गया है। यह आदर्श समाधान से कम है:

var foo = function(callAgain){
    console.log( 'Whassup?' );
    // Less then ideal... we're dependent on a variable reference...
    if (callAgain === true) foo(false);
};

foo(true);

// Console Output:
// Whassup?
// Whassup?

// Assign bar to the original function, and assign foo to another function.
var bar = foo;
foo = function(){
    console.log('Bad.')
};

bar(true);

// Console Output:
// Whassup?
// Bad.

यहाँ आशय अनाम कार्य के लिए स्वयं को फिर से बुलाने का था, लेकिन जब फू का मूल्य बदलता है, तो आप बग को ट्रेस करने के लिए संभावित रूप से कठिन हो जाते हैं।

इसके बजाय, हम अनाम फ़ंक्शन को एक निजी नाम देकर खुद को संदर्भ दे सकते हैं, जैसे:

var foo = function myself(callAgain){
    console.log( 'Whassup?' );
    // Less then ideal... we're dependent on a variable reference...
    if (callAgain === true) myself(false);
};

foo(true);

// Console Output:
// Whassup?
// Whassup?

// Assign bar to the original function, and assign foo to another function.
var bar = foo;
foo = function(){
    console.log('Bad.')
};

bar(true);

// Console Output:
// Whassup?
// Whassup?

ध्यान दें कि फ़ंक्शन का नाम अपने आप में स्कोप है। नाम बाहरी दायरे में लीक नहीं हुआ है:

myself(false); // ReferenceError: myself is not defined

कॉलबैक मापदंडों के रूप में पुनरावर्ती अनाम कार्यों से निपटने के दौरान यह तकनीक विशेष रूप से उपयोगी है:

// Calculate the fibonacci value for each number in an array:
var fib = false,
    result = [1,2,3,4,5,6,7,8].map(
        function fib(n){
            return ( n <= 2 ) ? 1 : fib( n - 1 ) + fib( n - 2 );
        });
// result = [1, 1, 2, 3, 5, 8, 13, 21]
// fib = false (the anonymous function name did not overwrite our fib variable)

तुरंत समारोह अभिव्यक्तियाँ

कभी-कभी आप अपने फ़ंक्शन को एक चर के रूप में सुलभ / संग्रहीत नहीं करना चाहते हैं। आप एक तत्काल इनवॉइस फंक्शन एक्सप्रेशन (शॉर्ट के लिए IIFE) बना सकते हैं। ये अनिवार्य रूप से स्वयं-निष्पादित अनाम कार्य हैं । उनके पास आस-पास के दायरे तक पहुंच है, लेकिन फ़ंक्शन स्वयं और किसी भी आंतरिक चर बाहर से दुर्गम होगा। IIFE के बारे में ध्यान देने वाली एक महत्वपूर्ण बात यह है कि भले ही आप अपने फ़ंक्शन का नाम दें, IIFE को फहराया नहीं जाता है जैसे कि मानक फ़ंक्शन हैं और उन्हें उस फ़ंक्शन नाम से नहीं बुलाया जा सकता है जिसे वे घोषित किए गए हैं।

(function() {
   alert("I've run - but can't be run again because I'm immediately invoked at runtime,
          leaving behind only the result I generate");
}());

यह IIFE लिखने का एक और तरीका है। ध्यान दें कि अर्धविराम से पहले समापन कोष्ठक को स्थानांतरित किया गया था और समापन घुंघराले ब्रैकेट के ठीक बाद रखा गया था:

(function() {
   alert("This is IIFE too.");
})();

आप आसानी से एक IIFE में पैरामीटर पास कर सकते हैं:

(function(message) {
   alert(message);
}("Hello World!"));

इसके अतिरिक्त, आप मान को आसपास के दायरे में लौटा सकते हैं:

var example = (function() {
   return 42;
}());
console.log(example); // => 42

यदि आवश्यक हो तो IIFE नाम देना संभव है। जबकि कम अक्सर देखा जाता है, इस पैटर्न के कई फायदे हैं, जैसे कि एक संदर्भ प्रदान करना जिसे पुनरावृत्ति के लिए उपयोग किया जा सकता है और यह डीबगिंग को सरल बना सकता है क्योंकि नाम को कॉलस्टैक में शामिल किया गया है।

(function namedIIFE() { 
    throw error; // We can now see the error thrown in 'namedIIFE()'
}());

कोष्ठक में एक फ़ंक्शन को लपेटते समय एक अभिव्यक्ति की उम्मीद करने के लिए जावास्क्रिप्ट पार्सर को निरूपित करने का सबसे आम तरीका है, उन जगहों पर जहां एक अभिव्यक्ति पहले से ही अपेक्षित है, संकेतन को और अधिक संक्षिप्त किया जा सकता है:

var a = function() { return 42 }();
console.log(a)  // => 42

तुरंत लागू समारोह का तीर संस्करण:

(() => console.log("Hello!"))(); // => Hello!

फंक्शन स्कूपिंग

जब आप किसी फ़ंक्शन को परिभाषित करते हैं, तो यह एक गुंजाइश बनाता है।

फ़ंक्शन के भीतर परिभाषित सब कुछ फ़ंक्शन के बाहर कोड द्वारा सुलभ नहीं है। इस दायरे के केवल कोड को दायरे के अंदर परिभाषित निकाय देख सकते हैं।

function foo() {
  var a = 'hello';
  console.log(a);  // => 'hello'
}

console.log(a);  // reference error

जावास्क्रिप्ट में नेस्टेड कार्य संभव हैं और वही नियम लागू होते हैं।

function foo() {
  var a = 'hello';
  
  function bar() {
    var b = 'world';
    console.log(a);  // => 'hello'
    console.log(b);  // => 'world'
  }

  console.log(a);  // => 'hello'
  console.log(b);  // reference error
}

console.log(a);  // reference error
console.log(b);  // reference error

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

var a = 'hello';

function foo() {
  var b = 'world';

  function bar() {
    var c = '!!';

    console.log(a);  // => 'hello'
    console.log(b);  // => 'world'
    console.log(c);  // => '!!'
    console.log(d);  // reference error
  }
}

इस चढ़ाई के व्यवहार का मतलब यह भी हो सकता है कि एक संदर्भ बाहरी दायरे में समान रूप से नामित संदर्भ पर "छाया" हो सकता है क्योंकि यह पहली बार देखा जाता है।

var a = 'hello';

function foo() {
  var a = 'world';

  function bar() {
    console.log(a);  // => 'world'
  }
}

function foo() {
  const a = true;

  function bar() {
    const a = false;  // different variable
    console.log(a);   // false
  }

  const a = false;    // SyntaxError
  a = false;          // TypeError
  console.log(a);     // true
}

बाध्यकारी `यह` और तर्क

var monitor = {
  threshold: 5,
  check: function(value) {
    if (value > this.threshold) {
      this.display("Value is too high!");
    }
  },
  display(message) {
    alert(message);
  }
};

monitor.check(7); // The value of `this` is implied by the method call syntax.


var badCheck = monitor.check;
badCheck(15); // The value of `this` is window object and this.threshold is undefined, so value > this.threshold is false

var check = monitor.check.bind(monitor);
check(15); // This value of `this` was explicitly bound, the function works.

var check8 = monitor.check.bind(monitor, 8);
check8(); // We also bound the argument to `8` here. It can't be re-specified.

window.x = 12; 

function example() {
  return this.x;
}

console.log(example()); // 12

window.x = 12; 
    
function example() {
  "use strict";
  return this.x;
}

console.log(example()); // Uncaught TypeError: Cannot read property 'x' of undefined(…)

var log = console.log.bind(console); // long version
const log = ::console.log; // short version

foo.bar.call(foo); // long version
foo::bar(); // short version

foo.bar.call(foo, arg1, arg2, arg3); // long version
foo::bar(arg1, arg2, arg3); // short version

foo.bar.apply(foo, args); // long version
foo::bar(...args); // short version

बाइंडिंग कंसोल वेरिएबल्स के लिए कार्य करता है

var log = console.log.bind(console);

उपयोग:

log('one', '2', 3, [4], {5: 5});

आउटपुट:

one 2 3 [4] Object {5: 5}

तुम ऐसा क्यों करोगे?

एक उपयोग का मामला तब हो सकता है जब आपके पास कस्टम लकड़हारा हो और आप रनटाइम पर निर्णय लेना चाहते हैं कि किसका उपयोग करना है।

var logger = require('appLogger');

var log = logToServer ? logger.log : console.log.bind(console);

फ़ंक्शन तर्क, "तर्क" ऑब्जेक्ट, बाकी और फैला हुआ पैरामीटर

फ़ंक्शंस उन वेरिएबल्स के रूप में इनपुट ले सकते हैं जिन्हें उपयोग किया जा सकता है और उन्हें अपने स्वयं के दायरे में रखा जा सकता है। निम्नलिखित फ़ंक्शन दो संख्यात्मक मान लेता है और उनका योग लौटाता है:

function addition (argument1, argument2){
    return argument1 + argument2; 
}

console.log(addition(2, 3)); // -> 5

arguments वस्तु

arguments ऑब्जेक्ट में फ़ंक्शन के सभी पैरामीटर होते हैं जिनमें एक गैर- डिफ़ॉल्ट मान होता है । इसका उपयोग तब भी किया जा सकता है जब पैरामीटर स्पष्ट रूप से घोषित नहीं किए जाते हैं:

(function() { console.log(arguments) })(0,'str', [2,{3}]) // -> [0, "str", Array[2]]

हालांकि जब मुद्रण arguments एक Array जैसा दिखता है, तो यह वास्तव में एक वस्तु है:

(function() { console.log(typeof arguments) })(); // -> object

बाकी पैरामीटर: function (...parm) {}

ES6 में, ... जब किसी फ़ंक्शन के मापदंडों की घोषणा में उपयोग किया जाने वाला वाक्यविन्यास, चर को अपने अधिकार में बदल देता है, जो घोषित किए गए सभी शेष पैरामीटरों को प्रदान करता है। यह फ़ंक्शन को असीमित संख्या में तर्कों के साथ आमंत्रित किया जा सकता है, जो इस चर का हिस्सा बन जाएगा:

(function(a, ...b){console.log(typeof b+': '+b[0]+b[1]+b[2]) })(0,1,'2',[3],{i:4});
// -> object: 123  

स्प्रेड पैरामीटर: function_name(...varb);

ES6 में, ... सिंटैक्स का उपयोग तब भी किया जा सकता है, जब किसी वस्तु / चर को उसके दाईं ओर रखकर किसी फ़ंक्शन का उपयोग किया जाता है। यह उस ऑब्जेक्ट के तत्वों को एक ही ऑब्जेक्ट के रूप में उस फ़ंक्शन में पारित करने की अनुमति देता है:

let nums = [2,42,-1];
console.log(...['a','b','c'], Math.max(...nums)); // -> a b c 42

नाम दिया गया कार्य

कार्य या तो नाम दिए जा सकते हैं या अनाम ( अनाम फ़ंक्शंस ):

var namedSum = function sum (a, b) { // named
    return a + b;
}

var anonSum = function (a, b) { // anonymous
    return a + b;
}

namedSum(1, 3);
anonSum(1, 3);

4
4

लेकिन उनके नाम अपने स्वयं के दायरे के लिए निजी हैं:

var sumTwoNumbers = function sum (a, b) {
    return a + b;
}

sum(1, 3);

बिना संदर्भित संदर्भ: योग परिभाषित नहीं है

नामित कार्य कई परिदृश्यों में अनाम कार्यों से भिन्न होते हैं:

• जब आप डिबगिंग कर रहे हैं, तो फ़ंक्शन का नाम त्रुटि / स्टैक ट्रेस में दिखाई देगा
• नामांकित कार्यों रहे फहराया जबकि अनाम प्रक्रियाएं नहीं हैं
• नामांकित फ़ंक्शंस और अनाम फ़ंक्शंस पुनरावृत्ति से निपटने के दौरान अलग-अलग व्यवहार करते हैं
• ECMAScript संस्करण के आधार पर, नाम और अनाम फ़ंक्शन फ़ंक्शन name संपत्ति का अलग-अलग तरीके से इलाज कर सकते हैं

नामित कार्यों को फहराया जाता है

किसी अनाम फ़ंक्शन का उपयोग करते समय, फ़ंक्शन को केवल घोषणा की रेखा के बाद कहा जा सकता है, जबकि एक नामित फ़ंक्शन को घोषणा से पहले बुलाया जा सकता है। विचार करें

foo();
var foo = function () { // using an anonymous function
    console.log('bar');
}

बिना पढ़ा हुआ टाइपरोर: फू एक फंक्शन नहीं है

foo();
function foo () { // using a named function
    console.log('bar');
}

बार

एक पुनरावर्ती परिदृश्य में नामित कार्य

एक पुनरावर्ती कार्य के रूप में परिभाषित किया जा सकता है:

var say = function (times) {
    if (times > 0) {
        console.log('Hello!');

        say(times - 1);
    }
}

//you could call 'say' directly, 
//but this way just illustrates the example
var sayHelloTimes = say;

sayHelloTimes(2);

नमस्कार!
नमस्कार!

क्या होगा अगर आपके कोड में कहीं मूल फ़ंक्शन बाइंडिंग को फिर से परिभाषित किया गया है?

var say = function (times) {
    if (times > 0) {
        console.log('Hello!');

        say(times - 1);
    }
}

var sayHelloTimes = say;
say = "oops";

sayHelloTimes(2);

नमस्कार!
बिना पढ़ा हुआ टाइपरोर: कहते हैं कि फ़ंक्शन नहीं है

एक नामित फ़ंक्शन का उपयोग करके इसे हल किया जा सकता है

// The outer variable can even have the same name as the function
// as they are contained in different scopes
var say = function say (times) {
    if (times > 0) {
        console.log('Hello!');

        // this time, 'say' doesn't use the outer variable
        // it uses the named function
        say(times - 1);
    }
}

var sayHelloTimes = say;
say = "oops";

sayHelloTimes(2);

नमस्कार!
नमस्कार!

और बोनस के रूप में, नामित फ़ंक्शन को अंदर से भी undefined नहीं किया जा सकता है:

var say = function say (times) {
    // this does nothing
    say = undefined;
    
    if (times > 0) {
        console.log('Hello!');

        // this time, 'say' doesn't use the outer variable
        // it's using the named function
        say(times - 1);
    }
}

var sayHelloTimes = say;
say = "oops";

sayHelloTimes(2);

नमस्कार!
नमस्कार!

कार्यों का name संपत्ति

ईएस 6 से पहले, नामित फ़ंक्शन में उनके name गुणों को उनके फ़ंक्शन नामों पर सेट किया गया था, और अनाम फ़ंक्शन के पास उनके name गुण खाली स्ट्रिंग पर सेट थे।

var foo = function () {}
console.log(foo.name); // outputs ''

function foo () {}
console.log(foo.name); // outputs 'foo'

ES6 के नाम, नाम और अनाम कार्य दोनों ने अपने name गुण निर्धारित किए हैं:

var foo = function () {}
console.log(foo.name); // outputs 'foo'

function foo () {}
console.log(foo.name); // outputs 'foo'

var foo = function bar () {}
console.log(foo.name); // outputs 'bar'

पुनरावर्ती कार्य

एक पुनरावर्ती फ़ंक्शन केवल एक फ़ंक्शन है, जो स्वयं को कॉल करेगा।

function factorial (n) {
    if (n <= 1) {
        return 1;
    }
    
    return n * factorial(n - 1);
}

उपरोक्त फ़ंक्शन एक फैक्टरियल को वापस करने के लिए एक पुनरावर्ती कार्य करने के तरीके का एक मूल उदाहरण दिखाता है।

एक अन्य उदाहरण, एक सरणी में सम संख्याओं का योग प्राप्त करना होगा।

function countEvenNumbers (arr) {
    // Sentinel value.  Recursion stops on empty array.
    if (arr.length < 1) {
        return 0;
    }
    // The shift() method removes the first element from an array 
    // and returns that element. This method changes the length of the array.
    var value = arr.shift();

    // `value % 2 === 0` tests if the number is even or odd
    // If it's even we add one to the result of counting the remainder of 
    // the array.  If it's odd, we add zero to it.
    return ((value % 2 === 0) ? 1 : 0) + countEvens(arr);
}

यह महत्वपूर्ण है कि इस तरह के फ़ंक्शंस अनंत छोरों से बचने के लिए किसी प्रकार के प्रहरी मूल्य की जांच करते हैं। ऊपर के पहले उदाहरण में, जब n 1 से कम या उसके बराबर है, तो पुनरावृत्ति रुक जाती है, जिससे प्रत्येक कॉल का परिणाम कॉल स्टैक को वापस किया जा सकता है।

Currying

करीकरण केवल एक तर्क लेने वाले n कार्यों के अनुक्रम में n arity या तर्कों के कार्य का रूपांतरण है।

मामलों का उपयोग करें: जब कुछ तर्कों के मूल्य दूसरों के सामने उपलब्ध होते हैं, तो आप फ़ंक्शन को चरणों में काम पूरा करने वाली श्रृंखला में एक फ़ंक्शन को विघटित करने के लिए उपयोग कर सकते हैं, जैसा कि प्रत्येक मान में आता है। यह उपयोगी हो सकता है:

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

उदाहरण के लिए, एक आयताकार प्रिज्म के आयतन को तीन कारकों के कार्य द्वारा समझाया जा सकता है: लंबाई ( l ), चौड़ाई ( w ), और ऊँचाई ( h ):

var prism = function(l, w, h) {
    return l * w * h;
}

इस फ़ंक्शन का एक घुमावदार संस्करण इस तरह दिखेगा:

function prism(l) {
    return function(w) {
        return function(h) {
            return l * w * h;
        }
    }
}

// alternatively, with concise ECMAScript 6+ syntax:
var prism = l => w => h => l * w * h;

आप prism(2)(3)(5) साथ फ़ंक्शंस के इन अनुक्रमों को कॉल कर सकते हैं, जिन्हें 30 का मूल्यांकन करना चाहिए।

कुछ अतिरिक्त मशीनरी (लाइब्रेरियों के साथ) के बिना, प्लेसहोल्डर मानों की कमी के कारण, जावास्क्रिप्ट जावास्क्रिप्ट (ईएस 5/6) में सीमित सिंटैक्टिक लचीलेपन की है; इस प्रकार, जब आप var a = prism(2)(3) का उपयोग आंशिक रूप से लागू फ़ंक्शन बनाने के लिए कर सकते हैं, तो आप prism()(3)(5) उपयोग नहीं कर सकते।

रिटर्न स्टेटमेंट का उपयोग करना

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

//An example function that will take a string as input and return 
//the first character of the string.

function firstChar (stringIn){
    return stringIn.charAt(0);
}

अब इस फ़ंक्शन का उपयोग करने के लिए, आपको इसे अपने कोड में कहीं और एक चर के स्थान पर रखना होगा:

फ़ंक्शन के परिणाम को दूसरे फ़ंक्शन के लिए तर्क के रूप में उपयोग करना:

console.log(firstChar("Hello world"));

कंसोल आउटपुट होगा:

> H

रिटर्न स्टेटमेंट फ़ंक्शन को समाप्त करता है

यदि हम शुरुआत में फ़ंक्शन को संशोधित करते हैं, तो हम यह प्रदर्शित कर सकते हैं कि रिटर्न स्टेटमेंट फ़ंक्शन को समाप्त करता है।

function firstChar (stringIn){
    console.log("The first action of the first char function");
    return stringIn.charAt(0);
    console.log("The last action of the first char function");
}

इस फंक्शन को इस तरह से चलाना इस तरह दिखेगा:

console.log(firstChar("JS"));

कंसोल आउटपुट:

> The first action of the first char function
> J

यह रिटर्न स्टेटमेंट के बाद संदेश को प्रिंट नहीं करेगा, क्योंकि फ़ंक्शन अब समाप्त हो गया है।

कई लाइनों में फैले विवरण लौटें:

जावास्क्रिप्ट में, आप आमतौर पर पठनीय उद्देश्यों या संगठन के लिए कोड की एक पंक्ति को कई लाइनों में विभाजित कर सकते हैं। यह मान्य जावास्क्रिप्ट है:

var
    name = "bob",
    age = 18;

जब जावास्क्रिप्ट var जैसा अधूरा विवरण देखता है तो यह स्वयं को पूरा करने के लिए अगली पंक्ति में दिखता है। हालांकि, यदि आप return स्टेटमेंट में वही गलती करते return , तो आपको वह नहीं मिलेगा जिसकी आपको उम्मीद थी।

return
    "Hi, my name is "+ name + ". " +
    "I'm "+ age + " years old.";

यह कोड undefined होकर return क्योंकि रिटर्न undefined जावास्क्रिप्ट में एक पूर्ण विवरण है, इसलिए यह स्वयं को पूरा करने के लिए अगली पंक्ति में नहीं दिखेगा। यदि आपको return स्टेटमेंट को कई लाइनों में विभाजित करने की आवश्यकता है, तो रिटर्न के आगे एक मान डालें, इससे पहले कि आप इसे विभाजित करें, जैसे।

return "Hi, my name is " + name + ". " +
    "I'm " + age + " years old.";

संदर्भ या मूल्य से तर्क पारित करना

जावास्क्रिप्ट में सभी तर्क मूल्य द्वारा पारित किए जाते हैं। जब कोई फ़ंक्शन एक तर्क चर के लिए एक नया मान प्रदान करता है, तो वह परिवर्तन कॉलर को दिखाई नहीं देगा:

var obj = {a: 2};
function myfunc(arg){
    arg = {a: 5}; // Note the assignment is to the parameter variable itself
}
myfunc(obj);
console.log(obj.a); // 2

हालांकि, (नेस्ट) इस तरह के तर्क के गुणों में किए गए परिवर्तनों, फोन करने वाले को दिखाई देगी,:

var obj = {a: 2};
function myfunc(arg){
    arg.a = 5; // assignment to a property of the argument
}
myfunc(obj);
console.log(obj.a); // 5

इसे संदर्भ द्वारा कॉल के रूप में देखा जा सकता है: हालाँकि कोई फ़ंक्शन कॉल करने वाले की ऑब्जेक्ट को एक नया मान देकर बदल नहीं सकता है, यह कॉल करने वाले की ऑब्जेक्ट को म्यूट कर सकता है।

जैसे कि आदिम मूल्यवान तर्क, जैसे संख्या या तार अपरिवर्तनीय हैं, किसी फ़ंक्शन को उन्हें म्यूट करने का कोई तरीका नहीं है:

var s = 'say';
function myfunc(arg){
    arg += ' hello'; // assignment to the parameter variable itself
}
myfunc(s);
console.log(s); // 'say'

जब कोई फ़ंक्शन किसी ऑब्जेक्ट को तर्क के रूप में म्यूट करना चाहता है, लेकिन वास्तव में कॉलर की ऑब्जेक्ट को म्यूट करना नहीं चाहता है, तो तर्क चर को फिर से असाइन किया जाना चाहिए:

var obj = {a: 2, b: 3};
function myfunc(arg){
    arg = Object.assign({}, arg); // assignment to argument variable, shallow copy
    arg.a = 5;
}
myfunc(obj);
console.log(obj.a); // 2

एक तर्क के इन-प्लेस म्यूटेशन के विकल्प के रूप में, फ़ंक्शन तर्क के आधार पर एक नया मान बना सकते हैं, और इसे वापस कर सकते हैं। कॉल करने वाला इसे तर्क के रूप में पारित किए गए मूल चर तक भी भेज सकता है:

var a = 2;
function myfunc(arg){
    arg++;
    return arg;
}
a = myfunc(a);
console.log(obj.a); // 3

कॉल करें और आवेदन करें

फ़ंक्शंस में दो अंतर्निहित तरीके होते हैं जो प्रोग्रामर को तर्क और this चर को अलग-अलग आपूर्ति करने की अनुमति देते हैं: call और apply ।

यह उपयोगी है, क्योंकि एक वस्तु पर काम करने वाले कार्य (जिस वस्तु की वे एक संपत्ति हैं) को दूसरे, संगत ऑब्जेक्ट पर संचालित करने के लिए पुनर्खरीद किया जा सकता है। इसके अतिरिक्त, ES6 में प्रसार ( ... ) ऑपरेटर के समान, सरणियों के रूप में एक शॉट में तर्क दिए जा सकते हैं।

let obj = {
    a: 1,
    b: 2,
    set: function (a, b) {
        this.a = a;
        this.b = b;
    }
};

obj.set(3, 7); // normal syntax
obj.set.call(obj, 3, 7); // equivalent to the above
obj.set.apply(obj, [3, 7]); // equivalent to the above; note that an array is used

console.log(obj); // prints { a: 3, b: 5 }

let myObj = {};
myObj.set(5, 4); // fails; myObj has no `set` property
obj.set.call(myObj, 5, 4); // success; `this` in set() is re-routed to myObj instead of obj
obj.set.apply(myObj, [5, 4]); // same as above; note the array

console.log(myObj); // prints { a: 3, b: 5 }

function showName(label) {
    console.log(label + ":" + this.name);
}
var student1 = {
     name: "Ravi"
};
var student2 = {
     name: "Vinod"
};

// create a function just for student1
var showNameStudent1 = showName.bind(student1);
showNameStudent1("student1"); // outputs "student1:Ravi"

// create a function just for student2
var showNameStudent2 = showName.bind(student2, "student2");
showNameStudent2(); // outputs "student2:Vinod"

// attaching a method to an object doesn't change `this` value of that method.
student2.sayName = showNameStudent1;
student2.sayName("student2"); // outputs "student2:Ravi"

डिफ़ॉल्ट पैरामीटर

ECMAScript 2015 (ES6) से पहले, एक पैरामीटर्स का डिफ़ॉल्ट मान निम्नलिखित तरीके से सौंपा जा सकता है:

function printMsg(msg) {
  msg = typeof msg !== 'undefined' ? // if a value was provided 
        msg :                        // then, use that value in the reassignemnt
        'Default value for msg.';    // else, assign a default value
  console.log(msg);
}

ES6 ने एक नया सिंटैक्स प्रदान किया जहां ऊपर वर्णित स्थिति और पुनर्मूल्यांकन अब आवश्यक नहीं है:

function printMsg(msg='Default value for msg.') {
    console.log(msg);
}

printMsg(); // -> "Default value for msg."
printMsg(undefined); // -> "Default value for msg."
printMsg('Now my msg in different!'); // -> "Now my msg in different!"

इससे यह भी पता चलता है कि यदि फ़ंक्शन को लागू करने के दौरान कोई पैरामीटर गायब है, तो इसका मान undefined रखा जाता है, क्योंकि इसे निम्नलिखित उदाहरण में स्पष्ट रूप से प्रदान करके इसकी पुष्टि की जा सकती है: ( तीर फ़ंक्शन का उपयोग करके)

let param_check = (p = 'str') => console.log(p + ' is of type: ' + typeof p);

param_check(); // -> "str is of type: string"
param_check(undefined); // -> "str is of type: string"

param_check(1); // -> "1 is of type: number"
param_check(this); // -> "[object Window] is of type: object"

डिफ़ॉल्ट मान और पुन: उपयोग के मापदंडों के रूप में कार्य / चर

डिफ़ॉल्ट पैरामीटर का मान संख्या, स्ट्रिंग्स या साधारण ऑब्जेक्ट तक सीमित नहीं है। एक फ़ंक्शन को डिफ़ॉल्ट मान callback = function(){} : के रूप में भी सेट किया जा सकता है

function foo(callback = function(){ console.log('default'); }) {
    callback();
}

foo(function (){
    console.log('custom');
});
// custom

foo();
//default

डिफ़ॉल्ट मानों के माध्यम से किए जा सकने वाले ऑपरेशनों की कुछ विशेषताएं हैं:

• एक पूर्व घोषित पैरामीटर को आगामी मापदंडों के मूल्यों के लिए एक डिफ़ॉल्ट मान के रूप में पुन: उपयोग किया जा सकता है।
• एक पैरामीटर के लिए डिफ़ॉल्ट मान असाइन करते समय इनलाइन संचालन की अनुमति है।
• घोषित किए जा रहे फ़ंक्शन के समान दायरे में मौजूद चर का उपयोग उसके डिफ़ॉल्ट मानों में किया जा सकता है।
• डिफ़ॉल्ट मान में उनकी वापसी का मूल्य प्रदान करने के लिए कार्यों को लागू किया जा सकता है।

let zero = 0;
function multiply(x) { return x * 2;}

function add(a = 1 + zero, b = a, c = b + a, d = multiply(c)) {
    console.log((a + b + c), d);
}

add(1);                // 4, 4
add(3);                // 12, 12
add(2, 7);             // 18, 18
add(1, 2, 5);          // 8, 10
add(1, 2, 5, 10);      // 8, 20 

एक नए आह्वान के डिफ़ॉल्ट मान में फ़ंक्शन के वापसी मूल्य का पुन: उपयोग करना:

let array = [1]; // meaningless: this will be overshadowed in the function's scope
function add(value, array = []) {
  array.push(value);
  return array;
}
add(5);         // [5]
add(6);         // [6], not [5, 6]
add(6, add(5)); // [5, 6]

arguments में मानदंड की कमी होने पर arguments और मूल्य

arguments सरणी ऑब्जेक्ट केवल उन मापदंडों को बनाए रखता है जिनके मान डिफ़ॉल्ट नहीं हैं, अर्थात जो फ़ंक्शन के आह्वान पर स्पष्ट रूप से प्रदान किए जाते हैं:

function foo(a = 1, b = a + 1) {
    console.info(arguments.length, arguments);
    console.log(a,b);
}

foo();        // info: 0 >> []     | log: 1, 2
foo(4);       // info: 1 >> [4]    | log: 4, 5
foo(5, 6);    // info: 2 >> [5, 6] | log: 5, 6

किसी अज्ञात संख्या के तर्क (कार्य)

एक फ़ंक्शन बनाने के लिए जो एक अनिर्धारित तर्क को स्वीकार करता है, आपके पर्यावरण के आधार पर दो विधियां हैं।

function logSomeThings() {
    for (var i = 0; i < arguments.length; ++i) {
        console.log(arguments[i]);
    }
}

logSomeThings('hello', 'world');
// logs "hello"
// logs "world"

function personLogsSomeThings(person, ...msg) {
   msg.forEach(arg => {
       console.log(person, 'says', arg);
   });
}

personLogsSomeThings('John', 'hello', 'world');
// logs "John says hello"
// logs "John says world"

const logArguments = (...args) => console.log(args)
const list = [1, 2, 3]

logArguments('a', 'b', 'c', ...list)
// output: Array [ "a", "b", "c", 1, 2, 3 ]

const logArguments = (...args) => console.log(args)
function* generateNumbers() {
  yield 6
  yield 5
  yield 4
}

logArguments('a', ...generateNumbers(), ...'pqr', 'b')
// output: Array [ "a", 6, 5, 4, "p", "q", "r", "b" ]

किसी फ़ंक्शन ऑब्जेक्ट का नाम प्राप्त करें

myFunction.name

function functionName( func )
{
    // Match:
    // - ^          the beginning of the string
    // - function   the word 'function'
    // - \s+        at least some white space
    // - ([\w\$]+)  capture one or more valid JavaScript identifier characters
    // - \(         followed by an opening brace
    //
    var result = /^function\s+([\w\$]+)\(/.exec( func.toString() )
    
    return result ? result[1] : ''
}

आंशिक आवेदन

करीने के समान, एक फ़ंक्शन को दिए गए तर्कों की संख्या को कम करने के लिए आंशिक अनुप्रयोग का उपयोग किया जाता है। करीने के विपरीत, संख्या एक से नीचे जाने की आवश्यकता नहीं है।

उदाहरण:

यह समारोह ...

function multiplyThenAdd(a, b, c) {
    return a * b + c;
}

... एक और फ़ंक्शन बनाने के लिए उपयोग किया जा सकता है जो हमेशा 2 से गुणा करेगा और फिर पारित मूल्य में 10 जोड़ देगा;

function reversedMultiplyThenAdd(c, b, a) {
    return a * b + c;
}

function factory(b, c) {
    return reversedMultiplyThenAdd.bind(null, c, b);
}

var multiplyTwoThenAddTen = factory(2, 10);
multiplyTwoThenAddTen(10); // 30

आंशिक आवेदन का "आवेदन" हिस्सा बस एक फ़ंक्शन के मापदंडों को ठीक करने का मतलब है।

समारोह रचना

एक में कई कार्यों की रचना एक कार्यात्मक प्रोग्रामिंग आम अभ्यास है;

रचना एक पाइपलाइन बनाती है, जिसके माध्यम से हमारा डेटा पारगमन करेगा और कार्य-रचना (बस एक ट्रैक के टुकड़े के टुकड़े की तरह) पर काम करते हुए संशोधित हो जाएगा ...

आप कुछ एकल जिम्मेदारी कार्यों के साथ शुरू करते हैं:

 const capitalize = x => x.replace(/^\w/, m => m.toUpperCase());
 const sign = x => x + ',\nmade with love';

और आसानी से एक परिवर्तन ट्रैक बनाएँ:

 const formatText = compose(capitalize, sign);

 formatText('this is an example')
 //This is an example,
 //made with love

नायब कम्पोजिशन को एक उपयोगिता फ़ंक्शन के माध्यम से प्राप्त किया जाता है जिसे आमतौर पर हमारे उदाहरण में compose कहा जाता है।

का कार्यान्वयन compose कई जावास्क्रिप्ट उपयोगिता पुस्तकालयों (में मौजूद हैं lodash , rambda , आदि), लेकिन आप भी इस तरह के रूप में एक सरल कार्यान्वयन के साथ शुरू कर सकते हैं:

 const compose = (...funs) =>
   x =>
   funs.reduce((ac, f) => f(ac), x);