[javascript] var functionName = function () {} vs ফাংশন ফাংশন নাম () {}



14 Answers

প্রথমত আমি গ্রেগকে সংশোধন করতে চাই: 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 উভয় একই বস্তুর aliases হয়:

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(){};

আমি জানি যে আমি বিশ্বব্যাপী এটি সরবরাহ করেছি যে আমি scopes শৃঙ্খলে যেকোনো জায়গায় abc সংজ্ঞায়িত করে নি। সংজ্ঞা এই শৈলী eval() ব্যবহৃত যখন এমনকি স্থিতিশীল। যদিও সংজ্ঞা

function abc(){};

প্রেক্ষাপটে নির্ভর করে এবং আপনাকে প্রকৃতপক্ষে যেখানে এটি প্রকৃতপক্ষে সংজ্ঞায়িত করা হয় অনুমান করতে পারে, বিশেষত eval() এর উত্তর - উত্তরটি হল: এটি ব্রাউজারের উপর নির্ভর করে।

Question

আমি সম্প্রতি অন্য কারো জাভাস্ক্রিপ্ট কোড বজায় রাখতে শুরু করেছি। আমি বাগ সংশোধন করছি, বৈশিষ্ট্য যুক্ত করছি, এবং কোডটি পরিষ্কার করার চেষ্টা করছি এবং এটি আরও সামঞ্জস্যপূর্ণ করে তুলছি।

পূর্ববর্তী বিকাশকারী ফাংশন ঘোষণা করার দুটি উপায়ে ব্যবহার করে এবং এটির পিছনে কোনো কারণ থাকলে আমি কাজ করতে পারছি না।

দুটি উপায় হল:

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

এই দুটি বিভিন্ন পদ্ধতি ব্যবহার করার জন্য কি কারণ এবং প্রতিটি এর পেশাদার এবং বিপর্যয় কি? এমন কি এমন কিছু আছে যা এক পদ্ধতিতে করা যায় যা অন্যের সাথে করা যায় না?




একটি উদাহরণ দেয় যেখানে তিনি নিজেই একটি অভ্যন্তরীণ রেফারেন্স হিসাবে ব্যবহার করতে সক্ষম একটি নির্দিষ্ট ফাংশন নামshortcut()জন রেসিগ আরেকটি উদাহরণ দিয়েছেন - তার পুনর্ব্যবহারযোগ্য জাভাস্ক্রিপ্ট টিউটোরিয়ালের অন্য বস্তুতে বরাদ্দ করা একটি পুনরাবৃত্তিমূলক ফাংশন অনুলিপি করা । বৈশিষ্ট্যগুলিতে ফাংশন বরাদ্দ করার সময় এখানে কঠোরভাবে প্রশ্ন নেই, আমি টিউটোরিয়ালটি সক্রিয়ভাবে চেষ্টা করার পরামর্শ দিচ্ছি - উপরের ডান কোণায় বোতামটি ক্লিক করে কোডটি চালান এবং আপনার পছন্দ অনুসারে সম্পাদনা করতে কোডটিতে ডাবল ক্লিক করুন।

টিউটোরিয়াল থেকে উদাহরণ: পুনরাবৃত্তি কল yell():

মূল নিনজা বস্তু মুছে ফেলা হয় যখন টেস্ট ব্যর্থ। (পৃষ্ঠা 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?" ); 
}

