javascript - var functionName=function(){}बनाम फ़ंक्शन फ़ंक्शननाम(){}




syntax idioms (25)

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

पिछला डेवलपर फ़ंक्शन घोषित करने के दो तरीकों का उपयोग करता है और यदि इसके पीछे कोई कारण नहीं है तो मैं काम नहीं कर सकता हूं।

दो तरीके हैं:

var functionOne = function() {
    // Some code
};
function functionTwo() {
    // Some code
}

इन दो अलग-अलग तरीकों का उपयोग करने के कारण क्या हैं और प्रत्येक के पेशेवर और विपक्ष क्या हैं? क्या ऐसी कोई चीज है जो एक विधि के साथ की जा सकती है जिसे दूसरे के साथ नहीं किया जा सकता है?


Answers

Both are different ways of defining a function. The difference is how the browser interprets and loads them into an execution context.

The first case is of function expressions which loads only when the interpreter reaches that line of code. So if you do it like the following, you will get an error that the functionOne is not a function .

functionOne();
var functionOne = function() {
    // Some code
};

The reason is that on the first line no value is assigned to functionOne, and hence it is undefined. We are trying to call it as a function, and hence we are getting an error.

On the second line we are assigning the reference of an anonymous function to functionOne.

The second case is of function declarations that loads before any code is executed. So if you do like the following you won't get any error as the declaration loads before code execution.

functionOne();
function functionOne() {
   // Some code
}

I'm listing out the differences below:

  1. A function declaration can be placed anywhere in the code. Even if it is invoked before the definition appears in code, it gets executed as function declaration is committed to memory or in a way it is hoisted up, before any other code in the page starts execution.

    Take a look at the function below:

    function outerFunction() {
        function foo() {
           return 1;
        }
        return foo();
        function foo() {
           return 2;
        }
    }
    alert(outerFunction()); // Displays 2
    

    This is because, during execution, it looks like:-

    function foo() {  // The first function declaration is moved to top
        return 1;
    }
    function foo() {  // The second function declaration is moved to top
        return 2;
    }
    function outerFunction() {
        return foo();
    }
    alert(outerFunction()); //So executing from top to bottom,
                            //the last foo() returns 2 which gets displayed
    

    A function expression, if not defined before calling it, will result in an error. Also, here the function definition itself is not moved to the top or committed to memory like in the function declarations. But the variable to which we assign the function gets hoisted up and undefined gets assigned to it.

    Same function using function expressions:

    function outerFunction() {
        var foo = function() {
           return 1;
        }
        return foo();
        var foo = function() {
           return 2;
        }
    }
    alert(outerFunction()); // Displays 1
    

    This is because during execution, it looks like:

    function outerFunction() {
       var foo = undefined;
       var foo = undefined;
    
       foo = function() {
          return 1;
       };
       return foo ();
       foo = function() {   // This function expression is not reachable
          return 2;
       };
    }
    alert(outerFunction()); // Displays 1
    
  2. It is not safe to write function declarations in non-function blocks like if because they won't be accessible.

    if (test) {
        function x() { doSomething(); }
    }
    
  3. Named function expression like the one below, may not work in Internet Explorer browsers prior to version 9.

    var today = function today() {return new Date()}
    

Hoisting वर्तमान स्कोप के शीर्ष पर सभी चर और फ़ंक्शन घोषणाओं को स्थानांतरित करने के लिए जावास्क्रिप्ट दुभाषिया की कार्रवाई है।

हालांकि, केवल वास्तविक घोषणाएं फेंक दी जाती हैं। असाइनमेंट छोड़कर वे कहाँ हैं।

  • पृष्ठ के अंदर परिवर्तनीय / फ़ंक्शन की घोषणा वैश्विक है जो उस पृष्ठ में कहीं भी पहुंच सकती है।
  • फ़ंक्शन के अंदर घोषित चर / फ़ंक्शंस स्थानीय दायरे में हैं। इसका मतलब है कि वे फ़ंक्शन बॉडी (स्कोप) के अंदर उपलब्ध / एक्सेस किए गए हैं, वे फ़ंक्शन बॉडी के बाहर उपलब्ध नहीं हैं।

Variable

जावास्क्रिप्ट को ढीली टाइप की गई भाषा कहा जाता है। जिसका अर्थ है जावास्क्रिप्ट चर किसी भी Data-Type मूल्य को पकड़ सकता है। जावास्क्रिप्ट स्वचालित रूप से रनटाइम के दौरान प्रदान किए गए मान / शाब्दिक के आधार पर चर-प्रकार को बदलने का ख्याल रखता है।

global_Page = 10;                                               var global_Page;      « undefined
    « Integer literal, Number Type.   -------------------       global_Page = 10;     « Number         
global_Page = 'Yash';                 |   Interpreted   |       global_Page = 'Yash'; « String
    « String literal, String Type.    «       AS        «       global_Page = true;   « Boolean 
var global_Page = true;               |                 |       global_Page = function (){          « function
    « Boolean Type                    -------------------                 var local_functionblock;  « undefined
global_Page = function (){                                                local_functionblock = 777;« Number
    var local_functionblock = 777;                              };  
    // Assigning function as a data.
};  

समारोह

function Identifier_opt ( FormalParameterList_opt ) { 
      FunctionBody | sequence of statements

      « return;  Default undefined
      « return 'some data';
}
  • पृष्ठ के अंदर घोषित कार्यों को वैश्विक पहुंच वाले पृष्ठ के शीर्ष पर रखा गया है।
  • फंक्शन-ब्लॉक के अंदर घोषित कार्यों को ब्लॉक के शीर्ष पर फेंक दिया जाता है।
  • फ़ंक्शन का डिफ़ॉल्ट वापसी मान ' undefined ' है, Variable घोषणा डिफ़ॉल्ट मान भी 'अपरिभाषित'

    Scope with respect to function-block global. 
    Scope with respect to page undefined | not available.
    

