محدوده متغیر، کلوژِر

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

ما از قبل می‌دانیم که یک تابع می‌تواند به متغیرهای بیرون از خودش دسترسی داشته باشد (متغیرهای «بیرونی»).

اما اگر متغیرهای بیرونی از زمانی که یک تابع ساخته شد تغییر کنند چه اتفاقی می‌افتد؟ آیا تابع مقدارهای جدید را دریافت می‌کند یا قدیمی‌ها را؟

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

بیایید دانش خود را گسترده‌تر کنیم تا این سناریوها و پیچیده‌تر از اینها را درک کنیم.

بلوک‌های کد

اگر یک متغیر درون بلوک کد {...} تعریف شود، فقط درون همان بلوک قابل رویت است.

برای مثال:

{
  // یک کار با متغیرهای محلی که از بیرون نباید شناخته شوند انجام دهید

  let message = "Hello"; // فقط درون این بلوک قابل رویت است

  alert(message); // Hello
}

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

ما می‌توانیم از این خاصیت برای ایزوله کردن یک قطعه از کد که دارای متغیرهایی است که فقط به آن تعلق دارند و کار خودش را انجام می‌دهد استفاده کنیم:

{
  // نمایش پیام
  let message = "Hello";
  alert(message);
}

{
  // نمایش پیامی دیگر
  let message = "Goodbye";
  alert(message);
}

// نمایش پیام
let message = "Hello";
alert(message);

// نمایش پیامی دیگر
let message = "Goodbye"; // ارور: متغیر از قبل تعریف شده است
alert(message);

برای ifØŒ forØŒ while Ùˆ بقیه، متغیرهایی Ú©Ù‡ درون {...} تعریف شده باشند تنها درون آنها قابل رویت هستند:

if (true) {
  let phrase = "Hello!";

  alert(phrase); // Hello!
}

alert(phrase); // !ارور، چنین متغیری وجود ندارد

اینجا، بعد از اینکه if تمام می‌شود، alert متغیر phrase را نمی‌بیند Ùˆ به همین دلیل ارور ایجاد می‌شود.

این عالی است چون به ما اجازه می‌دهد Ú©Ù‡ متغیرهایی در سطح بلوک محلی بسازیم Ú©Ù‡ به یک شاخه if اختصاص دارند.

همین موضوع برای حلقه‌های for Ùˆ while هم صادق است:

for (let i = 0; i < 3; i++) {
  // قابل رویت است for فقط درون این حلقه i متغیر
  alert(i); // اول 0، سپس 1، سپس 2
}

alert(i); // ارور، چنین متغیری وجود ندارد

از لحاظ ظاهری، let i بیرون از {...} است. اما اینجا ساختار for خاص است: متغیری Ú©Ù‡ درون آن ساخته شود، جزئی از بلوک کد فرض می‌شود.

تابع‌های تودرتو

به تابعی که درون تابع دیگری ساخته شود «تودرتو» گفته می‌شود.

این کار را به راحتی در جاوااسکریپت می‌توان انجام داد.

می‌توانیم از آن برای سازماندهی کد خود استفاده کنیم، مثلا اینگونه:

function sayHiBye(firstName, lastName) {

  // تابع کمک کننده که پایین‌تر استفاده می‌شود
  function getFullName() {
    return firstName + " " + lastName;
  }

  alert( "سلام " + getFullName() );
  alert( "خداحافظ " + getFullName() );

}

اینجا تابع تودرتو getFullName() برای راحتی استفاده شده است. این تابع می‌تواند به متغیرهای بیرونی دسترسی داشته باشد پس می‌تواند اسم کامل را برگرداند. تابع‌های تودرتو در جاوااسکریپت بسیار رایج هستند.

یک چیز جالب‌تر این است که یک تابع تودرتو می‌تواند برگردانده شود: حالا یا به عنوان یک ویژگی از شیءای جدید یا خودش به عنوان نتیجه برگردانده شود. بعدا می‌تواند در جایی دیگر مورد استفاده قرار بگیرد. مهم نیست کجا باشد، هنوز هم به متغیرهای بیرونی یکسان دسترسی دارد.

در کد پایین، makeCounter تابع «شمارنده» را می‌سازد Ú©Ù‡ با هر بار فراخوانی عدد بعدی را برمی‌گرداند:

function makeCounter() {
  let count = 0;

  return function() {
    return count++;
  };
}

let counter = makeCounter();

alert( counter() ); // 0
alert( counter() ); // 1
alert( counter() ); // 2

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

