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




syntax idioms (25)

প্রথম এক (ফাংশন do Somethingthing (x)) একটি বস্তু সংকেত অংশ হতে হবে।

দ্বিতীয়টি ( var doSomething = function(x){ alert(x);}) কেবল একটি বেনামী ফাংশন তৈরি করছে এবং এটি একটি পরিবর্তনশীলকে বরাদ্দ করছে doSomething। সুতরাং doSomething () ফাংশন কল করবে।

আপনি একটি ফাংশন ঘোষণা এবং ফাংশন অভিব্যক্তি কি জানতে চান হতে পারে ।

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

function foo() {
    return 3;
}

ইসিএমএ 5 (13.0)
ফাংশন আইডেন্টিফায়ার হিসাবে ফরম্যাট সংজ্ঞায়িত করে (ফরমালপ্যারিটারলিস্ট অপ্ট ) {FunctionBody}

উপরের অবস্থানে ফাংশন নামটি তার সুযোগ এবং তার পিতামাতার সুযোগের মধ্যে দৃশ্যমান (অন্যথায় এটি অ্যাক্সেসযোগ্য হবে)।

এবং একটি ফাংশন অভিব্যক্তি

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

// 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) সিন্ট্যাক্সটিকে
ফাংশন আইডেন্টিফায়ার অপ্ট (ফরমাল প্যারামিটারলিস্ট অপ্ট ) হিসাবে বর্ণনা করে {FunctionBody}

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

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

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

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

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


বৈশ্বিক প্রসঙ্গ সম্পর্কে বলার অপেক্ষা রাখে না, উভয়, 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 ডিক্লেয়ারেশন দ্বারা ঘোষিত শনাক্তকারী, কোনও ক্ষেত্রে এটি ওভাররাইট করা যাবে না।


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

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 MyNamespace = {}
MyNamespace.foo= function() {

}

অথবা

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

নামস্থান জন্য অনেক কৌশল আছে। এটি জাভাস্ক্রিপ্ট মডিউল প্রচুর পরিমাণে উপলব্ধ সঙ্গে আরও গুরুত্বপূর্ণ হয়ে ওঠে।

এছাড়াও কিভাবে আমি জাভাস্ক্রিপ্ট একটি নামস্থান ঘোষণা করবেন?


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

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


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

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


প্রথম উদাহরণ একটি ফাংশন ঘোষণা:

function abc(){}

দ্বিতীয় উদাহরণ একটি ফাংশন অভিব্যক্তি:

var abc = function() {};

প্রধান পার্থক্য তারা কিভাবে উত্তোলন করা হয় (উত্তোলন এবং ঘোষণা)। প্রথম উদাহরণে, পুরো ফাংশন ঘোষণা hoisted হয়। দ্বিতীয় উদাহরণে শুধুমাত্র var 'abc' ফাঁকা হয়, এর মান (ফাংশন) অনির্ধারিত হবে এবং ফাংশন নিজেই ঘোষিত অবস্থানের উপর থাকবে।

সহজভাবে এটি করা:

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

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

এই বিষয়ে আরো অধ্যয়ন করতে আমি দৃঢ়ভাবে আপনাকে এই link সুপারিশlink


গ্রেগের উত্তর যথেষ্ট ভাল, তবে আমি এখনও কিছু যোগ করতে চাই যা আমি এখন ডগলাস ক্রকফোর্ডের ভিডিওগুলি দেখে শিখেছি ।

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

var foo = function foo() {};

ফাংশন বিবৃতি:

function foo() {};

ফাংশন বিবৃতি varএকটি functionমান সঙ্গে বিবৃতি জন্য একটি শর্ট্যান্ড ।

সুতরাং

function foo() {};

প্রসারিত

var foo = function foo() {};

যা আরও প্রসারিত:

var foo = undefined;
foo = function foo() {};

