اعلان تابع Expression

در جاوااسکریپت، تابع یک “ساختار جادویی زبان” نیست، بلکه یک نوع خاصی از مقدار است.

سینتکسی که ما قبلا استفاده کردیم یک Function Declaration نامیده می‌شود:

function sayHi() {
  alert( "سلام" );
}

یک سینتکس دیگر هم برای ساخت تابع وجود دارد که Function Expression نامیده می‌شود.

این سینتکس به ما این امکان را می‌دهد که بین هر عبارتی یک تابع جدید بسازیم.

برای مثال:

let sayHi = function() {
  alert( "سلام" );
};

اینجا می‌توانیم متغیر sayHi را ببینیم Ú©Ù‡ مقداری را دریافت می‌کند، تابع جدید، Ú©Ù‡ به صورت function() { alert("Hello"); } ساخته شده است.

چون ایجاد تابع با زمینه (context) عبارت مقداردهی (سمت راست =) رخ می‌دهد، این یک Function Expression است.

لطفا در نظر داشته باشید، هیچ اسمی بعد از کلمه کلیدی function وجود ندارد. حذف کردن اسم برای Function Expressionها مجاز است.

اینجا ما بلافاصله آن را به متغیر اختصاص می‌دهیم پس معنی این قطعه‌های کد یکسان است: «تابعی بساز Ùˆ آن را درون متغیر sayHi قرار بده».

در موقعیت‌های پیشرفته‌تر، که بعدا به آن‌ها می‌رسیم، یک تابع ممکن است ایجاد و بلافاصله فراخوانی شود یا برای اینکه بعدا اجرا شود برنامه‌ریزی صورت گیرد و جایی ذخیره نشود، از این رو ناشناس بماند.

تابع یک مقدار است

بیایید تکرار کنیم: مهم نیست Ú©Ù‡ تابع چگونه ساخته شده است، یک تابع همیشه یک مقدار است. هر دو مثال بالا تابعی را درون متغیر sayHi ذخیره می‌کنند.

ما حتی می‌توانیم آن مقدار را با استفاده از alert چاپ کنیم:

function sayHi() {
  alert( "سلام" );
}

alert( sayHi ); // کد تابع را نشان می‌دهد

لطفا در نظر داشته باشید Ú©Ù‡ آخرین خط تابع را اجرا نمی‌کند، چون هیچ پرانتزی بعد از sayHi وجود ندارد. زبان‌های برنامه نویسی‌ای وجود دارند Ú©Ù‡ هر اشاره‌ای به اسم تابع سبب اجرا شدن آن می‌شود، اما جاوااسکریپت اینطور نیست.

در جاوااسکریپت، تابع یک مقدار است، پس ما می‌توانیم مثل یک مقدار با آن رفتار کنیم. کد بالا نمایش رشته‌ای آن را انجام می‌دهد، که همان کد منبع است.

مسلما، تابع یک مقدار خاص است، به همین دلیل ما می‌توانیم آن را مثل sayHi() صدا بزنیم.

اما تابع همچنان یک مقدار است. پس ما می‌توانیم با آن مثل انواع دیگر مقدارها کار کنیم.

ما می‌توانیم یک تابع را در یک متغیر دیگر کپی کنیم:

function sayHi() {   // (1) ساختن
  alert( "سلام" );
}

let func = sayHi;    // (2) کپی کردن

func(); // سلام     // (3) کپی را اجرا می‌کنیم (کار می‌کند!)
sayHi(); // سلام    //     هنوزم کار می‌کند (چرا نکند)

چیزی که بالا اتفاق می‌افتد با جزییات اینجا هست:

1. Function Declaration (1) تابع را می‌سازد Ùˆ آن را داخل متغیر sayHi قرار می‌دهد.
2. خط (2) آن را داخل متغیر func Ú©Ù¾ÛŒ می‌کند. لطفا دوباره در نظر داشته باشید: هیچ پرانتزی بعد از sayHi وجود ندارد. اگر وجود داشت، سپس func = sayHi() نتیجه صدا زدن sayHi() را در func می‌نوشت، نه خود تابع sayHi.
3. حالا تابع می‌تواند با sayHi() Ùˆ func() صدا زده شود.

همچنین می‌توانستیم از یک Function Expression برای تعریف sayHi در خط اول، استفاده کنیم:

let sayHi = function() { // (1) ایجاد
  alert( "سلام" );
};

let func = sayHi;
// ...

همه چیز به همان شکل کار خواهد کرد.

function sayHi() {
  // ...
}

let sayHi = function() {
  // ...
};

تابع‌های Callback

بیایید به مثال‌های بیشتری درباره استفاده کردن از تابع ها به عنوان مقدار و استفاده کردن از function expressions نگاه کنیم.

ما یک تابع ask(question, yes, no) با سه پارامتر می‌نویسیم:

question

متن سوال

yes

تابعی برای اجرا کردن اگر جواب “Yes” باشد

no