समारोह घोषणा

function globalAccess() {                                  function globalAccess() {      
}                                  -------------------     }
globalAccess();                    |                 |     function globalAccess() { « Re-Defined / overridden.
localAccess();                     «   Hoisted  As   «         function localAccess() {
function globalAccess() {          |                 |         }
     localAccess();                -------------------         localAccess(); « function accessed with in globalAccess() only.
     function localAccess() {                              }
     }                                                     globalAccess();
}                                                          localAccess(); « ReferenceError as the function is not defined

फंक्शन अभिव्यक्ति

        10;                 « literal
       (10);                « Expression                (10).toString() -> '10'
var a;                      
    a = 10;                 « Expression var              a.toString()  -> '10'
(function invoke() {        « Expression Function
 console.log('Self Invoking');                      (function () {
});                                                               }) () -> 'Self Invoking'

var f; 
    f = function (){        « Expression var Function
    console.log('var Function');                                   f ()  -> 'var Function'
    };

परिवर्तनीय उदाहरण के लिए आवंटित समारोह:

(function selfExecuting(){
    console.log('IIFE - Immediately-Invoked Function Expression');
}());

var anonymous = function (){
    console.log('anonymous function Expression');
};

var namedExpression = function for_InternalUSE(fact){
    if(fact === 1){
        return 1;
    }

    var localExpression = function(){
        console.log('Local to the parent Function Scope');
    };
    globalExpression = function(){ 
        console.log('creates a new global variable, then assigned this function.');
    };

    //return; //undefined.
    return fact * for_InternalUSE( fact - 1);   
};

namedExpression();
globalExpression();

जावास्क्रिप्ट के रूप में व्याख्या की

var anonymous;
var namedExpression;
var globalExpression;

anonymous = function (){
    console.log('anonymous function Expression');
};

namedExpression = function for_InternalUSE(fact){
    var localExpression;

    if(fact === 1){
        return 1;
    }
    localExpression = function(){
        console.log('Local to the parent Function Scope');
    };
    globalExpression = function(){ 
        console.log('creates a new global variable, then assigned this function.');
    };

    return fact * for_InternalUSE( fact - 1);    // DEFAULT UNDEFINED.
};

namedExpression(10);
globalExpression();

आप jsperf Test Runner का उपयोग कर विभिन्न ब्राउज़र के फ़ंक्शन घोषणा, अभिव्यक्ति परीक्षण की जांच कर सकते हैं

ईएस 5 कन्स्ट्रक्टर फंक्शन क्लासेस : फंक्शन ऑब्जेक्ट्स फंक्शन.प्रोटोटाइप.बिंड का उपयोग करके बनाया गया

जावास्क्रिप्ट पहले वर्ग की वस्तुओं के रूप में कार्य करता है, इसलिए एक ऑब्जेक्ट होने पर, आप फ़ंक्शन को गुण असाइन कर सकते हैं।

function Shape(id) { // Function Declaration
    this.id = id;
};
    // Adding a prototyped method to a function.
    Shape.prototype.getID = function () {
        return this.id;
    };
    Shape.prototype.setID = function ( id ) {
        this.id = id;
    };

var expFn = Shape; // Function Expression

var funObj = new Shape( ); // Function Object
funObj.hasOwnProperty('prototype'); // false
funObj.setID( 10 );
console.log( funObj.getID() ); // 10

ES6 introduced Arrow function : An arrow function expression has a shorter syntax, they are best suited for non-method functions, and they cannot be used as constructors.

ArrowFunction : ArrowParameters => ConciseBody .

const fn = (item) => { return item & 1 ? 'Odd' : 'Even'; };
console.log( fn(2) ); // Even
console.log( fn(3) ); // Odd

In computer science terms, we talk about anonymous functions and named functions. I think the most important difference is that an anonymous function is not bound to an name, hence the name anonymous function. In JavaScript it is a first class object dynamically declared at runtime.