এবং তারা উভয় কোড শীর্ষে hoisted হয়।


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

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

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

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

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

    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
    

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

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

    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
    
  2. অ-ফাংশন ব্লকগুলিতে ফাংশন ঘোষণাগুলি লিখতে নিরাপদ নয় যেমন যদি তারা অ্যাক্সেসযোগ্য না হয়।

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

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

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


প্রথমত আমি গ্রেগকে সংশোধন করতে চাই: 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() এর উত্তর - উত্তরটি হল: এটি ব্রাউজারের উপর নির্ভর করে।


অন্য মন্তব্যকারীরা ইতিমধ্যে উপরে দুটি রূপের অর্থাত্ পার্থক্য আচ্ছাদিত করেছে। আমি একটি স্টাইলিস্টিক পার্থক্য নোট করতে চেয়েছিলেন: শুধুমাত্র "বরাদ্দকরণ" বৈচিত্র্য অন্য বস্তুর একটি সম্পত্তি সেট করতে পারেন।

আমি প্রায়ই এই মত একটি প্যাটার্ন সঙ্গে জাভাস্ক্রিপ্ট মডিউল নির্মাণ:

(function(){
    var exports = {};

    function privateUtil() {
            ...
    }

    exports.publicUtil = function() {
            ...
    };

    return exports;
})();

এই প্যাটার্নের সাহায্যে, আপনার ব্যক্তিগত ফাংশনগুলি সর্বদা অ্যাসাইনমেন্ট ব্যবহার করবে, যখন আপনার ব্যক্তিগত ফাংশন ঘোষণা ব্যবহার করবে।

(উল্লেখ্য যে নিয়োগের পরে বিবৃতির জন্য একটি সেমিকোলন প্রয়োজন, যখন ঘোষণা এটি নিষিদ্ধ করে।)


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

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 সংজ্ঞায়িত সঠিক কাজ করে।


নীচের তালিকাভুক্ত দুটি ভিন্ন ঘোষণাগুলির মধ্যে তিনটি উল্লেখযোগ্য তুলনা রয়েছে।

  1. ফাংশন প্রাপ্যতা (সুযোগ)

নিচের function add()ব্লকটিকে স্কোপ করা হয়েছে বলে নিম্নলিখিত কাজগুলি :

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

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

নিম্নলিখিত কাজ করে না (কারণ var add=superseeds function add())।

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

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

addএটি ব্যবহার করা হয় পরে ঘোষণা করা হয় নিম্নলিখিত নিম্নলিখিত কাজ করে না ।

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

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

  1. (ফাংশন) .name

একটি ফাংশন নাম function thefuncname(){}হয় thefuncname যখন এই ভাবে ঘোষিত হয়।

function foobar(a, b){}

console.log(foobar.name);

var a = function foobar(){};

console.log(a.name);

অন্যথায়, যদি কোন ফাংশনটি ফাংশন হিসাবে ঘোষণা করা হয় function(){}, তবে ফাংশনটি সংরক্ষণ করতে ব্যবহৃত নাম।

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

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

যদি ফাংশনে কোনও ভেরিয়েবল সেট থাকে তবে ফাংশন নাম খালি স্ট্রিং ( "")।

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

অবশেষে, যখন পরিবর্তনশীল ফাংশনটি প্রাথমিকভাবে নামটি সেট করে দেওয়া হয়, তখন ফাংশনে সেট করা ক্রমিক ভেরিয়েবলগুলি নামটি পরিবর্তন করে না।

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

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

  1. কর্মক্ষমতা