تابعی برای اجرا کردن اگر جواب “No” باشد

تابع باید question را بپرسد، Ùˆ بر اساس جواب کاربر، yes() یا no() را صدا بزند:

function ask(question, yes, no) {
  if (confirm(question)) yes()
  else no();
}

function showOk() {
  alert( "شما موافقت کردید." );
}

function showCancel() {
  alert( "شما اجرا شدن را لغو کردید." );
}

// نحوه استفاده: تابع‌های showOk، showCancel به عنوان آرگومان به ask داده شده‌اند
ask("آیا موافق هستید؟", showOk, showCancel);

در عمل، چنین تابع هایی بسیار مفید هستند. تفاوت اصلی بین یک ask در زندگی واقعی Ùˆ مثال بالا در این است Ú©Ù‡ تابع‌ها در زندگی واقعی از راه‌های پیچیده‌تری نسبت به یک confirm ساده برای تعامل با کاربر استفاده می‌کنند. در مرورگر، چنین تابع‌هایی معمولا یک پنچره پرسش زیبا را ایجاد می‌کنند. اما آن یک داستان دیگر است.

آرگومان‌های showOk Ùˆ showCancel داخل ask callback functions یا فقط callbacks نامیده می‌شوند.

ایده اینطور است Ú©Ù‡ ما یک تابع را می‌دهیم Ùˆ از آن توقع داریم Ú©Ù‡ بعدا اگر نیاز شد “دوباره صدا زده شود”. در مورد ما، showOk تبدیل به callback برای جواب “yes” می‌شود، Ùˆ showCancel برای چواب “no”.

ما می توانیم از Function Expressions برای نوشتن همان تابع به صورت بسیار کوتاه‌تر استفاده کنیم:

function ask(question, yes, no) {
  if (confirm(question)) yes()
  else no();
}

ask(
  "آیا موافق هستید؟",
  function() { alert("شما موافقت کردید."); },
  function() { alert("شما اجرا شدن را لغو کردید."); }
);

اینجا، تابع‌ها دقیقا درون صدا زدن ask(...) تعریف شده اند. آنها هیچ اسمی ندارند، Ùˆ بنابراین anonymous نامیده Ù…ÛŒ شود. چنین تابع هایی بیرون از ask قابل دسترسی نیستند (چون آنها به متغیری تخصیص داده نشده اند)ØŒ اما این چیزی است Ú©Ù‡ ما اینجا می‌خواهیم.

چنین کدی در اسکریپت‌های ما به طور طبیعی نمایان می شوند، این در ذات جاوااسکریپت است.

اعلان تابع Expression در مقابل تابع Declaration

بیایید تفاوت‌های کلیدی بین Function Declarations و Expressions را فرمول بندی کنیم.

اول، سینتکس: چگونه داخل کد بین آنها فرق قائل شویم.

• Function Declaration: یک تابع است، Ú©Ù‡ به عنوان یک دستور جدا، در کد اصلی تعریف می‌شود.

  // Function Declaration
  function sum(a, b) {
    return a + b;
  }

• Function Expression: یک تابع است، Ú©Ù‡ در داخل یک عبارت یا داخل یک ساختار سینتکس دیگر ساخته می‌شود. اینجا، تابع سمت راست “عبارت تخصیص دادن” = ساخته شده است.

  // Function Expression
  let sum = function(a, b) {
    return a + b;
  };

تفاوت‌های نامحسوس بیشتر زمانی ایجاد می‌شوند که یک تابع توسط موتور جاوااسکریپت ساخته می‌شود.

یک Function Expression زمانی ساخته می‌شود که اجرا شدن به آن می‌رسد و فقط از همان لحظه قابل استفاده است.

بلافاصله Ú©Ù‡ جریان اجرا شدن به سمت راست تخصیص دادن let sum = function... برسد – د برو Ú©Ù‡ رفتیم، تابع از آن لحظه ساخته شده Ùˆ می‌تواند استفاده شود (تخصیص داده شود، صدا زده شود، و…).

Function Declarations متفاوت هستند.

یک Function Declaration می‌تواند زودتر از زمانی که تعریف شده باشد صدا شده شود.

برای مثال، یک Function Declaration سراسری داخل کل اسکریپت قابل رویت است، هیچ فرقی ندارد که کجا باشد.

این به دلیل الگوریتم‌های داخلی است. زمانی که جاوااسکریپت برای اجرای اسکریپت آماده می‌شود، اول به دنبال Function Declarationهای سراسری می‌گردد و تابع‌ها را می‌سازد. ما می‌توانیم به عنوان یک “مرحله مقداردهی اولیه” به آن فکر کنیم.

و بعد از اینکه همه Function Declarations پردازش شدند، کد اجرا می‌شود. پس به این تابع‌ها دسترسی دارد.

برای مثال، این کار می‌کند:

sayHi("John"); // سلام، John

function sayHi(name) {
  alert( `سلام، ${name}` );
}