যদি আপনি ফাংশন নামকরণ করেন যা পুনরাবৃত্তি বলা হবে, পরীক্ষাগুলি পাস হবে। (পৃষ্ঠা 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." );



আমি নিচে পার্থক্য তালিকাভুক্ত করছি:

  1. একটি ফাংশন ঘোষণা কোডে যে কোন জায়গায় স্থাপন করা যেতে পারে। কোডটিতে সংজ্ঞাটি উপস্থিত হওয়ার আগে এটি আহ্বান করা হলেও এটি ফাংশন ঘোষণাকে মেমরির জন্য প্রতিশ্রুতিবদ্ধ করা হয় বা পৃষ্ঠাতে যেকোনো কোড কার্যকর করার আগে এটি ফাঁকা করা হয়।

    নীচের ফাংশন তাকান:

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

    কারণ, মৃত্যুদন্ড কার্যকর করার সময়, এটি মনে হচ্ছে: -

    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
    

    একটি ফাংশন এক্সপ্রেশন, এটি কল করার আগে সংজ্ঞায়িত না হলে, একটি ত্রুটি হতে হবে। এছাড়াও, এখানে ফাংশন সংজ্ঞাটি নিজেই শীর্ষে স্থানান্তরিত হয় না বা ফাংশন ঘোষণার মতো মেমরিতে প্রতিশ্রুতিবদ্ধ হয় না। কিন্তু যে ভেরিয়েবল আমরা ফাংশন বরাদ্দ করি তা হোল্ড হয়ে যায় এবং অনির্ধারিত এটি নির্ধারিত হয়।

    ফাংশন এক্সপ্রেশন ব্যবহার করে একই ফাংশন:

    if (test) {
        function x() { doSomething(); }
    }
    

    কারণ মৃত্যুদন্ড কার্যকর করার সময় এটি মনে হচ্ছে:

    var today = function today() {return new Date()}
    
  2. অ-ফাংশন ব্লকগুলিতে ফাংশন ঘোষণাগুলি লিখতে নিরাপদ নয় যেমন যদি তারা অ্যাক্সেসযোগ্য না হয়।

    function foo() {
        return 3;
    }
    
  3. নিচের মত ফাংশন এক্সপ্রেশন, সংস্করণ 9 এর আগে ইন্টারনেট এক্সপ্লোরার ব্রাউজারে কাজ করতে পারে না।

    // 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!");
    })();
    



গ্রেগ এর উত্তর একটি ভাল ব্যাখ্যা

functionTwo();
function functionTwo() {
}

কেন কোন ত্রুটি? আমরা সর্বদা শেখানো হয় যে এক্সপ্রেশন উপরের থেকে নীচে (??)

কারণ:

ফাংশন ঘোষণা এবং পরিবর্তনশীল ঘোষণা সর্বদা জাভাস্ক্রিপ্ট ইন্টারপ্রেটার দ্বারা তাদের ধারণকারী সুযোগের উপরে অদৃশ্যভাবে সরানো ( hoisted ) করা হয়। ফাংশন পরামিতি এবং ভাষা সংজ্ঞায়িত নাম, অবশ্যই, ইতিমধ্যে সেখানে আছে। বেন চেরি

এর মানে এই যে কোড:

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

ঘোষণা করুন যে ঘোষণার বরাদ্দ অংশটি উত্তোলন করা হয়নি। শুধুমাত্র নাম উত্তোলন করা হয়।

কিন্তু ফাংশন ঘোষণা সঙ্গে ক্ষেত্রে, পুরো ফাংশন শরীর এছাড়াও উত্তোলন করা হবে :

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



আপনি বস্তু তৈরি করতে এই ফাংশন ব্যবহার করবে, আপনি পাবেন:

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



উভয় একটি ফাংশন সংজ্ঞায়িত বিভিন্ন উপায়। পার্থক্য হল কিভাবে ব্রাউজার ব্যাখ্যা করে এবং এটি একটি নির্বাহ প্রেক্ষাপটে লোড করে।

প্রথম ক্ষেত্রে ফাংশন এক্সপ্রেশনগুলি যা কেবল তখনই লোড হয় যখন ইন্টারপ্রেটারটি কোডের সেই লাইনটিতে পৌঁছায়। সুতরাং যদি আপনি এটি নীচের মত করেন তবে আপনি একটি ত্রুটি পাবেন যা ফাংশনটি একটি ফাংশন নয়

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

কারণটি হল প্রথম লাইনটিতে কোনও মান ফাংশনকে বরাদ্দ করা হয় না এবং তাই এটি অনির্ধারিত। আমরা এটি একটি ফাংশন হিসাবে কল করার চেষ্টা করছি, এবং অতএব আমরা একটি ত্রুটি হচ্ছে।

দ্বিতীয় লাইনে আমরা ফাংশনকে একটি বেনামী ফাংশনের রেফারেন্স বরাদ্দ করছি।