গুগল এর ভি 8 এবং ফায়ারফক্সের স্পিডার্মোকিতে কিছু মাইক্রোসেকেন্ড জিআইএসটি সংকলন পার্থক্য থাকতে পারে, তবে অবশেষে ফলাফলটি একই রকম। এটি প্রমাণ করার জন্য, দুটি ফাঁকা কোড স্নিপেটের গতি তুলনা করে মাইক্রোবিনচার্কগুলিতে জেএসপিআরএফের দক্ষতা পরীক্ষা করে দেখুন। JSPerf পরীক্ষার এখানে পাওয়া যায় । এবং, jsben.ch testare এখানে পাওয়া যায় । আপনি দেখতে পারেন, যখন কেউ হতে হবে একটি উল্লেখযোগ্য পার্থক্য আছে। আপনি যদি সত্যিই আমার মত একটি পারফরম্যান্স ফিকাক হন, তবে সুযোগের ভেরিয়েবল এবং ফাংশন সংখ্যা এবং বিশেষত পলিমোরফিজম (যেমন একই ভেরিয়েবলটি দুটি ভিন্ন ধরণের সঞ্চয় করার জন্য) ব্যবহার করা কমিয়ে দেওয়ার চেষ্টা করা আপনার পক্ষে আরো মূল্যবান হতে পারে।

"নিকটতম ব্লক" কি

"নিকটতম ব্লক" নিকটতম "ফাংশন" (অ্যাসিঙ্ক্রোনাস ফাংশন, জেনারেটর ফাংশন এবং অ্যাসিঙ্ক্রোনাস জেনারেটরের ফাংশন সহ)। যাইহোক, মজার ব্যাপার, একটি function functionName() {}নিষ্ক্রিয় var functionName = function() {}ব্লক আইটেম বন্ধ যখন বলেন মত আচরণ । কর।

  • সাধারণ 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}

  • সাধারণ 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;
    }
})();

  • বিবৃতি (যেমন 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;
    }
}

  • সঙ্গে তীর ফাংশন 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;
    }
})();

  • সঙ্গে তীর ফাংশন 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;
    }
})();


আপনি যে দুটি কোড স্নিপেট পোস্ট করেছেন সেখানে প্রায় সব উদ্দেশ্যেই একই আচরণ করবেন।

যাইহোক, আচরণের পার্থক্য হল যে প্রথম রূপটি ( var functionOne = function() {} ) সহ, সেই ফাংশনটিকে শুধুমাত্র কোডের পরেই বলা যেতে পারে।

দ্বিতীয় রূপ ( function functionTwo() ) সঙ্গে, ফাংশন ঘোষণা করা হয় যেখানে উপরের কোড রান যে ফাংশন ঘোষণা করা হয়।

এটি কারণ প্রথম রূপের সাথে, ফাংশনটি চলমান সময়ে foo variable এ নির্ধারিত হয়। দ্বিতীয়ত, ফাংশনটি সেই আইডেন্টিফায়ারকে নির্ধারিত হয়, foo , পার্স সময়।

আরো প্রযুক্তিগত তথ্য

জাভাস্ক্রিপ্ট ফাংশন সংজ্ঞা তিনটি উপায় আছে।

  1. আপনার প্রথম স্নিপেট একটি ফাংশন অভিব্যক্তি দেখায়। এটি একটি ফাংশন তৈরি করার জন্য "ফাংশন" অপারেটর ব্যবহার করে থাকে - যে অপারেটরের ফলাফলটি কোনও পরিবর্তনশীল বা বস্তুর সম্পত্তিতে সংরক্ষণ করা যেতে পারে। ফাংশন অভিব্যক্তি যে ভাবে শক্তিশালী। ফাংশন এক্সপ্রেশনটি প্রায়শই একটি "বেনামী ফাংশন" বলা হয়, কারণ এটির নাম থাকতে হবে না,
  2. আপনার দ্বিতীয় উদাহরণ একটি ফাংশন ঘোষণা । এটি একটি ফাংশন তৈরি করার জন্য "ফাংশন" বিবৃতি ব্যবহার করে। ফাংশন পার্স সময় সময়ে উপলব্ধ করা হয় এবং যে সুযোগ কোথাও বলা যেতে পারে। আপনি এখনও এটি একটি পরিবর্তনশীল বা বস্তুর সম্পত্তি পরে সংরক্ষণ করতে পারেন।
  3. একটি ফাংশন সংজ্ঞায়িত করার তৃতীয় উপায় হল "ফাংশন ()" গঠনকারী , যা আপনার মূল পোস্টে দেখানো হয় না। এটি ব্যবহার করার পরামর্শ দেওয়া হয় না কারণ এটি eval() , যা তার সমস্যাগুলির মতো একই ভাবে কাজ করে।