Function Declaration sayHi زمانی Ú©Ù‡ جاوااسکریپت برای شروع اسکریپت در حال آماده شدن است ساخته می‌شود Ùˆ هرجایی داخل آن قابل رویت است.

…اگر این یک Function Expression بود، سپس کار نمی‌کرد:

sayHi("John"); // ارور!

let sayHi = function(name) {  // (*) دیگر جادویی وجود ندارد
  alert( `سلام، ${name}` );
};

Function Expressions زمانی Ú©Ù‡ اجرا شدن به آنها می‌رسد ساخته می‌شوند. این فقط در خط (*) اتفاق می‌افتد. خیلی دیر است.

یکی دیگر از ویژگی‌های Function Declaration ویژگی block scope آنها است.

در حالت سختگیرانه(strict mode)، زمانی که یک Function Declaration داخل یک بلوک کد است، همه جای آن بلوک قابل رویت است. اما نه خارج از آن.

برای مثال، بیایید تصور کنیم Ú©Ù‡ می‌خواهیم یک تابع welcome() تعریف کنیم Ú©Ù‡ به متغیر age بستگی دارد Ú©Ù‡ آن را زمان اجرا دریافت می‌کنیم. Ùˆ سپس می‌خواهیم از آن بعدا استفاده کنیم.

اگر ما از Function Declaration استفاده کنیم، آن طور که در نظر داریم کار نمی‌کند:

let age = prompt("سن شما چقدر است؟", 18);

// بر اساس شرط یک تابع تعریف کن
if (age < 18) {

  function welcome() {
    alert("سلام!");
  }

} else {

  function welcome() {
    alert("درود!");
  }

}

// ...بعدا از آن استفاده کن
welcome(); // ارور: welcome تعریف نشده است

دلیل آن این است که یک Function Declaration فقط داخل بلوک کدی که داخل آن مستقر است قابل رویت است.

اینجا یک مثال دیگر داریم:

let age = 16; // 16 را به عنوان یک مثال دریافت کنید

if (age < 18) {
  welcome();               // \   (اجرا می‌شود)
                           //  |
  function welcome() {     //  |
    alert("سلام!");         //  |  Function Declaration در دسترس است
  }                        //  |  هرجایی از بلوکی که داخل آن تعریف شده است
                           //  |
  welcome();               // /   (اجرا می‌شود)

} else {

  function welcome() {
    alert("درود!");
  }
}

// اینجا ما بیرون از آکولادها هستیم،
// پس ما نمی‌توانیم Function Declarationهایی که داخل آنها ساخته شده‌اند را رویت کنیم.

welcome(); // ارور: welcome تعریف نشده است

ما Ú†Ù‡ کاری می‌توانیم انجام دهیم تا welcome را بیرون از if قابل رویت کنیم؟

رویکرد درست می‌تواند این باشد Ú©Ù‡ از Function Expression استفاده کنیم Ùˆ welcome را به متغیری تخصیص بدهیم Ú©Ù‡ خارج از if تعریف شده باشد Ùˆ قابل رویت باشد.

این کد به طوری که در نظر داریم کار می‌کند:

let age = prompt("سن شما چقدر است؟", 18);

let welcome;

if (age < 18) {

  welcome = function() {
    alert("سلام!");
  };

} else {

  welcome = function() {
    alert("درود!");
  };

}

welcome(); // الان درست است

یا حتی ما می‌توانیم آن را با استفاده از عملگر علامت سوال ? ساده‌تر کنیم:

let age = prompt("سن شما چقدر است؟", 18);

let welcome = (age < 18) ?
  function() { alert("سلام!"); } :
  function() { alert("درود!"); };

welcome(); // الان درست است

خلاصه

• تابع‌ها مقدار هستند. آنها می‌توانند هرجای کد تخصیص داده شوند، Ú©Ù¾ÛŒ شوند یا تعریف شوند.
• اگر تابع به عنوان یک دستور جداگانه در جریان کد اصلی تعریف شده باشد، یک “Function Declaration” نامیده می‌شود.
• اگر تابع به عنوان بخشی از یک عبارت ساخته شده باشد، یک “Function Expression” نامیده می‌شود.
• Function Declarations قبل از اینکه بلوک کد اجرا شود پردازش می‌شوند. آنها از هرجای بلوک قابل رویت هستند.
• Function Expressions زمانی Ú©Ù‡ جریان اصلی به آنها می‌رسد ساخته می‌شوند.

در اکثر موارد زمانی که ما می‌خواهیم یک تابع تعریف کنیم، یک Function Declaration ترجیح داده می‌شود، چون قبل از اینکه تعریف شود قابل رویت است. آن به ما انعطاف بیشتری برای سازماندهی کد می‌دهد، و معمولا خواناتر است.

پس ما باید فقط زمانی از Function Expression استفاده کنیم که Function Declaration برای کار مناسب نباشد. ما یک جفت مثال از آن در این فصل دیدیم، و در آینده بیشتر خواهیم دید.