দ্বিতীয় ক্ষেত্রে ফাংশন ঘোষণা যে কোন কোড কার্যকর করা হয় আগে লোড হয়। সুতরাং যদি আপনি নিম্নলিখিতটি পছন্দ করেন তবে কোড এক্সিকিউশন আগে ঘোষণা লোড হিসাবে আপনি কোন ত্রুটি পাবেন না।

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



কোড রক্ষণাবেক্ষণ খরচ শর্তাবলী, নামযুক্ত ফাংশন আরো ভাল হয়:

  • যেখানে তারা ঘোষণা করা হয় থেকে স্বাধীন (কিন্তু এখনও সুযোগ দ্বারা সীমাবদ্ধ)।
  • শর্তসাপেক্ষ প্রাথমিককরণের মতো ভুলগুলির আরো প্রতিরোধী (যদি আপনি এখনও চেয়েছিলেন তবে আপনি ওভাররাইড করতে পারবেন)।
  • কোড সুযোগ কার্যকারিতা আলাদাভাবে স্থানীয় ফাংশন বরাদ্দ করে আরো পাঠযোগ্য হয়ে ওঠে। সাধারণত সুযোগ মধ্যে কার্যকারিতা প্রথম যায়, স্থানীয় ফাংশন ঘোষণা দ্বারা অনুসরণ।
  • ডিবাগারে আপনি "বেনামী / মূল্যায়ন" ফাংশনের পরিবর্তে কল স্ট্যাকের ফাংশন নামটি স্পষ্টভাবে দেখতে পাবেন।

আমি নামযুক্ত ফাংশন অনুসরণ করার জন্য আরো PROS সন্দেহ। এবং নামযুক্ত ফাংশন একটি সুবিধা হিসাবে তালিকাভুক্ত করা হয় বেনামী বেশী জন্য একটি অসুবিধা।

ঐতিহাসিকভাবে, বেনামী ফাংশনগুলি জাভাস্ক্রিপ্টের অক্ষমতার কারণে একটি ভাষা হিসাবে নাম তালিকাভুক্ত সদস্যদের তালিকাভুক্ত করে:

{
    member:function() { /* How do I make "this.member" a named function? */
    }
}



বৈশ্বিক প্রসঙ্গ সম্পর্কে বলার অপেক্ষা রাখে না, উভয়, var বিবৃতি এবং একটি FunctionDeclaration ডিক্লেয়ারেশন গ্লোবাল অবজেক্টে একটি অ- মুছে ফেলার যোগ্য সম্পত্তি তৈরি করবে, তবে উভয়ের মূল্য ওভাররাইট করা যেতে পারে

দুটি উপায়ে সূক্ষ্ম পার্থক্য হল যে যখন ভেরিয়েবল ইনস্ট্যান্টেশন প্রক্রিয়া চলবে (প্রকৃত কোড কার্যকর করার আগে) var সাথে ঘোষণা করা সমস্ত সনাক্তকারী undefined সঙ্গে শুরু হবে এবং FunctionDeclaration ডিক্লেয়ারেশন var দ্বারা ব্যবহৃত যে মুহূর্তগুলি সেই মুহুর্ত থেকে পাওয়া যাবে উদাহরণ:

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

bar FunctionExpression বরাদ্দ রানটাইম পর্যন্ত সঞ্চালিত হয়।

একটি FunctionDeclaration দ্বারা তৈরি একটি বিশ্বব্যাপী সম্পত্তি একটি পরিবর্তনশীল মানের মতো কোনও সমস্যা ছাড়াই ওভাররাইট করা যেতে পারে, উদাহরণস্বরূপ:

 function test () {}
 test = null;

আপনার দুটি উদাহরণের মধ্যে আরেকটি সুস্পষ্ট পার্থক্য হল প্রথম ফাংশনে একটি নাম নেই, তবে দ্বিতীয়টি এটি আছে যা ডিবাগ করার সময় সত্যিই উপকারী হতে পারে (যেমন একটি কল স্ট্যাক পরিদর্শন করা)।