For more information on anonymous functions and lambda calculus, Wikipedia is a good start ( http://en.wikipedia.org/wiki/Anonymous_function ).


दूसरी विधि को पहली विधि को प्राथमिकता देने का एक उदाहरण यह है कि जब आपको किसी फ़ंक्शन की पिछली परिभाषाओं को ओवरराइड करने से बचने की आवश्यकता होती है।

साथ में

if (condition){
    function myfunction(){
        // Some code
    }
}

, myfunction की यह परिभाषा किसी भी पिछली परिभाषा को ओवरराइड करेगा, क्योंकि यह पार्स-टाइम पर किया जाएगा।

जबकि

if (condition){
    var myfunction = function (){
        // Some code
    }
}

जब condition पूरी हो myfunction केवल myfunction को परिभाषित करने का सही काम करता है।


gives an example where he names an assigned function to be able to use shortcut() as an internal reference to itself. John Resig gives another example - copying a recursive function assigned to another object in his Learning Advanced Javascript tutorial. While assigning functions to properties isn't strictly the question here, I recommend actively trying the tutorial out - run the code by clicking the button in the upper right corner, and double click the code to edit to your liking.

Examples from the tutorial: recursive calls in yell() :

Tests fail when the original ninja object is removed. (page 13)

var ninja = { 
  yell: function(n){ 
    return n > 0 ? ninja.yell(n-1) + "a" : "hiy"; 
  } 
}; 
assert( ninja.yell(4) == "hiyaaaa", "A single object isn't too bad, either." ); 

var samurai = { yell: ninja.yell }; 
var ninja = null; 

try { 
  samurai.yell(4); 
} catch(e){ 
  assert( false, "Uh, this isn't good! Where'd ninja.yell go?" ); 
}

If you name the function that will be called recursively, the tests will pass. (page 14)

var ninja = { 
  yell: function yell(n){ 
    return n > 0 ? yell(n-1) + "a" : "hiy"; 
  } 
}; 
assert( ninja.yell(4) == "hiyaaaa", "Works as we would expect it to!" ); 

var samurai = { yell: ninja.yell }; 
var ninja = {}; 
assert( samurai.yell(4) == "hiyaaaa", "The method correctly calls itself." );

In JavaScript there are two ways to create functions:

  1. Function declaration:

    function fn(){
      console.log("Hello");
    }
    fn();
    

    This is very basic, self-explanatory, used in many languages and standard across C family of languages. We declared a function defined it and executed it by calling it.

    What you should be knowing is that functions are actually objects in JavaScript; internally we have created an object for above function and given it a name called fn or the reference to the object is stored in fn. Functions are objects in JavaScript; an instance of function is actually an object instance.

  2. Function expression:

    var fn=function(){
      console.log("Hello");
    }
    fn();
    

    JavaScript has first-class functions, that is, create a function and assign it to a variable just like you create a string or number and assign it to a variable. Here, the fn variable is assigned to a function. The reason for this concept is functions are objects in JavaScript; fn is pointing to the object instance of the above function. We have initialized a function and assigned it to a variable. It's not executing the function and assigning the result.

Reference: JavaScript function declaration syntax: var fn = function() {} vs function fn() {}


I'm adding my own answer just because everyone else has covered the hoisting part thoroughly.

I've wondered about which way is better for a long while now, and thanks to http://jsperf.com now I know :)

Function declarations are faster, and that's what really matters in web dev right? ;)


सबसे पहले मैं ग्रेग को सही करना चाहता हूं: function abc(){} भी स्कॉप्ड किया गया है - नाम abc उस दायरे में परिभाषित किया गया है जहां इस परिभाषा का सामना किया गया है। उदाहरण:

function xyz(){
  function abc(){};
  // abc is defined here...
}
// ...but not here

दूसरा, दोनों शैलियों को गठबंधन करना संभव है:

var xyz = function abc(){};

xyz सामान्य रूप से परिभाषित किया जा रहा है, abc सभी ब्राउज़रों में अपरिभाषित है लेकिन इंटरनेट एक्सप्लोरर - इसे परिभाषित करने पर भरोसा नहीं है। लेकिन इसे अपने शरीर के अंदर परिभाषित किया जाएगा:

var xyz = function abc(){
  // xyz is visible here
  // abc is visible here
}
// xyz is visible here
// abc is undefined here

यदि आप सभी ब्राउज़रों पर कार्यों को उपनाम करना चाहते हैं, तो इस तरह की घोषणा का उपयोग करें:

function abc(){};
var xyz = abc;

इस मामले में, xyz और abc दोनों एक ही ऑब्जेक्ट के उपनाम हैं:

console.log(xyz === abc); // prints "true"

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

function abc(){};
console.log(abc.name); // prints "abc"

इसका नाम स्वचालित रूप से असाइन किया गया है। लेकिन जब आप इसे परिभाषित करते हैं

var abc = function(){};
console.log(abc.name); // prints ""

इसका नाम खाली है - हमने एक अनाम कार्य बनाया है और इसे कुछ चर के लिए असाइन किया है।

संयुक्त शैली का उपयोग करने का एक और अच्छा कारण बाहरी उपयोगकर्ताओं के लिए एक लंबा गैर-विरोधी नाम प्रदान करते समय स्वयं को संदर्भित करने के लिए एक छोटा आंतरिक नाम उपयोग करना है:

// Assume really.long.external.scoped is {}
really.long.external.scoped.name = function shortcut(n){
  // Let it call itself recursively:
  shortcut(n - 1);
  // ...
  // Let it pass itself as a callback:
  someFunction(shortcut);
  // ...
}

ऊपर दिए गए उदाहरण में हम बाहरी नाम के साथ ऐसा ही कर सकते हैं, लेकिन यह बहुत ही कमजोर (और धीमी) होगी।

(खुद को संदर्भित करने का एक और तरीका है arguments.callee का उपयोग करना, जो अभी भी अपेक्षाकृत लंबा है, और सख्त मोड में समर्थित नहीं है।)

गहराई से, जावास्क्रिप्ट दोनों बयान अलग-अलग व्यवहार करता है। यह एक समारोह घोषणा है:

function abc(){}

यहां abc को मौजूदा दायरे में हर जगह परिभाषित किया गया है:

// We can call it here
abc(); // Works

// Yet, it is defined down there.
function abc(){}

// We can call it again
abc(); // Works

इसके अलावा, यह एक return कथन के माध्यम से फहराया:

// We can call it here
abc(); // Works
return;
function abc(){}

यह एक समारोह अभिव्यक्ति है:

var xyz = function(){};

xyz यहां असाइनमेंट के बिंदु से परिभाषित किया गया है:

// We can't call it here
xyz(); // UNDEFINED!!!

// Now it is defined
xyz = function(){}

// We can call it here
xyz(); // works

फंक्शन घोषणा बनाम फ़ंक्शन अभिव्यक्ति वास्तविक कारण है कि ग्रेग द्वारा प्रदर्शित एक अंतर क्यों है।

मजेदार तथ्य:

var xyz = function abc(){};
console.log(xyz.name); // Prints "abc"

निजी तौर पर, मैं "फ़ंक्शन अभिव्यक्ति" घोषणा पसंद करता हूं क्योंकि इस तरह से मैं दृश्यता को नियंत्रित कर सकता हूं। जब मैं इस तरह के समारोह को परिभाषित करता हूं

var abc = function(){};

मुझे पता है कि मैंने स्थानीय रूप से फ़ंक्शन को परिभाषित किया है। जब मैं इस तरह के समारोह को परिभाषित करता हूं

abc = function(){};

मुझे पता है कि मैंने इसे विश्व स्तर पर परिभाषित किया है कि मैंने स्कॉप्स की श्रृंखला में कहीं भी abc परिभाषित नहीं किया है। eval() अंदर उपयोग किए जाने पर भी परिभाषा की यह शैली लचीला है। परिभाषा के दौरान

function abc(){};

संदर्भ पर निर्भर करता है और आपको अनुमान लगा सकता है कि इसे वास्तव में परिभाषित किया गया है, खासकर eval() के मामले में - जवाब है: यह ब्राउज़र पर निर्भर करता है।


यहां मानक रूपों पर रैंडडाउन है जो कार्य बनाते हैं: (मूल रूप से किसी अन्य प्रश्न के लिए लिखा गया है, लेकिन कैननिकल प्रश्न में स्थानांतरित होने के बाद अनुकूलित किया गया है।)

शर्तें:

त्वरित सूची:

  • समारोह घोषणा

  • "बेनामी" function अभिव्यक्ति (जो शब्द के बावजूद, कभी-कभी नामों के साथ फ़ंक्शन बनाती है)

  • नामित function अभिव्यक्ति

  • एक्सेसर फ़ंक्शन प्रारंभकर्ता (ES5 +)

  • तीर फ़ंक्शन अभिव्यक्ति (ES2015 +) (जो, अज्ञात फ़ंक्शन अभिव्यक्तियों की तरह, एक स्पष्ट नाम शामिल नहीं है, और फिर भी नामों के साथ फ़ंक्शन बना सकता है)

  • ऑब्जेक्ट इनिशिलाइज़र में विधि घोषणा (ES2015 +)

  • class में कन्स्ट्रक्टर और विधि घोषणाएं (ES2015 +)

समारोह घोषणा

पहला रूप एक समारोह घोषणा है , जो इस तरह दिखता है:

function x() {
    console.log('x');
}

एक समारोह घोषणा एक घोषणा है ; यह एक बयान या अभिव्यक्ति नहीं है। इस प्रकार, आप इसका पालन नहीं करते हैं ; (हालांकि ऐसा करना हानिरहित है)।

किसी चरण-दर-चरण कोड को निष्पादित करने से पहले निष्पादन उस संदर्भ में प्रवेश करता है जब निष्पादन में प्रकट होता है, एक फ़ंक्शन घोषणा संसाधित की जाती है। जो फ़ंक्शन बनाता है उसे उचित नाम दिया जाता है (ऊपर दिए गए उदाहरण में x ), और वह नाम उस दायरे में रखा जाता है जिसमें घोषणा प्रकट होती है।

चूंकि इसे एक ही संदर्भ में चरण-दर-चरण कोड से पहले संसाधित किया जाता है, इसलिए आप इस तरह की चीजें कर सकते हैं:

x(); // Works even though it's above the declaration
function x() {
    console.log('x');
}

ES2015 तक, कल्पना में शामिल नहीं था कि जावास्क्रिप्ट इंजन को क्या करना चाहिए यदि आप नियंत्रण संरचना के अंदर फ़ंक्शन घोषणा जैसे try , if , switch , इत्यादि, जैसे:

if (someCondition) {
    function foo() {    // <===== HERE THERE
    }                   // <===== BE DRAGONS
}

और चूंकि चरण-दर-चरण कोड चलाने से पहले उन्हें संसाधित किया जाता है, इसलिए यह जानना मुश्किल होता है कि जब वे नियंत्रण संरचना में होते हैं तो क्या करना है।

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

ES2015 के अनुसार, विनिर्देश कहता है कि क्या करना है। वास्तव में, यह करने के लिए तीन अलग-अलग चीजें देता है:

  1. यदि एक वेब ब्राउज़र पर ढीला मोड नहीं है, तो जावास्क्रिप्ट इंजन को एक काम करना चाहिए
  2. यदि किसी वेब ब्राउज़र पर ढीले मोड में, जावास्क्रिप्ट इंजन को कुछ और करना है
  3. यदि सख्त मोड (ब्राउज़र या नहीं) में, जावास्क्रिप्ट इंजन को अभी तक एक और चीज करना है

ढीले मोड के नियम मुश्किल हैं, लेकिन सख्त मोड में, ब्लॉक में फ़ंक्शन घोषणाएं आसान हैं: वे ब्लॉक के लिए स्थानीय हैं (उनके पास ब्लॉक स्कोप है , जो ES2015 में भी नया है), और वे शीर्ष पर फिसल गए हैं ब्लॉक का इसलिए:

"use strict";
if (someCondition) {
    foo();               // Works just fine
    function foo() {
    }
}
console.log(typeof foo); // "undefined" (`foo` is not in scope here
                         // because it's not in the same block)

"बेनामी" function अभिव्यक्ति

दूसरे सामान्य रूप को अनाम कार्य अभिव्यक्ति कहा जाता है:

var y = function () {
    console.log('y');
};

सभी अभिव्यक्तियों की तरह, यह मूल्यांकन किया जाता है जब यह कोड के चरण-दर-चरण निष्पादन में पहुंच जाता है।

ईएस 5 में, इस रचना के फ़ंक्शन का कोई नाम नहीं है (यह अनाम है)। ES2015 में, फ़ंक्शन को संदर्भ से संदर्भित करके संभवतः एक नाम असाइन किया गया है। उपर्युक्त उदाहरण में, नाम y होगा। कुछ ऐसा ही किया जाता है जब फ़ंक्शन किसी प्रॉपर्टी प्रारंभकर्ता का मान होता है। (यह कब होता है और नियमों के विवरण के लिए , विनिर्देशन में SetFunctionName खोज करें - यह पूरे स्थान पर दिखाई देता है।)

नामित function अभिव्यक्ति

तीसरा रूप एक नामित फ़ंक्शन अभिव्यक्ति ("एनएफई") है:

var z = function w() {
    console.log('zw')
};

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

var z = function w() {
    console.log(typeof w); // "function"
};
console.log(typeof w);     // "undefined"

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

एक्सेसर फ़ंक्शन प्रारंभकर्ता (ES5 +)

कभी-कभी कार्य बड़े पैमाने पर अनजान में छेड़छाड़ कर सकते हैं; यह एक्सेसर फ़ंक्शंस के मामले में है। यहां एक उदाहरण दिया गया है:

var obj = {
    value: 0,
    get f() {
        return this.value;
    },
    set f(v) {
        this.value = v;
    }
};
console.log(obj.f);         // 0
console.log(typeof obj.f);  // "number"

ध्यान दें कि जब मैंने फ़ंक्शन का उपयोग किया, तो मैंने () उपयोग नहीं किया! ऐसा इसलिए है क्योंकि यह किसी संपत्ति के लिए एक एक्सेसर फ़ंक्शन है । हम संपत्ति को सामान्य तरीके से प्राप्त करते हैं और सेट करते हैं, लेकिन दृश्यों के पीछे, फ़ंक्शन को कॉल किया जाता है।

आप Object.defineProperty , Object.defineProperties , और Object.defineProperties लिए कम ज्ञात दूसरे तर्क के साथ Object.defineProperty फ़ंक्शंस भी बना सकते हैं।

तीर फंक्शन अभिव्यक्ति (ES2015 +)

ES2015 हमें तीर समारोह लाता है। यहां एक उदाहरण दिया गया है:

var a = [1, 2, 3];
var b = a.map(n => n * 2);
console.log(b.join(", ")); // 2, 4, 6

देखें कि n => n * 2 चीज़ map() में छिपा रही है map() कॉल? यह एक समारोह है।

तीर कार्यों के बारे में कुछ चीजें:

  1. उनके पास यह स्वयं नहीं है। इसके बजाय, वे संदर्भ के this पर बंद होते हैं जहां उन्हें परिभाषित किया जाता है। (वे arguments भी बंद करते arguments , जहां प्रासंगिक, super ।) इसका मतलब है कि this उनके भीतर समान है, जहां वे बनाए गए हैं, और बदला नहीं जा सकता है।

  2. जैसा कि आपने उपरोक्त के साथ देखा होगा, आप कीवर्ड function उपयोग नहीं करते हैं; इसके बजाय, आप => उपयोग करते हैं।

ऊपर n => n * 2 उदाहरण उनमें से एक रूप है। यदि आपके पास फ़ंक्शन पास करने के लिए कई तर्क हैं, तो आप माता-पिता का उपयोग करते हैं:

var a = [1, 2, 3];
var b = a.map((n, i) => n * i);
console.log(b.join(", ")); // 0, 2, 6

(याद रखें कि Array#map प्रवेश को पहले तर्क के रूप में पास करता है, और सूचकांक दूसरे के रूप में।)

दोनों मामलों में, समारोह का शरीर सिर्फ एक अभिव्यक्ति है; फ़ंक्शन का रिटर्न वैल्यू स्वचालित रूप से उस अभिव्यक्ति का परिणाम होगा (आप एक स्पष्ट return उपयोग नहीं करते return )।

यदि आप केवल एक अभिव्यक्ति से अधिक कर रहे हैं, तो {} और एक स्पष्ट return (यदि आपको मूल्य वापस करने की आवश्यकता है) का उपयोग करें, सामान्य के रूप में:

var a = [
  {first: "Joe", last: "Bloggs"},
  {first: "Albert", last: "Bloggs"},
  {first: "Mary", last: "Albright"}
];
a = a.sort((a, b) => {
  var rv = a.last.localeCompare(b.last);
  if (rv === 0) {
    rv = a.first.localeCompare(b.first);
  }
  return rv;
});
console.log(JSON.stringify(a));

{ ... } बिना संस्करण को अभिव्यक्ति निकाय या संक्षिप्त निकाय के साथ एक तीर फ़ंक्शन कहा जाता है । (इसके अलावा: एक संक्षिप्त तीर समारोह।) शरीर के साथ परिभाषित { ... } एक समारोह शरीर के साथ एक तीर समारोह है । (इसके अलावा: एक वर्बोज़ तीर समारोह।)

ऑब्जेक्ट इनिशिलाइज़र में विधि घोषणा (ES2015 +)

ES2015 एक ऐसी संपत्ति घोषित करने का एक छोटा रूप प्रदान करता है जो किसी फ़ंक्शन का संदर्भ देता है; यह इस तरह दिख रहा है:

var o = {
    foo() {
    }
};

ईएस 5 और पहले के बराबर होगा:

var o = {
    foo: function foo() {
    }
};

class में कन्स्ट्रक्टर और विधि घोषणाएं (ES2015 +)

ES2015 हमें घोषित रचनाकारों और विधियों सहित class वाक्यविन्यास लाता है:

class Person {
    constructor(firstName, lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }

    getFullName() {
        return this.firstName + " " + this.lastName;
    }
}

ऊपर दो फ़ंक्शन घोषणाएं हैं: एक कन्स्ट्रक्टर के लिए, जिसे नाम Person जाता है, और getFullName लिए एक, जो Person.prototype को सौंपा गया एक फ़ंक्शन है।


About performance:

New versions of V8 introduced several under-the-hood optimizations and so did SpiderMonkey .

There is almost no difference now between expression and declaration.
Function expression appears to be faster now.

Chrome 62.0.3202

FireFox 55

Chrome Canary 63.0.3225


Anonymous function expressions appear to have better performance against Named function expression.


Firefox Chrome Canary Chrome


एक महत्वपूर्ण कारण है कि एक और केवल एक चर को अपने नेमस्पेस के "रूट" के रूप में जोड़ें ...

var MyNamespace = {}
MyNamespace.foo= function() {

}

या

var MyNamespace = {
  foo: function() {
  },
  ...
}

नेमस्पेसिंग के लिए कई तकनीकें हैं। यह उपलब्ध जावास्क्रिप्ट मॉड्यूल की पर्याप्तता के साथ और अधिक महत्वपूर्ण हो गया है।

यह भी देखें कि मैं जावास्क्रिप्ट में नेमस्पेस कैसे घोषित करूं?


अंतर यह है कि functionOne एक फ़ंक्शन अभिव्यक्ति है और इसलिए केवल उस पंक्ति को तब तक परिभाषित किया जाता है जब functionTwo एक फ़ंक्शन घोषणा होती है और जैसे ही इसके आसपास के फ़ंक्शन या स्क्रिप्ट को निष्पादित किया जाता है ( hoisting कारण)।

उदाहरण के लिए, एक फ़ंक्शन अभिव्यक्ति:

// TypeError: functionOne is not a function
functionOne();

var functionOne = function() {
  console.log("Hello!");
};

और, एक समारोह घोषणा:

// Outputs: "Hello!"
functionTwo();

function functionTwo() {
  console.log("Hello!");
}

इसका मतलब यह भी है कि आप फ़ंक्शन घोषणाओं का उपयोग करके फ़ंक्शंस को सशर्त रूप से परिभाषित नहीं कर सकते हैं:

if (test) {
   // Error or misbehavior
   function functionThree() { doSomething(); }
}

उपर्युक्त वास्तव में functionThree को परिभाषित करता है test के मूल्य के बावजूद - जब तक use strict प्रभावी नहीं होता है, इस मामले में यह केवल एक त्रुटि उठाता है।


The first one (function doSomething(x)) should be part of an object notation.

The second one ( var doSomething = function(x){ alert(x);} ) is simply creating an anonymous function and assigning it to a variable, doSomething . So doSomething() will call the function.

You may want to know what a function declaration and function expression is.

A function declaration defines a named function variable without requiring variable assignment. Function declarations occur as standalone constructs and cannot be nested within non-function blocks.

function foo() {
    return 3;
}

ECMA 5 (13.0) defines the syntax as
function Identifier ( FormalParameterList opt ) { FunctionBody }

In above condition the function name is visible within its scope and the scope of its parent (otherwise it would be unreachable).

And in a function expression

A function expression defines a function as a part of a larger expression syntax (typically a variable assignment ). Functions defined via functions expressions can be named or anonymous. Function expressions should not start with “function”.

// Anonymous function expression
var a = function() {
    return 3;
}

// Named function expression
var a = function foo() {
    return 3;
}

// Self-invoking function expression
(function foo() {
    alert("hello!");
})();

ECMA 5 (13.0) defines the syntax as
function Identifier opt ( FormalParameterList opt ) { FunctionBody }


If you would use those functions to create objects, you would get:

var objectOne = new functionOne();
console.log(objectOne.__proto__); // prints "Object {}" because constructor is an anonymous function

var objectTwo = new functionTwo();
console.log(objectTwo.__proto__); // prints "functionTwo {}" because constructor is a named function

This is just two possible ways of declaring functions, and in the second way, you can use the function before declaration.


Another difference that is not mentioned in the other answers is that if you use the anonymous function

var functionOne = function() {
    // Some code
};

and use that as a constructor as in

var one = new functionOne();

then one.constructor.name will not be defined. Function.name is non-standard but is supported by Firefox, Chrome, other Webkit-derived browsers and IE 9+.

With

function functionTwo() {
    // Some code
}
two = new functionTwo();

it is possible to retrieve the name of the constructor as a string with two.constructor.name .


The first example is a function declaration:

function abc(){}

The second example is a function expression:

var abc = function() {};

The main difference is how they are hoisted (lifted and declared). In the first example, the whole function declaration is hoisted. In the second example only the var 'abc' is hoisted, its value (the function) will be undefined, and the function itself remains at the position that it is declared.

To put it simply:

//this will work
abc(param);
function abc(){}

//this would fail
abc(param);
var abc = function() {}

To study more about this topic I strongly recommend you this link


There are three noteworthy comparisons between the two different declarations of functions as listed below.

  1. Availability (scope) of the function

The following works because function add() is scoped to the nearest block:

try {
  console.log("Success: ", add(1, 1));
} catch(e) {
  console.log("ERROR: " + e);
}

function add(a, b){
  return a + b;
}

The following does not works (because the var add= superseeds the function add() ).

try {
  console.log("Success: ", add(1, 1));
} catch(e) {
  console.log("ERROR: " + e);
}

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

The following does not work because add is declared after it is used.

try {
  console.log("Success: ", add(1, 1));
} catch(e) {
  console.log("ERROR: " + e);
}

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

  1. (function) .name

The name of a function function thefuncname(){} is thefuncname when it is declared this way.

function foobar(a, b){}

console.log(foobar.name);

var a = function foobar(){};

console.log(a.name);

Otherwise, if a function is declared as function(){} , the function .name is the first variable used to store the function.

var a = function(){};
var b = (function(){ return function(){} });

console.log(a.name);
console.log(b.name);

If there are no variables set to the function, then the functions name is the empty string ( "" ).

console.log((function(){}).name === "");

Lastly, while the variable the function is assigned to initially sets the name, successive variables set to the function do not change the name.

var a = function(){};
var b = a;
var c = b;

console.log(a.name);
console.log(b.name);
console.log(c.name);

  1. प्रदर्शन

In Google's V8 and Firefox's Spidermonkey there might be a few microsecond JIST compilation difference, but ultimately the result is the exact same. To prove this, let's examine the efficiency of JSPerf at microbenchmarks by comparing the speed of two blank code snippets. The JSPerf tests are found here . And, the jsben.ch testsare found here . As you can see, there is a noticable difference when there should be none. If you are really a performance freak like me, then it might be more worth your while trying to reduce the number of variables and functions in the scope and especially eliminating polymorphism (such as using the same variable to store two different types).

What Is The "Nearest Block"

The "nearest block" is the nearest "function," (including asynchronous functions, generator functions, and asynchronous generator functions). However, interestingly, a function functionName() {} behaves like a var functionName = function() {} when in a non-closure block to items outside said closure. Observe.

  • Normal var add=function(){}

try {
  // typeof will simply return "undefined" if the variable does not exist
  if (typeof add !== "undefined") {
    add(1, 1); // just to prove it
    console.log("Not a block");
  }else if(add===undefined){ // this throws an exception if add doesn't exist
    console.log('Behaves like var add=function(a,b){return a+b}');
  }
} catch(e) {
  console.log("Is a block");
}
var add=function(a, b){return a + b}

  • Normal function add(){}

try {
  // typeof will simply return "undefined" if the variable does not exist
  if (typeof add !== "undefined") {
    add(1, 1); // just to prove it
    console.log("Not a block");
  }else if(add===undefined){ // this throws an exception if add doesn't exist
    console.log('Behaves like var add=function(a,b){return a+b}')
  }
} catch(e) {
  console.log("Is a block");
}
function add(a, b){
  return a + b;
}

  • समारोह

try {
  // typeof will simply return "undefined" if the variable does not exist
  if (typeof add !== "undefined") {
    add(1, 1); // just to prove it
    console.log("Not a block");
  }else if(add===undefined){ // this throws an exception if add doesn't exist
    console.log('Behaves like var add=function(a,b){return a+b}')
  }
} catch(e) {
  console.log("Is a block");
}
(function () {
    function add(a, b){
      return a + b;
    }
})();

  • Statement (such as if , else , for , while , try / catch / finally , switch , do / while , with )

try {
  // typeof will simply return "undefined" if the variable does not exist
  if (typeof add !== "undefined") {
    add(1, 1); // just to prove it
    console.log("Not a block");
  }else if(add===undefined){ // this throws an exception if add doesn't exist
    console.log('Behaves like var add=function(a,b){return a+b}')
  }
} catch(e) {
  console.log("Is a block");
}
{
    function add(a, b){
      return a + b;
    }
}

  • Arrow Function with var add=function()

try {
  // typeof will simply return "undefined" if the variable does not exist
  if (typeof add !== "undefined") {
    add(1, 1); // just to prove it
    console.log("Not a block");
  }else if(add===undefined){ // this throws an exception if add doesn't exist
    console.log('Behaves like var add=function(a,b){return a+b}')
  }
} catch(e) {
  console.log("Is a block");
}
(() => {
    var add=function(a, b){
      return a + b;
    }
})();

  • Arrow Function With function add()

try {
  // typeof will simply return "undefined" if the variable does not exist
  if (typeof add !== "undefined") {
    add(1, 1); // just to prove it
    console.log("Not a block");
  }else if(add===undefined){ // this throws an exception if add doesn't exist
    console.log('Behaves like var add=function(a,b){return a+b}')
  }
} catch(e) {
  console.log("Is a block");
}
(() => {
    function add(a, b){
      return a + b;
    }
})();


I use the variable approach in my code for a very specific reason, the theory of which has been covered in an abstract way above, but an example might help some people like me, with limited JavaScript expertise.

I have code that I need to run with 160 independently-designed brandings. Most of the code is in shared files, but branding-specific stuff is in a separate file, one for each branding.

Some brandings require specific functions, and some do not. Sometimes I have to add new functions to do new branding-specific things. I am happy to change the shared coded, but I don't want to have to change all 160 sets of branding files.

By using the variable syntax, I can declare the variable (a function pointer essentially) in the shared code and either assign a trivial stub function, or set to null.

The one or two brandings that need a specific implementation of the function can then define their version of the function and assign this to the variable if they want, and the rest do nothing. I can test for a null function before I execute it in the shared code.

From people's comments above, I gather it may be possible to redefine a static function too, but I think the variable solution is nice and clear.


वैश्विक संदर्भ के बारे में बोलते हुए, दोनों तरफ var कथन और एक FunctionDeclaration घोषणा वैश्विक वस्तु पर एक गैर-हटाने योग्य संपत्ति बनायेगी , लेकिन दोनों का मूल्य ओवरराइट किया जा सकता है

दोनों तरीकों के बीच सूक्ष्म अंतर यह है कि जब परिवर्तनीय इंस्टेंटेशन प्रक्रिया चलती है (वास्तविक कोड निष्पादन से पहले) var साथ घोषित सभी पहचानकर्ताओं को undefined साथ प्रारंभ किया जाएगा, और undefined द्वारा उपयोग किए जाने वाले लोगों को उस पल के बाद उपलब्ध होगा उदाहरण:

 alert(typeof foo); // 'function', it's already available
 alert(typeof bar); // 'undefined'
 function foo () {}
 var bar = function () {};
 alert(typeof bar); // 'function'

bar FunctionExpression bar असाइनमेंट रनटाइम तक होता है।

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

 function test () {}
 test = null;

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

आपके संपादित पहले उदाहरण के बारे में ( foo = function() { alert('hello!'); }; ), यह एक अविकसित असाइनमेंट है, मैं आपको अत्यधिक कीवर्ड का हमेशा उपयोग करने के लिए प्रोत्साहित करता हूं।

एक असाइनमेंट के साथ, var स्टेटमेंट के बिना, यदि संदर्भित पहचानकर्ता स्कोप श्रृंखला में नहीं मिलता है, तो यह वैश्विक ऑब्जेक्ट की एक हटाने योग्य संपत्ति बन जाएगा।

इसके अलावा, अविकसित असाइनमेंट सख्त मोड के तहत ECMAScript 5 पर एक ReferenceError त्रुटि फेंक देते हैं।

एक अवश्य पढ़ने की बात:

नोट : यह उत्तर किसी अन्य प्रश्न से विलय कर दिया गया है, जिसमें ओपी से प्रमुख संदेह और गलत धारणा थी कि फंक्शनडेक्लेरेशन के साथ घोषित पहचानकर्ताओं को अधिलेखित नहीं किया जा सकता था, जो मामला नहीं है।


new Function() can be used to pass the function's body in a string. And hence this can be used to create dynamic functions. Also passing the script without executing the script.

var func = new Function("x", "y", "return x*y;");
function secondFunction(){
   var result;
   result = func(10,20);
   console.log ( result );
}

secondFunction()

आपके द्वारा पोस्ट किए गए दो कोड स्निपेट, लगभग सभी उद्देश्यों के लिए, वैसे ही व्यवहार करेंगे।

हालांकि, व्यवहार में अंतर यह है कि पहले संस्करण ( var functionOne = function() {} ) के साथ, उस फ़ंक्शन को कोड में उस बिंदु के बाद ही बुलाया जा सकता है।

दूसरे संस्करण ( function functionTwo() ) के साथ, फ़ंक्शन कोड के लिए उपलब्ध है जो ऊपर चलाता है जहां फ़ंक्शन घोषित किया जाता है।

ऐसा इसलिए है क्योंकि पहले संस्करण के साथ, कार्य रन टाइम पर परिवर्तनीय foo को सौंपा गया है। दूसरे में, कार्य उस पहचानकर्ता, foo , पार्स समय पर असाइन किया गया है।

अधिक तकनीकी जानकारी

जावास्क्रिप्ट में कार्यों को परिभाषित करने के तीन तरीके हैं।

  1. आपका पहला स्निपेट फ़ंक्शन अभिव्यक्ति दिखाता है। इसमें फ़ंक्शन बनाने के लिए "फ़ंक्शन" ऑपरेटर का उपयोग करना शामिल है - उस ऑपरेटर का परिणाम किसी भी चर या ऑब्जेक्ट प्रॉपर्टी में संग्रहीत किया जा सकता है। फ़ंक्शन अभिव्यक्ति उस तरह शक्तिशाली है। फ़ंक्शन अभिव्यक्ति को अक्सर "अज्ञात फ़ंक्शन" कहा जाता है, क्योंकि इसका नाम नहीं होना चाहिए,
  2. आपका दूसरा उदाहरण एक समारोह घोषणा है । यह फ़ंक्शन बनाने के लिए "फ़ंक्शन" कथन का उपयोग करता है। समारोह पार्स समय पर उपलब्ध कराया गया है और उस दायरे में कहीं भी कहा जा सकता है। आप इसे बाद में एक चर या ऑब्जेक्ट प्रॉपर्टी में स्टोर कर सकते हैं।
  3. फ़ंक्शन को परिभाषित करने का तीसरा तरीका "फ़ंक्शन ()" कन्स्ट्रक्टर है , जो आपकी मूल पोस्ट में नहीं दिखाया गया है। इसका उपयोग करने की अनुशंसा नहीं की जाती क्योंकि यह eval() जैसी ही काम करता है, जिसमें इसकी समस्याएं होती हैं।

ग्रेग के जवाब के लिए एक बेहतर स्पष्टीकरण

functionTwo();
function functionTwo() {
}

कोई त्रुटि क्यों नहीं? हमें हमेशा सिखाया जाता था कि अभिव्यक्ति को ऊपर से नीचे तक निष्पादित किया जाता है (??)

इसलिये:

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

इसका मतलब है कि इस तरह का कोड:

functionOne();                  ---------------      var functionOne;
                                | is actually |      functionOne();
var functionOne = function(){   | interpreted |-->
};                              |    like     |      functionOne = function(){
                                ---------------      };

ध्यान दें कि घोषणाओं का असाइनमेंट हिस्सा फहराया नहीं गया था। केवल नाम फहराया गया है।

लेकिन समारोह घोषणाओं के मामले में, पूरे समारोह निकाय को भी फहराया जाएगा :

functionTwo();              ---------------      function functionTwo() {
                            | is actually |      };
function functionTwo() {    | interpreted |-->
}                           |    like     |      functionTwo();
                            ---------------

उपयोग करने के लिए एक अच्छा मुद्दा है ! airbnb जावास्क्रिप्ट गाइड पर चिह्नित फ़ंक्शन आमंत्रण के लिए

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

!function abc(){}()
!function bca(){}();

के रूप में काम करेंगे

!function abc(){}()
;(function bca(){})();

लेकिन दो अक्षर बचाता है और मनमाने ढंग से बेहतर दिखता है।

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

abcval = !function abc(){return true;}() // abcval equals false
bcaval = +function bca(){return true;}() // bcaval equals 1
zyxval = -function zyx(){return true;}() // zyxval equals -1
xyzval = ~function xyz(){return true;}() // your guess?

लेकिन यदि आप एक फ़ाइल के लिए आईआईएफई पैटर्न का उपयोग करते हैं तो एक मॉड्यूल कोड अलगाव और अनुकूलन के लिए कॉन्सट टूल का उपयोग करना (जो एक लाइन एक फ़ाइल नौकरी बनाता है), निर्माण से

!function abc(/*no returns*/) {}()
+function bca() {/*no returns*/}()

सुरक्षित कोड निष्पादन करेगा, जैसा कि पहले कोड नमूना के समान होगा।

यह त्रुटि कारण फेंक देगा क्योंकि जावास्क्रिप्ट एएसआई अपना काम नहीं कर पाएगा।

!function abc(/*no returns*/) {}()
(function bca() {/*no returns*/})()

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

यह काम:

!function abc(/*no returns*/) {}()
^function bca() {/*no returns*/}()

यह नहीं:

^function abc(/*no returns*/) {}()
!function bca() {/*no returns*/}()




javascript function syntax idioms