আরেকটি পার্থক্য যে অন্য উত্তর উল্লেখ করা হয় না আপনি যদি বেনামী ফাংশন ব্যবহার

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

এবং হিসাবে একটি কনস্ট্রাকটর হিসাবে যে ব্যবহার

var one = new functionOne();

তারপর one.constructor.nameসংজ্ঞায়িত করা হবে না। Function.nameঅ-মানক কিন্তু ফায়ারফক্স, ক্রোম, অন্যান্য ওয়েবকিট-প্রাপ্ত ব্রাউজার এবং IE 9+ দ্বারা সমর্থিত।

সঙ্গে

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

এটির সাথে স্ট্রিং হিসাবে কন্সট্রাকটরটির নাম পুনরুদ্ধার করা সম্ভব two.constructor.name


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

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

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

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

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

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

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

এখানে ফাংশন তৈরি করে এমন স্ট্যান্ডার্ড ফর্মগুলিতে রান্ডাউন্ডটি রয়েছে: (মূলত অন্য প্রশ্নটির জন্য লিখিত, কিন্তু ক্যানোনিকাল প্রশ্নে স্থানান্তরিত হওয়ার পরে এটির অভিযোজিত।)

শর্তাবলী:

দ্রুত তালিকা:

  • ফাংশন ঘোষণা

  • "বেনামী" 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 , while , ইত্যাদির মতো করা থাকে তবে কোনও জাভাস্ক্রিপ্ট ইঞ্জিন কী করবে তা জুড়েছে না:

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

সমস্ত এক্সপ্রেশন লেগেছে, যখন এটি কোডের ধাপে ধাপে কার্যকর হয় তখন এটি মূল্যায়ন করা হয়।

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

নামকরণ function এক্সপ্রেশন

তৃতীয় ফর্মটি একটি নামযুক্ত ফাংশন এক্সপ্রেশন ("NFE"):

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

এই সৃষ্টির ফাংশন একটি সঠিক নাম আছে (এই ক্ষেত্রে w )। সমস্ত অভিব্যক্তি লেগেছে, যখন এটি কোডের ধাপে ধাপে কার্যকর করা হয় তখন এটি মূল্যায়ন করা হয়। ফাংশনের নামটি কোনও অভিব্যক্তিতে যুক্ত হয় না যা অভিব্যক্তিটি উপস্থিত হয়; নাম ফাংশন নিজেই মধ্যে সুযোগ হয়:

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

উল্লেখ্য যে NFEs প্রায়শই জাভাস্ক্রিপ্ট বাস্তবায়নের জন্য বাগগুলির একটি উত্স হয়েছে। IE8 এবং এর আগে, উদাহরণস্বরূপ, NFEs সম্পূর্ণভাবে ভুলভাবে পরিচালনা করে , দুটি পৃথক ফাংশন দুটি পৃথক সময়ে তৈরি করে। সাফারি এর প্রাথমিক সংস্করণ এছাড়াও সমস্যা ছিল। ভাল খবর হল যে ব্রাউজারগুলির বর্তমান সংস্করণগুলি (IE9 এবং আপ, বর্তমান সাফারি) আর কোন সমস্যা নেই। (কিন্তু এই লেখার হিসাবে, দুঃখজনকভাবে, IE8 ব্যাপকভাবে ব্যবহৃত হয় এবং তাই সাধারণভাবে ওয়েবের জন্য কোড সহ NFEs ব্যবহার করা এখনও সমস্যাযুক্ত।)

অ্যাক্সেসার ফাংশন ইনস্যুলাইজার (ES5 +)