আপনার সম্পাদিত প্রথম উদাহরণ সম্পর্কে ( foo = function() { alert('hello!'); }; ), এটি একটি অব্যবহৃত অ্যাসাইনমেন্ট, আমি আপনাকে var শব্দটি সর্বদা ব্যবহার করার জন্য উত্সাহিত করব।

ভ্যারেন্টমেন্ট ছাড়া কোনও অ্যাসাইনমেন্ট সহ, যদি রেফারেন্সড আইডেন্টিফায়ারটি স্কোপ শৃঙ্খলে পাওয়া না যায় তবে এটি গ্লোবাল অবজেক্টের একটি মুছে যাওয়াযোগ্য সম্পত্তি হয়ে যাবে।

এছাড়াও, অনির্ধারিত বরাদ্দগুলি কঠোর মোডের অধীনে ECMAScript 5 এ একটি ReferenceError ত্রুটি ফেলে।

একটি পড়তে হবে:

দ্রষ্টব্য : এই উত্তরটি অন্য প্রশ্ন থেকে মার্জ করা হয়েছে, যার মধ্যে OP থেকে প্রধান সন্দেহ এবং ভুল ধারণা ছিল FunctionDeclaration ডিক্লেয়ারেশন দ্বারা ঘোষিত শনাক্তকারী, কোনও ক্ষেত্রে এটি ওভাররাইট করা যাবে না।




কম্পিউটার বিজ্ঞান পদে, আমরা বেনামী ফাংশন এবং নামযুক্ত ফাংশন সম্পর্কে কথা বলতে। আমি মনে করি সর্বাধিক গুরুত্বপূর্ণ পার্থক্য হল যে একটি বেনামী ফাংশন কোনও নামে আবদ্ধ নয়, তাই নাম বেনামী ফাংশন। জাভাস্ক্রিপ্টে এটি একটি প্রথম শ্রেণী বস্তু যা গতিশীলভাবে রানটাইম এ ঘোষণা করা হয়।