این چگونه کار می‌کند؟ اگر ما چند شمارنده بسازیم، آیا آنها مستقل خواهند بود؟ چه چیزی در حال رخ دادن روی متغیرها است؟

درک چنین چیزهایی برای دانش کلی از جاوااسکریپت و سناریوهای پیچیده‌تر خوب است. پس بیایید کمی عمیق‌تر شویم.

محیط لغوی (Lexical Environment)

برای واضح بودن، توضیحات به چند مرحله تقسیم شده‌اند.

مرحله 1. متغیرها

در جاوااسکریپت، هر تابع در حال اجرا، بلوک کد {...} Ùˆ تمام اسکریپت، یک شیء درونی (پنهان) اختصاص یافته دارد Ú©Ù‡ به عنوان محیط لغوی شناخته می‌شود.

شیء محیط لغوی شامل دو بخش است:

1. ذخایر محیط (Environment Record) – یک شیء Ú©Ù‡ تمام متغیرهای محلی را به عنوان ویژگی‌های خود (Ùˆ اطلاعات دیگری مانند مقدار this) ذخیره می‌کند.
2. یک رجوع به محیط لغوی بیرونی (outer)، محیطی که به کد بیرونی اختصاص دارد.

یک «متغیر» فقط یک ویژگی از شیء خاص درونی Environment Record است. «دریافت یا تغییر یک متغیر» به معنی «دریافت یا تغییر یک ویژگی از آن شیء» است.

در این کد ساده که تابعی ندارد، تنها یک محیط لغوی وجود دارد:

این همان محیط لغوی گلوبال است که به تمام کد اختصاص یافته.

در تصویر بالا، مستطیل به معنای ذخایر محیط (ذخایر متغیر) است Ùˆ کمان به معنی مرجع بیرونی. محیط لغوی گلوبال مرجع بیرونی ندارد Ùˆ به همین دلیل است Ú©Ù‡ کمان به null اشاره می‌کند.

همانطور که کد شروع به اجرا شدن می‌کند و ادامه می‌یابد، محیط لغوی تغییر می‌کند.

یک کد طولانی‌تر را اینجا داریم:

مستطیل‌های سمت راست نشان می‌دهند که محیط لغوی گلوبال در حین اجرا شدن چگونه تغییر می‌کند:

1. زمانی که اسکریپت شروع می‌کند، محیط لغوی از تمام متغیرهای تعریف شده پر می‌شود.
   • در ابتدا، آنها در حالت «بدون مقدار اولیه (Uninitialized)» هستند. این یک حالت درونی خاص است Ùˆ به این معنی است Ú©Ù‡ موتور درباره متغیر آگاه است اما تا زمانی Ú©Ù‡ با let تعریف شود نمی‌توان به آن رجوع کرد. تقریبا مانند این است Ú©Ù‡ متغیر وجود ندارد.
2. تعریف let phrase نمایان می‌شود. هنوز مقداردهی نشده است، پس مقدار آنها undefined است. ما می‌توانیم از اینجا به بعد از متغیر استفاده کنیم.
3. phrase یک مقدار گرفته است.
4. phrase مقدار را تغییر می‌دهد.

تا اینجا همه چیز ساده بنظر می‌رسد نه؟

• یک متغیر، ویژگی یک شیء خاص درونی است Ú©Ù‡ به بلوک/تابع/اسکریپتی Ú©Ù‡ در حال اجرا است اختصاص یافته.
• کارکردن با متغیرها در واقع کارکردن با ویژگی‌های آن شیء است.

مرحله 2. Function Declaration

یک تابع هم مانند یک متغیر، مقدار است.

تفاوت اینجاست که Function Declaration سریعا به طور کامل مقداردهی می‌شوند.

زمانی Ú©Ù‡ یک محیط لغوی ساخته می‌شود، یک Function Declaration سریعا به یک تابع آماده استفاده تبدیل می‌شود (برخلاف let Ú©Ù‡ تا زمان تعریف آن در کد غیر قابل استفاده است).

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

برای مثال، زمانی که ما یک تابع اضافه می‌کنیم وضعیت اولیه محیط لغوی گلوبال اینگونه است:

طبیعتا، این رفتار فقط برای Function Declarations است نه برای اعلان تابع Expression Ú©Ù‡ ما یک متغیر را برابر با یک تابع قرار می‌دهیم مانند let say = function(name)....

مرحله 3. محیط‌های لغوی درونی و بیرونی

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