কখনও কখনও ফাংশন মূলত unnoticed মধ্যে ছিঁচকে চুরি করা যাবে; যে অ্যাক্সেস ফাংশন সঙ্গে ক্ষেত্রে। এখানে একটি উদাহরণ:

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.create . Object.create কম পরিচিত দ্বিতীয় যুক্তি সহ 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 বন্ধ করে এবং যেখানে প্রাসঙ্গিক, super ।) এর অর্থ এই যে তাদের মধ্যে এটি একই রকম যেখানে তারা তৈরি হয়, এবং পরিবর্তন করা যাবে না।

  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 (যদি আপনাকে একটি মান ফেরত দিতে হয়) ব্যবহার করুন।

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

{ ... } ছাড়া সংস্করণটি একটি এক্সপ্রেশন শরীর বা সংক্ষিপ্ত শরীরের সাথে একটি তীর ফাংশন বলা হয়। (এছাড়াও: একটি সংক্ষেপণ তীর ফাংশন।) { ... } শরীরের সংজ্ঞায়িতকারী একটি ফাংশন শরীরের সাথে একটি তীর ফাংশন। (এছাড়াও: একটি verbose তীর ফাংশন।)

অবজেক্ট ইনিশিয়ালাইজারের পদ্ধতি ঘোষণা (ES2015 +)

ES2015 একটি ফাংশন রেফারেন্স যে একটি সম্পত্তি ঘোষণা একটি ছোট আকার অনুমতি দেয়; এটা দেখে মনে হচ্ছে:

var o = {
    foo() {
    }
};

ES5 এবং এর সমতুল্য হবে:

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 জন্য একটি, যা getFullName দেওয়া একটি ফাংশন।


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

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

আমি আমার নিজের উত্তর যোগ করছি কারণ অন্য সবাই উত্তোলন অংশটি পুঙ্খানুপুঙ্খ ভাবে ঢেকে রেখেছে।

আমি এখন দীর্ঘ সময় ধরে কোন পথ ভাল জন্য সম্পর্কে বিস্মিত করেছি, এবং ধন্যবাদ http://jsperf.com এখন আমি জানি :)

ফাংশন ঘোষণা দ্রুত হয়, এবং ওয়েব ডেভ অধিকার সত্যিই কি ব্যাপার? ;)


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

সেখানে একটি পার্থক্য অবশ্য হয় কিভাবে এবং যখন ফাংশন বস্তুর আসলে তার পরিবর্তনশীল সঙ্গে সংশ্লিষ্ট। এই পার্থক্য জাভাস্ক্রিপ্ট মধ্যে পরিবর্তনশীল 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


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

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

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

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

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

@ টি জে ক্রোডারের উত্তরের সাবসিডিয়ারি, + এই SO উত্তরটির ব্যাখ্যা হিসাবে সাধারণত মানের সংখ্যাসূচক কাস্টিং জোর করার জন্য ব্যবহৃত হয়। এই ক্ষেত্রে এটি 'unary প্লাস অপারেটর' (googling সহজে জন্য) বলা হয়।

var num = +variant;

সুতরাং একটি ফাংশনের সামনে এটি ফাংশনের ফলাফলকে সংখ্যার হিসাবে ব্যাখ্যা করার একটি উপায় হতে পারে। আমি সন্দেহ করি এটি এখনো ঘটেছে, কিন্তু তাত্ত্বিকভাবে জিটটি যে সংখ্যাকে ফাংশনটিকে সংখ্যাসূচক-ফাংশন হিসাবে সংকলন করতে পারে সেটি ব্যবহার করতে পারে। তবে, বৃহত্তর অভিব্যক্তিতে ব্যবহৃত হলে ইউনিনারি প্লাসকে সংকোচন হিসাবে আটকানোর জন্য আপনাকে বন্ধনী প্রয়োজন হবে:

blah + (+(function(){ var scope; return "4"; })());




javascript function syntax idioms