বেনামী ফাংশন এবং ল্যাম্বা ক্যালকুলাস সম্পর্কিত আরও তথ্যের জন্য, উইকিপিডিয়া একটি ভাল শুরু ( http://en.wikipedia.org/wiki/Anonymous_function )।




জাভাস্ক্রিপ্টে ফাংশন তৈরি করার দুটি উপায় রয়েছে:

  1. ফাংশন ঘোষণা:

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

    এটি খুব মৌলিক, স্ব-ব্যাখ্যামূলক, ভাষাগুলির সি পরিবার জুড়ে অনেক ভাষা এবং মানচিত্রে ব্যবহৃত হয়। আমরা একটি ফাংশন সংজ্ঞায়িত ঘোষণা করে এবং এটি কল করে এটি কার্যকর।

    আপনি কি জানাতে হবে যে ফাংশন আসলে জাভাস্ক্রিপ্ট বস্তু হয়; অভ্যন্তরীণভাবে আমরা উপরের ফাংশনের জন্য একটি বস্তু তৈরি করেছি এবং এটি fn নামে একটি নাম দেওয়া হয়েছে অথবা বস্তুর রেফারেন্স fn এ সংরক্ষিত আছে। ফাংশন জাভাস্ক্রিপ্ট বস্তু; ফাংশন একটি উদাহরণ আসলে একটি বস্তুর উদাহরণ।

  2. ফাংশন এক্সপ্রেশন:

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

    জাভাস্ক্রিপ্টের প্রথম-শ্রেণীর ফাংশন রয়েছে, যা একটি ফাংশন তৈরি করে এবং এটি একটি ভেরিয়েবলের জন্য সন্নিবেশ করান ঠিক যেমন আপনি একটি স্ট্রিং বা সংখ্যা তৈরি করেন এবং এটি একটি পরিবর্তনশীলকে বরাদ্দ করুন। এখানে, fn পরিবর্তনশীল একটি ফাংশন বরাদ্দ করা হয়। এই ধারণার কারণটি হল জাভাস্ক্রিপ্টগুলিতে বস্তুগুলি; FN উপরের ফাংশন বস্তুর দৃষ্টান্ত নির্দেশ করা হয়। আমরা একটি ফাংশন আরম্ভ এবং একটি পরিবর্তনশীল এটি বরাদ্দ করা হয়েছে। এটি ফাংশন নির্বাহ এবং ফলাফল বরাদ্দ করা হয় না।

রেফারেন্স: জাভাস্ক্রিপ্ট ফাংশন ঘোষণা সিনট্যাক্স: var fn = function () {} বনাম ফাংশন fn () {}




Hoisting জাভাস্ক্রিপ্ট ইন্টারপ্রেটার এর বর্তমান পরিবর্তন শীর্ষে সব পরিবর্তনশীল এবং ফাংশন ঘোষণা সরানোর কর্ম।

যাইহোক, শুধুমাত্র প্রকৃত ঘোষণা hoisted হয়। তারা যেখানে নিয়োগ ছাড়াই।

  • ভেরিয়েবলের / ফাংশনটি পৃষ্ঠাটির ভিতরে ঘোষণা করা হয়েছে যেগুলি বিশ্বব্যাপী যে কোনও স্থানে অ্যাক্সেস করতে পারে।
  • পরিবর্তনশীল এর / ফাংশন ভিতরে ঘোষণা ফাংশন স্থানীয় সুযোগ আছে। অর্থ তারা ফাংশন শরীরের (সুযোগ) ভিতরে উপলব্ধ / অ্যাক্সেস করা হয়, তারা ফাংশন শরীরের বাইরে পাওয়া যায় না।

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 ব্যবহার করে বিভিন্ন ব্রাউজারে ফাংশন ঘোষণা, অভিব্যক্তি পরীক্ষা পরীক্ষা করতে পারেন

ES5 কনস্ট্রাক্টর ফাংশন ক্লাস : Function.prototype.bind ব্যবহার করে তৈরি ফাংশন বস্তু

জাভাস্ক্রিপ্ট প্রথম-শ্রেণীর বস্তু হিসাবে ফাংশন আচরণ করে, তাই একটি বস্তু হচ্ছে, আপনি একটি ফাংশন বৈশিষ্ট্য নির্ধারণ করতে পারেন।

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 এ্যারো ফাংশন চালু করেছে : একটি তীর ফাংশন এক্সপ্রেশনটি একটি ছোট সিন্ট্যাক্স রয়েছে, এটি অ-পদ্ধতির ফাংশনগুলির জন্য সর্বোত্তম উপযুক্ত, এবং তারা কন্সট্রাক্টর হিসাবে ব্যবহার করা যাবে না।

ArrowFunction : ArrowParameters => ConciseBody

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



একটি ফাংশন ঘোষণা এবং একটি পরিবর্তনশীল নির্ধারিত একটি ফাংশন অভিব্যক্তি বাঁধাই প্রতিষ্ঠিত একবার একই আচরণ।

সেখানে একটি পার্থক্য অবশ্য হয় কিভাবে এবং যখন ফাংশন বস্তুর আসলে তার পরিবর্তনশীল সঙ্গে সংশ্লিষ্ট। এই পার্থক্য জাভাস্ক্রিপ্ট মধ্যে পরিবর্তনশীল hoisting বলা প্রক্রিয়া কারণে ।

মূলত, সমস্ত ফাংশন ঘোষণা এবং পরিবর্তনশীল ঘোষণা ফাংশনের শীর্ষে ঘোষিত হয় যেখানে ঘোষণাকারী হয় (এই কারণে আমরা জাভাস্ক্রিপ্টটির কার্যকারিতা দশা বলে )।

  • যখন একটি ফাংশন ঘোষণাকৃত করা হয়, ফাংশন শরীরটি "অনুসরণ করে" তখন ফাংশন শরীর মূল্যায়ন করা হয়, পরিবর্তনশীল অবিলম্বে একটি ফাংশন বস্তুর সাথে আবদ্ধ করা হবে।

  • যখন একটি পরিবর্তনশীল ঘোষণায় উত্তোলন করা হয়, তখন প্রাথমিকভাবে অনুসরণ করা হয় না , তবে "পিছনে বাম" হয়। পরিবর্তনশীল undefinedফাংশন শরীরের শুরুতে শুরু হয়, এবং কোড তার মূল অবস্থান একটি মান বরাদ্দ করা হবে । (প্রকৃতপক্ষে, এটি প্রতিটি অবস্থানে একটি মান বরাদ্দ করা হবে যেখানে একই নামে একটি পরিবর্তনশীল ঘোষণাটি ঘটে।)

Hoisting আদেশ এছাড়াও গুরুত্বপূর্ণ: ফাংশন ঘোষণা একই নামের সঙ্গে পরিবর্তনশীল ঘোষণা উপর অগ্রাধিকার নিতে, এবং শেষ ফাংশন ঘোষণা একই নামের সঙ্গে আগের ফাংশন ঘোষণা উপর অগ্রাধিকার লাগে।

কিছু উদাহরণ...

var foo = 1;
function bar() {
  if (!foo) {
    var foo = 10 }
  return foo; }
bar() // 10

ভেরিয়েবলটি fooফাংশনের শীর্ষে আটকানো হয় undefined, যাতে শুরু !fooহয় true, তাই fooএটি নির্ধারিত হয় 10fooবাইরে barএর সুযোগ কোন ভূমিকা পালন করে এবং অস্পৃষ্ট হয়।

function f() {
  return a; 
  function a() {return 1}; 
  var a = 4;
  function a() {return 2}}
f()() // 2

function f() {
  return a;
  var a = 4;
  function a() {return 1};
  function a() {return 2}}
f()() // 2

ফাংশন ঘোষণা পরিবর্তনশীল ঘোষণা উপর অগ্রাধিকার, এবং শেষ ফাংশন ঘোষণা "লাঠি" ঘোষণা।

function f() {
  var a = 4;
  function a() {return 1}; 
  function a() {return 2}; 
  return a; }
f() // 4

এই উদাহরণটি aফাংশন অবজেক্টের সাথে শুরু হয় যার ফলে দ্বিতীয় ফাংশন ঘোষণার মূল্যায়ন করা হয় এবং তারপরে বরাদ্দ করা হয় 4

var a = 1;
function b() {
  a = 10;
  return;
  function a() {}}
b();
a // 1

এখানে ফাংশন ঘোষণার প্রথম, ঘোষণা এবং পরিবর্তনশীল আরম্ভ করা হয় a। পরবর্তী, এই পরিবর্তনশীল বরাদ্দ করা হয় 10। অন্য কথায়: বরাদ্দ বাইরের পরিবর্তনশীল বরাদ্দ করা হয় না a




তারা কিছু ছোট পার্থক্যগুলির সাথে খুব সাদৃশ্যপূর্ণ, প্রথমটি একটি পরিবর্তনশীল যা একটি বেনামী ফাংশন (ফাংশন ঘোষণা) এ নির্ধারিত হয় এবং দ্বিতীয়টি জাভাস্ক্রিপ্ট (বেনামী ফাংশন ঘোষণা) তে একটি ফাংশন তৈরি করার স্বাভাবিক উপায়, উভয়ই ব্যবহার, :

1. ফাংশন এক্সপ্রেশন

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

একটি ফাংশন এক্সপ্রেশন একটি ফাংশনকে একটি বৃহত্তর অভিব্যক্তি সিনট্যাক্স (সাধারণত একটি পরিবর্তনশীল অ্যাসাইনমেন্ট) অংশ হিসাবে সংজ্ঞায়িত করে। ফাংশন এক্সপ্রেশন মাধ্যমে সংজ্ঞায়িত ফাংশন নাম বা বেনামী করা যেতে পারে। ফাংশন এক্সপ্রেশনগুলি অবশ্যই "ফাংশন" দিয়ে শুরু করা উচিত নয় (অতএব নিচের স্বচালিত উদাহরণের চারপাশে বন্ধনী)।

একটি ফাংশনে একটি ভেরিয়েবল বরাদ্দ করুন, কোন Hoisting মানে, আমরা জাভাস্ক্রিপ্ট মধ্যে ফাংশন Hoist করতে পারেন জানি, মানে তারা ঘোষিত করার আগে তাদের বলা যেতে পারে, যখন ভেরিয়েবল তাদের অ্যাক্সেস পাওয়ার আগে ঘোষণা করা প্রয়োজন, তাই এই ক্ষেত্রে আমরা বলতে পারি না ঘোষিত হওয়ার আগে ফাংশনটি অ্যাক্সেস করুন, এটি এমন একটি উপায় হতে পারে যা আপনি আপনার ফাংশন লিখতে পারেন, যে ফাংশনগুলি অন্য ফাংশনটি ফেরত দেয় সেগুলির জন্য, এই ধরনের ঘোষণাটি ইসিএম 6 এবং এর উপরেও বোঝা যায়, এটি একটি তীর ফাংশনে আপনাকে বরাদ্দ করতে পারে বেনামী ফাংশন কল করতে ব্যবহার করা যেতে পারে, জাভাস্ক্রিপ্টে কনস্ট্রাক্টর ফাংশন তৈরি করার আরও একটি ভাল উপায় ঘোষণা করার উপায়।

2. ফাংশন ঘোষণা

function functionTwo() {
    // Some code
}

একটি ফাংশন ঘোষণাপত্র পরিবর্তনশীল নিয়োগ প্রয়োজন ছাড়া একটি নামযুক্ত ফাংশন পরিবর্তনশীল সংজ্ঞায়িত করে। ফাংশন ঘোষণা স্বতন্ত্র গঠন হিসাবে সংঘটিত হয় এবং অ ফাংশন ব্লক মধ্যে নিস্তেজ করা যাবে না। ভেরিয়েবল ঘোষণাপত্রের ভাইবোন হিসাবে তাদের চিন্তা করা সহায়ক। ভেরিয়েবল ঘোষণাগুলি অবশ্যই "var" দিয়ে শুরু করতে হবে, ফাংশন ঘোষণাগুলি "ফাংশন" দিয়ে শুরু হওয়া আবশ্যক।

জাভাস্ক্রিপ্টে একটি ফাংশন কল করার এই সাধারণ উপায়, এই ফাংশনটিকে জাভাস্ক্রিপ্ট হিসাবে ঘোষণা করার আগেই সমস্ত ফাংশন hoisted পেতে আগে আপনাকে বলা যেতে পারে, কিন্তু যদি আপনি 'কঠোর ব্যবহার করেন' এটি প্রত্যাশিত হিসাবে উত্তোলন করবে না, এটি একটি ভাল উপায় সমস্ত স্বাভাবিক ফাংশনকে কল করতে যা লাইনগুলিতে বড় না এবং কন্সট্রাকটর ফাংশনও নয়।

এছাড়াও, যদি জাভাস্ক্রিপ্টে কীভাবে উত্তোলন কাজ করে সে সম্পর্কে আরও তথ্যের প্রয়োজন হয় তবে নীচের লিঙ্কটিতে যান:

https://developer.mozilla.org/en-US/docs/Glossary/Hoisting




new Function()একটি স্ট্রিং মধ্যে ফাংশন শরীর পাস করতে ব্যবহার করা যেতে পারে। এবং তাই এই গতিশীল ফাংশন তৈরি করতে ব্যবহার করা যেতে পারে। এছাড়াও স্ক্রিপ্ট নির্বাহ ছাড়া স্ক্রিপ্ট পাস।

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

secondFunction()



দ্বিতীয়টির প্রথম পদ্ধতিটি কখন পছন্দ করবেন তা একটি উদাহরণ যা আপনাকে কোন ফাংশনের পূর্বনির্ধারিত সংজ্ঞাগুলিকে ওভাররাইড করা থেকে বিরত থাকা দরকার।

সঙ্গে

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

, আমার myfunction সংজ্ঞাটি পূর্বের কোনও myfunction ওভাররাইড করবে, কারণ এটি পার্স-টাইমে সম্পন্ন হবে।

যদিও

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

condition পূরণ করা হয় শুধুমাত্র যখন myfunction সংজ্ঞায়িত সঠিক কাজ করে।




Related