برای مثال، برای say("John)" اینگونه بنظر می‌رسد (فرایند اجرا شدن در خطی است Ú©Ù‡ با کمان نشانه گذاری شده است):

در حین فراخوانی تابع ما دو محیط لغوی داریم: محیط درونی (برای فراخوانی تابع) و محیط بیرونی (گلوبال):

• محیط لغوی درونی متناظر با فرایند اجرای کنونی say است. این محیط یک ویژگی(property) دارد: name Ú©Ù‡ همان آرگومان تابع است. ما say("John") را فراخوانی کردیم پس مقدار name برابر با "John" خواهد بود.
• محیط لغوی بیرونی همان محیط لغوی گلوبال است. این محیط متغیر phrase Ùˆ خود تابع را شامل می‌شود.

محیط لغوی درونی یک رجوع به محیط outer(بیرونی) دارد.

زمانی که کد می‌خواهد به یک متغیر دسترسی پیدا کند – اول محیط لغوی درونی جستجو می‌شود، سپس محیط بیرونی، سپس محیط بیرونی‌تر و همینطور تا محیط لغوی گلوبال ادامه پیدا می‌کند

اگر متغیری جایی پیدا نشود، در حالت سخت‌گیرانه(strict mode) ارور ایجاد می‌شود (بدون use strictØŒ برای سازگاری با کدهای قدیمی اگر یک متغیر Ú©Ù‡ موجود نیست را برای مقداردهی استفاده کنیم، یک متغیر گلوبال جدید ساخته می‌شود).

در این مثال، جستجو اینگونه پیش می‌رود:

• برای متغیر nameØŒ alert Ú©Ù‡ درون say است بلافاصله آن را در محیط لغوی درونی پیدا می‌کند.
• زمانی Ú©Ù‡ می‌خواهد به phrase دسترسی پیدا کند، هیچ phrase محلی موجود نیست، پس به محیط لغوی بیرونی رجوع Ùˆ آن را آنجا پیدا می‌کند.

مرحله 4. برگرداندن یک تابع

بیایید به مثال makeCounter برگردیم.

function makeCounter() {
  let count = 0;

  return function() {
    return count++;
  };
}

let counter = makeCounter();

در ابتدای هر فراخوانی makeCounterØŒ یک شیء محیط لغوی جدید ساخته می‌شود تا متغیرها را برای این فراخوانیِ makeCounter ذخیره کند.

بنابراین ما دو محیط لغوی تودرتو داریم، درست مانند مثال بالا:

تفاوتی Ú©Ù‡ وجود دارد این است Ú©Ù‡ در حین اجرای makeCounterØŒ یک تابع Ú©ÙˆÚ†Ú© تودرتو فقط به خاطر یک خط ایجاد می‌شود: return count++. ما هنوز این را اجرا نمی‌کنیم فقط می‌سازیم.

تمام تابع‌ها محیط لغوی‌ای Ú©Ù‡ در آن ساخته شده‌اند را به یاد می‌سپارند. از لحاظ فنی، هیچ جادویی اینجا وجود ندارد: تمام تابع‌ها یک ویژگی پنهان [[Environment]] دارند Ú©Ù‡ یک رجوع به محیط لغوی‌ای Ú©Ù‡ تابع در آن ساخته شده است دارد:

بنابراین counter.[[Environment]] یک رجوع به محیط لغوی {count: 0} دارد. اینگونه است Ú©Ù‡ تابع بدون توجه به اینکه کجا فراخوانی شده است، جایی Ú©Ù‡ ساخته شده را به یاد می‌سپارد. مرجع [[Environment]] فقط یک بار Ùˆ برای همیشه در زمان ساخت تابع تنظیم می‌شود.

بعدا، زمانی Ú©Ù‡ counter() فراخوانی می‌شود، یک محیط لغوی جدید برای آن فراخوانی ایجاد می‌شود Ùˆ مرجع محیط لغوی بیرونی آن از counter.[[Environment]] گرفته می‌شود:

حالا زمانی Ú©Ù‡ کد، درون counter() را برای متغیر count جستجو می‌کند، ابتدا محیط لغوی خودش را جستجو می‌کند (Ú©Ù‡ به دلیل نبود متغیری محلی خالی است)ØŒ سپس محیط لغویِ فراخوانیِ بیرونیِ makeCounter() را جستجو Ùˆ آنجا آن را پیدا می‌کند Ùˆ تغییرش می‌دهد.

یک متغیر در محیط لغوی‌ای که وجود دارد تغییر می‌یابد.

بعد از اجرا شدن وضعیت اینگونه است:

اگر ما counter() را چند بار فراخوانی کنیم، متغیر count به 2ØŒ 3 Ùˆ بیشتر در جای یکسانی افزایش می‌یابد.

زباله‌روبی

معمولا یک محیط لغوی زمانی که فراخوانی تابع تمام می‌شود با تمام متغیرهای خود از حافظه پاک می‌شود. به این دلیل که هیچ رجوعی به آن وجود ندارد. مانند هر شیء جاوااسکریپت، فقط تا زمانی که قابل دستیابی باشد در حافظه نگهداری می‌شود.

گرچه، اگر تابع‌ای تودرتو وجود داشته باشد Ú©Ù‡ بعد از پایان یک تابع هنوز قابل دسترس باشد، پس یک ویژگی [[Environment]] دارد Ú©Ù‡ به محیط لغوی رجوع می‌کند.

در این صورت محیط لغوی حتی بعد از تکمیل تابع هنوز قابل دسترس است پس از بین نمی‌رود.

برای مثال:

function f() {
  let value = 123;

  return function() {
    alert(value);
  }
}

let g = f(); // یک رجوع به محیط لغوی را ذخیره می‌کند g.[[Environment]]
// است f() که همان محیط لغوی فراخوانی

لطفا در نظر داشته باشید Ú©Ù‡ اگر f() چند بار فراخوانی شود Ùˆ تابع‌های برگردانده‌شده ذخیره شوند، سپس تمام شیءهای محیط لغوی متناظر هم در حافظه نگهداری می‌شود. در کد زیر هر 3تای آنها ذخیره می‌شود:

function f() {
  let value = Math.random();

  return function() { alert(value); };
}

// در آرایه 3 تابع وجود دارد، هر کدام به محیط لغوی متصل هستند
// f() محیطی از فراخوانی متناظر
let arr = [f(), f(), f()];

یک شیء محیط لغوی زمانی که غیر قابل دسترس شود ازبین می‌رود (درست مانند هر شیء دیگری). به عبارتی دیگر، فقط تا زمانی که حداقل یک تابع تودرتو وجود داشته باشد که به آن رجوع کند وجود خواهد داشت.

در کد زیر، بعد از اینکه تابع تودرتو حذف شود، محیط لغوی ضمیمه شده به آن (Ùˆ از این رو value) از حافظه پاک می‌شود:

function f() {
  let value = 123;

  return function() {
    alert(value);
  }
}

let g = f(); // در حافظه می‌ماند value وجود داشته باشد، متغیر g تا زمانی که تابع

g = null; // و حالا حافظه تمیز شده...

بهینه‌سازی در واقعیت

همانطور که دیدیم، از لحاظ تئوری تا زمانی که یک تابع موجود است، تمام متغیرهای بیرونی هم حفظ می‌شوند.

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

یک عارضه جانبی در موتور V8 (Chrome، Edge، Opera) این است که چنین متغیرهایی در دیباگ کردن غیر قابل دسترس می‌شوند.

سعی کنید که مثال پایین را در Chrome بعد از بازکردن Developer Tools اجرا کنید.

زمانی Ú©Ù‡ متوقف می‌شود، در کنسول alert(value) را تایپ کنید.

function f() {
  let value = Math.random();

  function g() {
    debugger; // ؛ چنین متغیری وجود نداردalert(value) :در کنسول تایپ کنید
  }

  return g;
}

let g = f();
g();

همانطور که دیدید، چنین متغیری وجود نداشت! از لحاظ تئوری، باید قابل دسترس باشد، اما موتور با بهینه‌سازی آن را ازبین برد.

این موضوع ممکن است منجر به مشکل‌های جالب (شاید وقت‌گیر) در زمان دیباگ کردن شود. یک از آنها این است که امکان دارد ما یک متغیر که هم نام با متغیر مورد نظر ما است را ببینیم:

let value = "سوپرایز!";

function f() {
  let value = "value نزدیک ترین متغیر";

  function g() {
    debugger; // !؛ سوپرایزalert(value) در کنسول: تایپ کنید
  }

  return g;
}

let g = f();
g();

خوب است که درباره این خاصیت V8 بدانید. اگر در حال دیباگ کردن با Chrome/Edge/Opera باشید، به دیر یا زود با آن روبرو می‌شوید.

این یک باگ در debugger نیست بلکه یک ویژگی خاص V8 است. شاید زمانی آن را تغییر دهند. شما همیشه می‌توانید با اجرای مثال‌های این صفحه آن را بررسی کنید.