نطاق (برمجة الحاسوب)

يكمن أحد الفروق الأساسية في النطاق في معنى "جزء من البرنامج". في اللغات ذات النطاق المعجمي (ويُسمى أيضًا النطاق الثابت )، يعتمد حلّ الاسم على موقعه في شفرة المصدر والسياق المعجمي (ويُسمى أيضًا السياق الثابت )، والذي يُحدد بمكان تعريف المتغير أو الدالة المُسماة. في المقابل، في اللغات ذات النطاق الديناميكي، يعتمد حلّ الاسم على حالة البرنامج عند مصادفة الاسم، والتي يُحددها سياق التنفيذ (ويُسمى أيضًا سياق وقت التشغيل ، أو سياق الاستدعاء ، أو السياق الديناميكي ). عمليًا، في النطاق المعجمي، يُحلّ الاسم بالبحث في السياق المعجمي المحلي، ثم إذا فشل ذلك، بالبحث في السياق المعجمي الخارجي، وهكذا؛ بينما في النطاق الديناميكي، يُحلّ الاسم بالبحث في سياق التنفيذ المحلي، ثم إذا فشل ذلك، بالبحث في سياق التنفيذ الخارجي، وهكذا، بالتقدم صعودًا في مكدس الاستدعاءات. ^{[ 4 ]}

تستخدم معظم لغات البرمجة الحديثة النطاق المعجمي للمتغيرات والدوال، بينما يُستخدم النطاق الديناميكي في بعض اللغات، ولا سيما بعض لهجات لغة ليسب، وبعض لغات البرمجة النصية، وبعض لغات القوالب . ^{[ ج ]} توفر لغة بيرل 5 كلا النطاقين المعجمي والديناميكي. تُعرف الدوال التي تستخدم متغيرات ذات نطاق معجمي باسم الدوال المغلقة .

يمكن تحديد الحل المعجمي في وقت الترجمة ، ويُعرف أيضًا باسم الربط المبكر ، بينما لا يمكن تحديد الحل الديناميكي بشكل عام إلا في وقت التشغيل ، وبالتالي يُعرف باسم الربط المتأخر .

في البرمجة كائنية التوجه ، يختار الإرسال الديناميكي دالة الكائن أثناء التشغيل، مع العلم أن تحديد ما إذا كان ربط الاسم الفعلي يتم أثناء الترجمة أو أثناء التشغيل يعتمد على لغة البرمجة. ويُعدّ النطاق الديناميكي الفعلي شائعًا في لغات الماكرو ، التي لا تُجري تحليل الأسماء مباشرةً، بل تتوسع في مكانها.

تستخدم بعض أطر البرمجة، مثل AngularJS، مصطلح "النطاق" من الناحية التركيبية بمعنى مختلف تمامًا عن معناه في هذه المقالة. ففي هذه الأطر، يُعد النطاق مجرد كائن من لغة البرمجة المستخدمة ( JavaScript في حالة AngularJS)، ويُستخدم بطرق معينة لمحاكاة النطاق الديناميكي في لغة تعتمد على النطاق المعجمي لمتغيراتها. ويمكن أن تكون نطاقات AngularJS هذه ضمن السياق أو خارجه (بالمعنى المعتاد للمصطلح) في أي جزء من البرنامج، مع اتباع قواعد نطاق المتغيرات المعتادة في اللغة كأي كائن آخر، واستخدام قواعد التوريث والتضمين الخاصة بها. وفي سياق AngularJS، يُستخدم أحيانًا مصطلح "$scope" (مع علامة الدولار) لتجنب الالتباس ، ولكن استخدام علامة الدولار في أسماء المتغيرات غالبًا ما يُنصح بتجنبه وفقًا لأدلة الأسلوب. ^{[ 5 ]}

نطاق ربط الاسم هو تعبير ، يُعرف بنطاق التعبير . يتوفر نطاق التعبير في العديد من اللغات، وخاصة اللغات الوظيفية التي توفر ميزة تُسمى تعبيرات let، والتي تسمح بأن يكون نطاق التصريح تعبيرًا واحدًا. يُعد هذا مفيدًا، على سبيل المثال، إذا كانت هناك حاجة إلى قيمة وسيطة لإجراء عملية حسابية. على سبيل المثال، في لغة Standard ML ، إذا كانت f()القيمة المُعادة 12هي ، فإن هو تعبير يُقيّم إلى ، باستخدام متغير مؤقت يُسمى لتجنب استدعاء مرتين. تُقارب بعض اللغات ذات نطاق الكتلة هذه الوظيفة من خلال توفير صيغة لتضمين كتلة في تعبير؛ على سبيل المثال، يمكن كتابة تعبير Standard ML المذكور أعلاه في لغة Perl على النحو التالي: ، أو في لغة GNU C على النحو التالي: .let val x = f() in x * x end144xf()do{my$x=f();$x*$x}({intx=f();x*x;})

في لغة بايثون، يكون للمتغيرات المساعدة في تعبيرات المولدات وفهم القوائم (في بايثون 3) نطاق تعبير.

في لغة C، تتمتع أسماء المتغيرات في نموذج الدالة بنطاق تعبيري، يُعرف في هذا السياق بنطاق بروتوكول الدالة . ولأن أسماء المتغيرات في النموذج لا يُشار إليها (قد تختلف في التعريف الفعلي) - فهي مجرد أسماء وهمية - فغالبًا ما تُحذف، مع أنها قد تُستخدم لإنشاء التوثيق، على سبيل المثال.

نطاق ربط الاسم هو كتلة ، تُعرف بنطاق الكتلة . يتوفر نطاق الكتلة في العديد من لغات البرمجة ذات البنية الكتلية، ولكن ليس جميعها. بدأ هذا مع لغة ALGOL 60 ، حيث "كل تصريح ... صالح فقط لتلك الكتلة."، ^{[ 6 ]} ويرتبط اليوم بشكل خاص بلغات عائلتي باسكال وسي . غالبًا ما تكون هذه الكتلة موجودة داخل دالة، مما يقيد النطاق بجزء من تلك الدالة، ولكن في بعض الحالات، مثل لغة بيرل، قد لا تكون الكتلة داخل دالة.

دالة مجموع_المربعات ( عدد صحيح م ) { عدد صحيح النتيجة = 0 ؛ من أجل ( عدد صحيح ن = 1 ؛ ن <= م ؛ ++ ن ) { عدد صحيح ن_تربيع = ن * ن ؛ النتيجة += ن_تربيع ؛ } إرجاع النتيجة ؛ }

يُعدّ كود C الموضح هنا مثالًا نموذجيًا على استخدام نطاق الكتلة، حيث تم تحديد نطاق متغيرين ضمن الحلقة: متغير الحلقة n ، الذي تتم تهيئته مرة واحدة وزيادته في كل تكرار للحلقة، والمتغير المساعد n_squared ، الذي تتم تهيئته في كل تكرار. والهدف من ذلك هو تجنب إضافة متغيرات إلى نطاق الدالة تكون ذات صلة بكتلة معينة فقط؛ فعلى سبيل المثال، يمنع هذا حدوث أخطاء ناتجة عن تعيين قيمة خاطئة لمتغير الحلقة العام i . في هذا المثال، لا يتم عادةً إسناد التعبير n * nإلى متغير مساعد، ويتم كتابة جسم الحلقة كما هو، result += n * nولكن في الأمثلة الأكثر تعقيدًا، تكون المتغيرات المساعدة مفيدة.

تُستخدم الكتل البرمجية بشكل أساسي للتحكم في تدفق البرنامج، كما هو الحال مع حلقات if و while و for، وفي هذه الحالات، يعني نطاق الكتلة أن نطاق المتغير يعتمد على بنية تدفق تنفيذ الدالة. مع ذلك، تسمح اللغات التي تدعم نطاق الكتلة عادةً باستخدام الكتل "المجردة"، والتي يقتصر غرضها على توفير تحكم دقيق في نطاق المتغير. على سبيل المثال، يمكن تعريف متغير مساعد داخل كتلة برمجية، ثم استخدامه (مثلاً، إضافته إلى متغير بنطاق دالة) ثم حذفه عند انتهاء الكتلة، أو يمكن تضمين حلقة while داخل كتلة برمجية تُهيئ المتغيرات المستخدمة داخل الحلقة والتي يجب تهيئتها مرة واحدة فقط.

من الخصائص الدقيقة لبعض لغات البرمجة، مثل Algol 68 وC (كما هو موضح في هذا المثال، والمُعتمدة منذ C99 )، إمكانية تعريف متغيرات نطاق الكتلة ليس فقط داخل جسم الكتلة، بل أيضًا داخل عبارة التحكم، إن وُجدت. وهذا يُشابه مُعاملات الدوال، التي تُعرّف في تعريف الدالة (قبل بدء كتلة جسم الدالة)، وتكون ضمن نطاق جسم الدالة بأكمله. يُستخدم هذا بشكل أساسي في حلقات for ، التي تحتوي على عبارة تهيئة منفصلة عن شرط الحلقة، على عكس حلقات while، وهو أسلوب شائع.

يمكن استخدام نطاق الكتلة للتظليل. في هذا المثال، كان من الممكن تسمية المتغير المساعد داخل الكتلة بـ n ، مما يُخفي اسم المعامل، لكن هذا يُعتبر أسلوبًا غير مُستحب نظرًا لاحتمالية حدوث أخطاء. علاوة على ذلك، فإن بعض اللغات المُشتقة من لغة C، مثل Java وC#، على الرغم من دعمها لنطاق الكتلة (حيث يُمكن إخراج متغير محلي من سياقه قبل نهاية الدالة)، لا تسمح لمتغير محلي بإخفاء آخر. في هذه اللغات، ستؤدي محاولة تعريف المتغير n الثاني إلى خطأ في بناء الجملة، وسيتعين إعادة تسمية أحد المتغيرين n .

إذا استُخدمت كتلة برمجية لتعيين قيمة متغير، فإن نطاق الكتلة يتطلب تعريف المتغير خارج الكتلة. وهذا يُعقّد استخدام العبارات الشرطية ذات التعيين الفردي . على سبيل المثال، في لغة بايثون، التي لا تستخدم نطاق الكتلة، يمكن تهيئة متغير على النحو التالي:

إذا كان c : a = "foo" وإلا : a = ""

حيث aيمكن الوصول إليه بعد ifالبيان.

في لغة بيرل، التي تتميز بنطاق الكتلة، يتطلب هذا بدلاً من ذلك تعريف المتغير قبل الكتلة:

my $a ; if ( c ) { $a = 'foo' ; } else { $a = '' ; }

غالبًا ما يُعاد كتابة هذا باستخدام التعيين المتعدد، مع تهيئة المتغير بقيمة افتراضية. في بايثون (حيث لا يكون ذلك ضروريًا) سيكون الأمر كالتالي:

a = "" إذا كان c : a = "foo"

بينما في لغة بيرل سيكون هذا كالتالي:

my $a = '' ; if ( c ) { $a = 'foo' ; }

في حالة تعيين متغير واحد، يكون البديل هو استخدام عامل التشغيل الثلاثي لتجنب الكتلة، ولكن هذا ليس ممكنًا بشكل عام لتعيينات المتغيرات المتعددة، ويصعب قراءته للمنطق المعقد.

هذه مشكلة أكثر أهمية في لغة C، لا سيما فيما يتعلق بتعيين السلاسل النصية، حيث يمكن لتهيئة السلسلة النصية تخصيص الذاكرة تلقائيًا، بينما يتطلب تعيين السلسلة النصية لمتغير مهيأ بالفعل تخصيص الذاكرة ونسخ السلسلة النصية والتحقق من نجاح هذه العمليات.

{ my $counter = 0 ; sub increment_counter { return ++ $counter ; } }

تسمح بعض لغات البرمجة بتطبيق مفهوم نطاق الكتلة، بدرجات متفاوتة، خارج نطاق الدالة. على سبيل المثال، في مقتطف بيرل على اليمين، $counterيُمثل `a` اسم متغير بنطاق كتلة (بسبب استخدام الكلمة myالمفتاحية `{{}}}`)، بينما increment_counterيُمثل `a` اسم دالة بنطاق عام. كل استدعاء لـ `a` increment_counterسيزيد قيمة `a` $counterبمقدار واحد، ويعيد القيمة الجديدة. يمكن للكود خارج هذه الكتلة استدعاء `a` increment_counter، لكن لا يمكنه الحصول على قيمة `a` أو تغييرها بأي طريقة أخرى $counter. يُتيح هذا الأسلوب تعريف الدوال المغلقة في بيرل.

عندما لا يتجاوز نطاق المتغيرات المُعلنة داخل دالة نطاق تلك الدالة، يُعرف ذلك بنطاق الدالة . ^{[ 7 ]} يتوفر نطاق الدالة في معظم لغات البرمجة التي تُتيح إنشاء متغير محلي داخل دالة أو إجراء فرعي : وهو متغير ينتهي نطاقه (أي يخرج من سياقه) عند انتهاء الدالة. في معظم الحالات، يكون عمر المتغير هو مدة استدعاء الدالة - فهو متغير تلقائي ، يُنشأ عند بدء الدالة (أو عند تعريف المتغير)، ويُحذف عند انتهاء الدالة - بينما يكون نطاق المتغير داخل الدالة، مع العلم أن معنى "داخل" يعتمد على ما إذا كان النطاق معجميًا أم ديناميكيًا. مع ذلك، تُتيح بعض اللغات، مثل لغة C، أيضًا المتغيرات المحلية الثابتة ، حيث يكون عمر المتغير هو عمر البرنامج بالكامل، ولكن يكون المتغير ضمن سياق الدالة فقط. في حالة المتغيرات المحلية الثابتة، يُنشأ المتغير عند بدء تشغيل البرنامج، ويُحذف فقط عند انتهائه، كما هو الحال مع المتغير العام الثابت ، ولكنه يكون ضمن سياق الدالة فقط، مثل المتغير المحلي التلقائي.

من المهم ملاحظة أنه في النطاق المعجمي، يكون نطاق المتغير ذي النطاق الوظيفي محصورًا ضمن السياق المعجمي للدالة فقط؛ إذ يخرج من هذا السياق عند استدعاء دالة أخرى داخل الدالة، ويعود إليه عند انتهاء الدالة. لا تستطيع الدوال المستدعاة الوصول إلى المتغيرات المحلية للدوال المستدعِية، وتكون المتغيرات المحلية ضمن سياق جسم الدالة التي تم تعريفها فيها فقط. على النقيض من ذلك، في النطاق الديناميكي، يمتد النطاق إلى سياق تنفيذ الدالة: تبقى المتغيرات المحلية ضمن سياقها عند استدعاء دالة أخرى، ولا تخرج منه إلا عند انتهاء الدالة المُعرِّفة، وبالتالي تكون المتغيرات المحلية ضمن سياق الدالة التي تم تعريفها فيها وجميع الدوال المستدعاة . في اللغات التي تستخدم النطاق المعجمي والدوال المتداخلة ، تكون المتغيرات المحلية ضمن سياق الدوال المتداخلة، لأنها تقع ضمن نفس السياق المعجمي، ولكن ليس ضمن سياق الدوال الأخرى غير المتداخلة معجميًا. يُعرف المتغير المحلي للدالة المُحيطة بالمتغير غير المحلي للدالة المتداخلة. ينطبق نطاق الدالة أيضًا على الدوال المجهولة .

دالة مربعة ( ن : عدد صحيح ) -> عدد صحيح : تُرجع ن * ندالة مجموع_المربعات ( ن : عدد صحيح ) -> عدد صحيح : المجموع : عدد صحيح = 0، i : عدد صحيح = 0، بينما i <= ن : المجموع += مربع ( i )، i += 1، إرجاع المجموع

على سبيل المثال، في مقتطف كود بايثون على اليمين، تم تعريف دالتين: الأولى squareلحساب مربع عدد، sum_of_squaresوالثانية لحساب مجموع مربعات الأعداد حتى ذلك العدد. (على سبيل المثال ، مربع العدد يساوي ^4² ، ومربع العدد يساوي ^0² + 1² + ^2² + ^3² + ^{4² )} .squaresum_of_squaressquare(4)  16sum_of_squares(4)          30

تحتوي كل دالة من هذه الدوال على متغير يُسمى n يُمثل وسيط الدالة. هذان المتغيران n منفصلان تمامًا وغير مرتبطين، على الرغم من تشابه اسميهما، لأنهما متغيران محليان ضمن نطاق الدالة: نطاق كل منهما دالة مستقلة بذاتها، وبالتالي لا يتداخلان. لذلك، sum_of_squaresيمكن استدعاء الدالة دون تغيير قيمة nsquare الخاصة بها . وبالمثل، تحتوي الدالة على متغيرين يُسميان total و i ؛ هذان المتغيران، نظرًا لنطاقهما المحدود، لن يتعارضا مع أي متغيرات أخرى تحمل الاسم total أو i قد تنتمي إلى أي دالة أخرى. بعبارة أخرى، لا يوجد خطر من حدوث تضارب في الأسماء بين هذه الأسماء وأي أسماء أخرى غير مرتبطة بها، حتى لو كانت متطابقة.sum_of_squares

لا يحدث إخفاء للأسماء: يوجد متغير واحد فقط باسم n في السياق في أي وقت، حيث لا تتداخل النطاقات. على النقيض من ذلك، إذا كُتبت فقرة مماثلة بلغة ذات نطاق ديناميكي، فإن n في الدالة المُستدعِية سيبقى في سياق الدالة المُستدعاة - ستتداخل النطاقات - وسيتم إخفاؤه (تظليله) بواسطة n الجديد في الدالة المُستدعاة.

يصبح نطاق الدالة أكثر تعقيدًا بشكل ملحوظ إذا كانت الدوال كائنات من الدرجة الأولى، ويمكن إنشاؤها محليًا بواسطة دالة أخرى ثم إعادتها. في هذه الحالة، تُنشئ أي متغيرات في الدالة المتداخلة غير محلية لها (المتغيرات غير المُرتبطة في تعريف الدالة، والتي تُحل إلى متغيرات في سياق مُحيط) إغلاقًا ، حيث لا يجب إعادة الدالة نفسها فحسب، بل يجب أيضًا إعادة سياقها (من المتغيرات)، ثم استدعاؤها لاحقًا في سياق مختلف. يتطلب هذا دعمًا أكبر بكثير من المُصرّف، وقد يُعقّد تحليل البرنامج .

نطاق ربط الاسم هو ملف، ويُعرف هذا بنطاق الملف . يُعد نطاق الملف خاصًا بلغة C (وC++) إلى حد كبير، حيث يمتد نطاق المتغيرات والدوال المُعلنة في المستوى الأعلى من الملف (وليس داخل أي دالة) ليشمل الملف بأكمله، أو بالأحرى، في لغة C، من لحظة الإعلان حتى نهاية ملف المصدر، أو تحديدًا وحدة الترجمة (الربط الداخلي). يُمكن اعتبار هذا شكلًا من أشكال نطاق الوحدة، حيث تُعرّف الوحدات بالملفات، وفي اللغات الحديثة يُستبدل بنطاق وحدة صريح. نظرًا لوجود عبارات التضمين، التي تُضيف متغيرات ودوال إلى السياق الداخلي، وقد تستدعي بدورها عبارات تضمين أخرى، قد يصعب تحديد ما هو موجود في سياق الملف.

في مقتطف كود C أعلاه، اسم الدالة sum_of_squaresله نطاق عام (في لغة C، يُسمى ارتباطًا خارجيًا). إضافة staticإلى توقيع الدالة سيؤدي إلى نطاق ملف (ارتباط داخلي).

نطاق ربط الاسم هو وحدة نمطية، ويُعرف هذا بنطاق الوحدة النمطية . يتوفر نطاق الوحدة النمطية في لغات البرمجة النمطية حيث تُشكّل الوحدات النمطية (التي قد تمتد عبر ملفات متعددة) الوحدة الأساسية للبرنامج المعقد، إذ تسمح بإخفاء المعلومات وعرض واجهة محدودة. وقد رُوّج لنطاق الوحدة النمطية في عائلة لغات Modula ، وتُعدّ لغة Python (التي تأثرت بـ Modula) مثالًا معاصرًا بارزًا.

في بعض لغات البرمجة كائنية التوجه التي تفتقر إلى دعم مباشر للوحدات، مثل لغة C++ قبل إصدار C++20 ، ^{[ 8 ]} يُوفر هيكل الفئات بنيةً مشابهة، حيث تُمثل الفئات الوحدة الأساسية للبرنامج، ويمكن أن تحتوي الفئة على توابع خاصة. يُفهم هذا بشكل صحيح في سياق التوزيع الديناميكي وليس في سياق تحديد الأسماء والنطاق، على الرغم من أنهما غالبًا ما يؤديان أدوارًا متشابهة. في بعض الحالات، تتوفر كلتا الميزتين، كما هو الحال في لغة بايثون، التي تدعم كلاً من الوحدات والفئات، ويكون تنظيم الكود (كدالة على مستوى الوحدة أو كدالة خاصة تقليدية) خيارًا للمبرمج.

يُعرَّف نطاق ربط الاسم بأنه البرنامج بأكمله، ويُسمى النطاق العام . غالبًا ما تُعتبر أسماء المتغيرات ذات النطاق العام - والتي تُسمى المتغيرات العامة - ممارسةً سيئة، على الأقل في بعض لغات البرمجة، نظرًا لاحتمالية حدوث تضارب في الأسماء وإخفاء غير مقصود، فضلًا عن ضعف قابلية التجزئة، ويُفضَّل استخدام نطاق الدالة أو نطاق الكتلة. مع ذلك، يُستخدم النطاق العام عادةً (بحسب لغة البرمجة) لأنواع أخرى من الأسماء، مثل أسماء الدوال، وأسماء الأصناف ، وأسماء أنواع البيانات الأخرى . في هذه الحالات، تُستخدم آليات مثل مساحات الأسماء لتجنب التضارب.

استُخدم النطاق المعجمي لأول مرة في أوائل الستينيات للغة الإجرائية ALGOL 60، وتم اعتماده في معظم اللغات الإجرائية الأخرى منذ ذلك الحين. ^{[ 4 ]}

لطالما كان للغات مثل باسكال وسي نطاق معجمي، حيث أن كلاهما متأثر بالأفكار التي دخلت في ALGOL 60 و ALGOL 68 (على الرغم من أن لغة سي لم تتضمن وظائف متداخلة معجميًا ).

لغة بيرل هي لغة ذات نطاق ديناميكي، وقد أُضيف إليها نطاق ثابت لاحقاً.

استخدم مترجم لغة ليسب الأصلي (1960) النطاق الديناميكي. تم تقديم الربط العميق ، الذي يقارب النطاق الثابت (المعجمي)، حوالي عام 1962 في ليسب 1.5 (عبر جهاز Funarg الذي طوره ستيف راسل ، الذي كان يعمل تحت إشراف جون مكارثي ).

استخدمت جميع لغات ليسب المبكرة النطاق الديناميكي، عندما كانت تعتمد على المفسرات. في عام 1982، نشر جاي إل. ستيل الابن ومجموعة كومون ليسب كتابًا بعنوان "نظرة عامة على كومون ليسب " ^{[ 11 ]،} وهو عبارة عن مراجعة موجزة لتاريخ لغة ليسب وتطبيقاتها المختلفة حتى ذلك الحين، بالإضافة إلى استعراض للميزات التي ينبغي أن يتضمنها تطبيق كومون ليسب . في الصفحة 102، نقرأ:

معظم تطبيقات لغة ليسب تعاني من عدم اتساق داخلي، حيث قد يُسند المفسر والمترجم، افتراضيًا، دلالات مختلفة للبرامج الصحيحة؛ ويعود ذلك أساسًا إلى افتراض المفسر أن جميع المتغيرات ذات نطاق ديناميكي، بينما يفترض المترجم أنها محلية ما لم يُجبر على خلاف ذلك. وقد تم ذلك تسهيلًا للعملية وتحسينًا للكفاءة، ولكنه قد يؤدي إلى أخطاء دقيقة للغاية. يتجنب تعريف لغة ليسب المشتركة هذه التناقضات من خلال اشتراطه صراحةً على المفسر والمترجم فرض دلالات متطابقة على البرامج الصحيحة.

لذا، كان من الضروري أن تتمتع تطبيقات لغة Common Lisp بنطاق معجمي . مرة أخرى، من نظرة عامة على Common Lisp :

بالإضافة إلى ذلك، توفر لغة Common LISP الميزات التالية (معظمها مُستعار من MacLisp أو InterLisp أو Lisp Machines Lisp): (...) متغيرات ذات نطاق معجمي كامل. تم حل ما يُسمى بـ " مشكلة FUNARG " ^{[ 12 ] [ 13 ]} بشكل كامل، في كلتا الحالتين التنازلية والتصاعدية.

في نفس العام الذي نُشر فيه كتاب "نظرة عامة على لغة ليسب الشائعة" (1982)، نُشرت التصاميم الأولية (أيضًا من قِبل جاي إل. ستيل الابن) للغة ليسب مُجمّعة ذات نطاق معجمي، تُسمى "سكيم" ، وكانت تُجرى محاولات لتنفيذها بواسطة المُجمّعات. في ذلك الوقت، كان يُخشى عمومًا أن يكون النطاق المعجمي في لغة ليسب غير فعال من حيث التنفيذ. في كتاب "تاريخ لغة تي" ، ^{[ 14 ]} يكتب أولين شيفرز:

كانت جميع لغات Lisp الجادة المستخدمة في الإنتاج آنذاك تعتمد على النطاق الديناميكي. لم يكن أحد ممن لم يقرأوا بعناية أطروحة Rabbit ^{[ 15 ]} (التي كتبها جاي لويس ستيل الابن عام 1978) يعتقد أن النطاق المعجمي سينجح؛ حتى القلة الذين قرأوها كانوا يغامرون قليلاً بالاعتقاد بأن هذا سينجح في الاستخدام الإنتاجي الجاد.

يعود مصطلح "النطاق المعجمي" إلى عام 1967 على الأقل، ^{[ 16 ]} بينما يعود مصطلح "تحديد النطاق المعجمي" إلى عام 1970 على الأقل، حيث استُخدم في مشروع MAC لوصف قواعد نطاق لهجة Lisp MDL (المعروفة آنذاك باسم "Muddle"). ^{[ 17 ]}

في لغات البرمجة الحديثة، يلعب النطاق المعجمي دورًا محوريًا في تمكين نماذج البرمجة الوظيفية. تعتمد لغات مثل جافا سكريبت ^{[ 18 ]} ، وبايثون ^{[ 19 ]} ، وسويفت ^{[ 20 ]} اعتمادًا كبيرًا على النطاق المعجمي لضمان قدرة الدوال على الوصول إلى المتغيرات من سياق تعريفها، حتى لو تم تنفيذ الدالة خارج نطاقها المعجمي. يكتسب هذا أهمية خاصة عند التعامل مع الدوال المغلقة، التي تُعد نتيجة مباشرة للنطاق المعجمي.

على سبيل المثال، في جافا سكريبت، تُستخدم الدوال المغلقة بكثرة في البرمجة غير المتزامنة ومعالجة الأحداث، إذ تسمح للدوال المستدعاة بالاحتفاظ بإمكانية الوصول إلى المتغيرات من النطاق الخارجي، مما يُسهّل كتابة كود أكثر وضوحًا ونمطية. وبالمثل، تستخدم بايثون وسويفت النطاق المعجمي لتنفيذ الدوال المغلقة وتمكين أنماط قوية مثل الدوال عالية الرتبة. ^{[ 21 ]}

في اللغات الحديثة، يُعدّ توسيع الماكرو في المعالج المسبق مثالًا رئيسيًا على النطاق الديناميكي الفعلي. لغة الماكرو نفسها تُحوّل شفرة المصدر فقط، دون حلّ الأسماء، ولكن بما أن التوسيع يتم في مكانه، فعندما تُحلّ الأسماء في النص الموسّع (خاصةً المتغيرات الحرة)، تُحلّ بناءً على مكان توسيعها (أو "استدعائها")، كما لو كان النطاق الديناميكي مُطبّقًا.

يتمتع معالج C المسبق ، المستخدم لتوسيع وحدات الماكرو ، بنطاق ديناميكي فعلي، حيث إنه لا يحل الأسماء بنفسه وهو مستقل عن مكان تعريف الماكرو. على سبيل المثال، الماكرو:

#define ADD_A(x) x + a

سيتم توسيع المتغير لإضافة قيمة aإلى المتغير المُمرر، ولن يتم تحديد هذا الاسم إلا لاحقًا بواسطة المُصرّف بناءً على مكان ADD_Aاستدعاء الماكرو (أو توسيعه). في الواقع، يقوم مُعالج C المُسبق فقط بالتحليل المعجمي ، حيث يقوم بتوسيع الماكرو أثناء مرحلة التجزئة، ولكنه لا يقوم بتحليله إلى شجرة بناء الجملة أو تحديد اسمه.

على سبيل المثال، في الكود التالي، يتم حل الاسم aالموجود في الماكرو (بعد التوسيع) إلى المتغير المحلي في موقع التوسيع:

#define ADD_A(x) (x + a)void add_one ( int * x ) { const int a = 1 ; * x = ADD_A ( * x ); }void add_two ( int * x ) { const int a = 2 ; * x = ADD_A ( * x ); }

في لغة C، يُعرف النطاق تقليديًا بالربط أو الرؤية ، خاصةً بالنسبة للمتغيرات. C لغة ذات نطاق معجمي، حيث يوجد نطاق عام (يُعرف بالربط الخارجي )، ونوع من نطاق الوحدة أو نطاق الملف (يُعرف بالربط الداخلي )، ونطاق محلي (داخل الدالة)؛ ويمكن تداخل النطاقات داخل الدالة عبر نطاق الكتلة. مع ذلك، لا تدعم لغة C القياسية الدوال المتداخلة.

يُحدد نوع تخزين المتغير ونطاق رؤيته . توجد ثلاثة أنواع من فترات العمر في لغة C: ثابت (تنفيذ البرنامج)، وتلقائي (تنفيذ الكتلة، مُخصص على المكدس)، ويدوي (مُخصص على الكومة). يدعم المُصرّف النوعين الثابت والتلقائي فقط من فترات العمر، بينما يجب تتبع الذاكرة المُخصصة يدويًا بين المتغيرات المختلفة. توجد ثلاثة مستويات للرؤية في لغة C: الربط الخارجي (عام)، والربط الداخلي (على مستوى الملف تقريبًا)، ونطاق الكتلة (الذي يشمل الدوال)؛ يمكن تداخل نطاقات الكتل، كما يُمكن تحقيق مستويات مختلفة من الربط الداخلي باستخدام تضمينات C. يُشير الربط الداخلي في لغة C إلى الرؤية على مستوى وحدة الترجمة ، أي ملف المصدر بعد معالجته بواسطة مُعالج C المُسبق ، ويشمل ذلك جميع التضمينات ذات الصلة.

تُجمَّع برامج لغة C كملفات كائنية منفصلة ، ​​ثم تُربط هذه الملفات في ملف تنفيذي أو مكتبة عبر رابط . وبالتالي، يتم تقسيم عملية حلّ الأسماء بين المُجمِّع، الذي يحلّ الأسماء داخل وحدة الترجمة (أو "وحدة التجميع" بشكل أعم، ولكن هذا مفهوم مختلف تمامًا)، والرابط، الذي يحلّ الأسماء بين وحدات الترجمة؛ انظر الربط لمزيد من التفاصيل.

في لغة C، تدخل المتغيرات ذات النطاق الكتلي إلى سياقها عند تعريفها (وليس في بداية الكتلة)، وتخرج من هذا السياق عند استدعاء أي دالة (غير متداخلة) داخل الكتلة، وتعود إلى السياق عند انتهاء الدالة، وتخرج منه عند نهاية الكتلة. أما بالنسبة للمتغيرات المحلية التلقائية، فيتم تخصيصها عند تعريفها وتحريرها عند نهاية الكتلة، بينما بالنسبة للمتغيرات المحلية الثابتة، فيتم تخصيصها عند بدء تشغيل البرنامج وتحريرها عند انتهائه.

يوضح البرنامج التالي متغيرًا بنطاق كتلة يدخل في السياق في منتصف الكتلة، ثم يخرج من السياق (ويتم تحريره فعليًا) عند انتهاء الكتلة:

#include <stdio.h>int main ( void ) { char x = 'm' ; printf ( "%c \n " , x );{ printf ( "%c \n " , x ); char x = 'b' ; printf ( "%c \n " , x ); }printf ( "%c \n " , x ); }

يُخرج البرنامج ما يلي:

م م ب م 

توجد مستويات أخرى لنطاق المتغيرات في لغة C. ^{[ 23 ]} أسماء المتغيرات المستخدمة في نموذج الدالة لها نطاق رؤية نموذج الدالة، ويتم الخروج من السياق في نهاية نموذج الدالة. ولأن الاسم غير مستخدم، فإن هذا غير مفيد للترجمة، ولكنه قد يكون مفيدًا للتوثيق. أسماء التسميات لعبارة GOTO لها نطاق الدالة.

يجب تعريف جميع المتغيرات المستخدمة في البرنامج مع تحديد نوعها في موضع سابق من الكود، كما هو الحال في الكود السابق عند بداية جسم الدالة mainعند تعريف a و b و result على أنها من نوع int. يمكن أن يكون نطاق المتغير عامًا أو محليًا. المتغير العام هو المتغير المُعرَّف في الجزء الرئيسي من الكود المصدري، خارج جميع الدوال، بينما المتغير المحلي هو المتغير المُعرَّف داخل جسم دالة أو كتلة برمجية.

تسمح الإصدارات الحديثة بنطاق معجمي متداخل.

يحتوي Swift على قاعدة مماثلة للنطاقات مع C++، ولكنه يحتوي على مُعدِّلات وصول مختلفة .

تعتمد لغة Go على النطاق المعجمي باستخدام الكتل. ^{[ 3 ]}

لغة جافا ذات نطاق معجمي.

تحتوي فئة جافا على عدة أنواع من المتغيرات: ^{[ 24 ]}

المتغيرات المحلية

تُعرَّف هذه المتغيرات داخل دالة أو كتلة برمجية محددة. وتكون هذه المتغيرات محلية في مكان تعريفها والمستويات الأدنى منه. على سبيل المثال، يمكن لحلقة تكرار داخل دالة استخدام المتغيرات المحلية لتلك الدالة، ولكن ليس العكس. تُحذف متغيرات الحلقة (المحلية لتلك الحلقة) بمجرد انتهاء الحلقة.

المتغيرات الأعضاء

تُعرف المتغيرات ، التي تُسمى أيضًا بالحقول، بأنها متغيرات مُعلنة داخل الصنف، خارج أي دالة. وبشكل افتراضي، تكون هذه المتغيرات متاحة لجميع الدوال داخل ذلك الصنف، وكذلك لجميع الأصناف في الحزمة.

حدود

هي متغيرات في تعريفات الأساليب.

بشكل عام، تحدد مجموعة من الأقواس نطاقًا معينًا، لكن سلوك المتغيرات في المستوى الأعلى داخل الصنف قد يختلف تبعًا لكلمات التعديل المستخدمة في تعريفها. يوضح الجدول التالي إمكانية الوصول إلى الأعضاء المسموح بها لكل مُعدِّل. ^{[ 25 ]}

تتميز لغة جافا سكريبت بقواعد نطاق بسيطة ، ^{[ 26 ]} لكن قواعد تهيئة المتغيرات وحلّ الأسماء قد تُسبب مشاكل، كما أن الاستخدام الواسع للدوال المغلقة في عمليات الاستدعاء يعني أن السياق المعجمي للدالة عند تعريفها (المستخدم لحلّ الأسماء) قد يختلف اختلافًا كبيرًا عن السياق المعجمي عند استدعائها (وهو غير ذي صلة بحلّ الأسماء). تتمتع كائنات جافا سكريبت بحلّ أسماء للخصائص، لكن هذا موضوع منفصل.

تتميز لغة جافا سكريبت بنطاق معجمي ^{[ 27 ]} متداخل على مستوى الدالة، حيث يمثل السياق العام السياق الخارجي. يُستخدم هذا النطاق لكل من المتغيرات والدوال (أي تعريفات الدوال، وليس متغيرات من نوع دالة ). ^{[ 28 ]} يُعد نطاق الكتلة باستخدام الكلمتين المفتاحيتين `<block scope>` letو` const<block scope>` معيارًا منذ إصدار ECMAScript 6. يمكن إنشاء نطاق الكتلة بتغليف الكتلة بأكملها في دالة ثم تنفيذها؛ يُعرف هذا بنمط تعبير الدالة المُستدعاة فورًا (IIFE).

على الرغم من بساطة نطاق المتغيرات في جافا سكريبت - فهو نطاق معجمي ونطاق دالة - إلا أن قواعد التهيئة وحلّ الأسماء المرتبطة به تُسبب بعض الارتباك. أولًا، عند إسناد قيمة إلى اسم خارج النطاق، يتم إنشاء متغير عام جديد، وليس متغيرًا محليًا. ثانيًا، لإنشاء متغير محلي جديد، يجب استخدام الكلمة varالمفتاحية `input`؛ حيث يُنشأ المتغير في بداية الدالة بقيمة، ثم undefinedتُسند إليه قيمته عند الوصول إلى عبارة الإسناد.

يتم تعيين قيمة تعبير التعيين الخاص بالمتغير الذي يحتوي على مُهيئ عند تنفيذ عبارة المتغير ، وليس عند إنشاء المتغير. ^{[ 29 ]}

يُعرف هذا باسم رفع المتغيرات ^{[ 30 ]} ، حيث يتم رفع تعريف المتغير، وليس تهيئته، إلى أعلى الدالة. ثالثًا، يؤدي الوصول إلى المتغيرات قبل تهيئتها إلى ظهور خطأ undefined، بدلًا من خطأ في بناء الجملة. رابعًا، بالنسبة لتعريفات الدوال، يتم رفع كل من التعريف والتهيئة إلى أعلى الدالة، على عكس تهيئة المتغيرات. على سبيل المثال، يُنتج الكود التالي مربع حوار مع مُخرجات.غير محددبما أن تعريف المتغير المحلي يتم رفعه، مما يؤدي إلى إخفاء المتغير العام، ولكن عملية التهيئة لا تتم، لذلك يكون المتغير غير مُعرَّف عند استخدامه:

a = 1 ; function f () { alert ( a ); var a = 2 ; } f ();

علاوة على ذلك، بما أن الدوال تُعتبر كائنات من الدرجة الأولى في جافا سكريبت، وكثيرًا ما تُستخدم كدوال رد نداء أو تُعاد من دوال أخرى، فعند تنفيذ دالة ما، يعتمد تحديد اسمها على مكان تعريفها الأصلي (السياق المعجمي للتعريف)، وليس على السياق المعجمي أو سياق التنفيذ الذي تُستدعى فيه. وتُسمى النطاقات المتداخلة لدالة معينة (من الأكثر عمومية إلى الأكثر محلية) في جافا سكريبت، وخاصةً للدالة المغلقة المستخدمة كدالة رد نداء، أحيانًا بسلسلة النطاقات ، قياسًا على سلسلة النموذج الأولي للكائن.

يمكن إنشاء الدوال المغلقة في جافا سكريبت باستخدام الدوال المتداخلة، لأن الدوال كائنات من الدرجة الأولى. ^{[ 31 ]} يؤدي إرجاع دالة متداخلة من دالة محيطة إلى تضمين المتغيرات المحلية للدالة المحيطة كسياق معجمي (غير محلي) للدالة المُعادة، مما ينتج عنه دالة مغلقة. على سبيل المثال:

دالة newCounter () { // تُعيد عدادًا يتم زيادته عند الاستدعاء (يبدأ من 0) // ويُعيد قيمته الجديدة var a = 0 ; var b = function () { a ++ ; return a ; }; return b ; } c = newCounter (); alert ( c () + ' ' + c ()); // يُخرج "1 2"

تُستخدم الدوال المغلقة بكثرة في جافا سكريبت، نظرًا لاستخدامها في دوال الاستدعاء. في الواقع، أي ربط لدالة في السياق المحلي كدالة استدعاء أو إعادتها من دالة يُنشئ دالة مغلقة إذا وُجدت أي متغيرات غير مُعرَّفة في جسم الدالة (مع سياق الدالة المغلقة المُستند إلى النطاقات المُتداخلة للسياق المعجمي الحالي، أو "سلسلة النطاق")؛ وقد يكون هذا غير مقصود. عند إنشاء دالة استدعاء بناءً على مُعاملات، يجب تخزين هذه المُعاملات في دالة مغلقة، وإلا فسيتم إنشاء دالة مغلقة تُشير عن طريق الخطأ إلى المُتغيرات في السياق المُحيط، والذي قد يتغير. ^{[ 32 ]}

يعتمد حل أسماء خصائص كائنات جافا سكريبت على الوراثة في شجرة النموذج الأولي - ويسمى المسار إلى الجذر في الشجرة سلسلة النموذج الأولي - وهو منفصل عن حل أسماء المتغيرات والوظائف.

تختلف قواعد نطاق اللغة في لهجات لغة ليسب .

استخدمت لغة Lisp الأصلية النطاق الديناميكي؛ أما لغة Scheme ، المستوحاة من لغة ALGOL ، فقد أدخلت النطاق الثابت (المعجمي) إلى عائلة Lisp.

استخدمت لغة ماكليسب النطاق الديناميكي افتراضيًا في المفسر والنطاق المعجمي افتراضيًا في الكود المُترجم، مع إمكانية وصول الكود المُترجم إلى الروابط الديناميكية باستخدام SPECIALتعريفات لمتغيرات محددة. ^{[ 33 ]} ومع ذلك، تعاملت ماكليسب مع الربط المعجمي كتحسين أكثر مما هو متوقع في اللغات الحديثة، ولم تتضمن ميزة الإغلاق التي قد يتوقعها المرء من النطاق المعجمي في لغات ليسب الحديثة. كانت هناك عملية منفصلة *FUNCTIONمتاحة للتغلب على بعض هذه المشكلة بطريقة غير سلسة. ^{[ 34 ]}

اعتمدت لغة Common Lisp النطاق المعجمي من لغة Scheme ، ^{[ 35 ]} كما فعلت لغة Clojure .

تتمتع لغة ISLISP بنطاق معجمي للمتغيرات العادية. كما أنها تحتوي على متغيرات ديناميكية، ولكنها في جميع الحالات يتم تمييزها بشكل صريح؛ يجب تعريفها بصيغة defdynamicخاصة، وربطها بصيغة dynamic-letخاصة، والوصول إليها بصيغة dynamicخاصة صريحة. ^{[ 36 ]}

لا تزال بعض لهجات لغة ليسب الأخرى، مثل إيماكس ليسب ، تستخدم النطاق الديناميكي افتراضيًا. أما إيماكس ليسب، فيتوفر لديها الآن نطاق معجمي متاح على أساس كل مخزن مؤقت. ^{[ 37 ]}

بالنسبة للمتغيرات، يوفر بايثون نطاقات الدالة، ونطاق الوحدة، والنطاق العام. تدخل الأسماء إلى السياق عند بداية النطاق (نطاق الدالة، أو نطاق الوحدة، أو النطاق العام)، وتخرج منه عند استدعاء دالة غير متداخلة أو عند انتهاء النطاق. إذا تم استخدام اسم قبل تهيئة المتغير، فسيؤدي ذلك إلى ظهور استثناء وقت التشغيل. عند الوصول إلى متغير (دون إسناد قيمة إليه)، يتم حل الاسم وفقًا لقاعدة LEGB (محلي، محيط، عام، مدمج) التي تُحدد أضيق نطاق ذي صلة. مع ذلك، عند إسناد قيمة إلى متغير، يتم افتراضيًا تعريف متغير يبدأ نطاقه من بداية المستوى (الدالة، أو الوحدة، أو النطاق العام)، وليس من نقطة الإسناد. يمكن تجاوز هاتين القاعدتين باستخدام تعريف `<input> global` أو nonlocal`<input>` (في بايثون 3) قبل الاستخدام، مما يسمح بالوصول إلى المتغيرات العامة حتى في حال وجود متغير غير محلي مُقنّع، وإسناد القيم إلى المتغيرات العامة أو غير المحلية.

كمثال بسيط، تقوم الدالة بربط متغير بالنطاق العام:

def f () -> None : print ( x )x : str = "global" f () # يطبع: global

لاحظ أن xالدالة تُعرَّف قبل fاستدعاء الدالة، لذا لا يظهر أي خطأ، على الرغم من تعريفها بعد الإشارة إليها في تعريف الدالة f. من الناحية اللغوية، هذه إشارة أمامية ، وهو أمر مسموح به في بايثون.

هنا، يؤدي التعيين إلى إنشاء متغير محلي جديد، وهو ما لا يغير قيمة المتغير العام:

def f () -> None : x : str = "f" print ( x )x : str = "global" print ( x ) # يطبع: global f () # يطبع: f print ( x ) # يطبع: global

يؤدي إسناد قيمة إلى متغير داخل دالة إلى تعريفه كمتغير محلي ضمن نطاق تلك الدالة، وبالتالي فإن نطاقه يشمل الدالة بأكملها، واستخدامه قبل هذا الإسناد يُسبب خطأً. يختلف هذا عن لغة C، حيث يبدأ نطاق المتغير المحلي من لحظة تعريفه. هذا الكود يُسبب خطأً:

def f () -> None : print ( x ) x : str = "f"x : str = "global" f () # Traceback (most recent call last): # File "<stdin>", line 1, in <module> # File "<stdin>", line 2, in f # UnboundLocalError: local variable 'x' referenced before assignment

يمكن تجاوز قواعد تحليل الأسماء الافتراضية باستخدام الكلمات المفتاحية global`or` nonlocal(في بايثون 3). في الكود أدناه، يعني global xالتصريح `in` أن `in` يُحل إلى المتغير العام. وبالتالي، يمكن الوصول إليه (لأنه مُعرّف مسبقًا)، وتُسند عملية الإسناد `assign` القيمة إلى المتغير العام، بدلًا من تعريف متغير محلي جديد. لاحظ أنه لا حاجة إلى تصريح `in` ، لأنه لا يُسند القيمة إلى المتغير، وبالتالي يُحل افتراضيًا إلى المتغير العام.gxglobalf

def f () -> None : print ( x )def g () -> None : global x print ( x ) x = "g"x : str = "global" f () # يطبع: global g () # يطبع: global f () # يطبع: g

globalيمكن استخدامها أيضًا مع الدوال المتداخلة. بالإضافة إلى السماح بتعيين قيمة لمتغير عام، كما هو الحال في الدوال غير المتداخلة، يمكن استخدامها أيضًا للوصول إلى المتغير العام في وجود متغير غير محلي.

def f () -> None : def g () -> None : global x print ( x ) x : str = "f" g ()x : str = "global" f () # يطبع: global

بالنسبة للدوال المتداخلة، يوجد أيضًا nonlocalتعريف لتعيين قيمة لمتغير غير محلي، على غرار استخدام globalفي دالة غير متداخلة:

def f () -> None : def g () -> None : nonlocal x # بايثون 3 فقط x = "g" x : str = "f" g () print ( x )x : str = "global" f () # يطبع: g print ( x ) # يطبع: global

لغة R هي لغة ذات نطاق معجمي، على عكس تطبيقات S الأخرى حيث تُحدد قيم المتغيرات الحرة بواسطة مجموعة من المتغيرات العامة، بينما في R تُحدد بواسطة السياق الذي أُنشئت فيه الدالة. ^{[ 38 ]} يمكن الوصول إلى سياقات النطاق باستخدام مجموعة متنوعة من الميزات (مثل parent.frame()) التي يمكنها محاكاة تجربة النطاق الديناميكي إذا رغب المبرمج بذلك.

لا يوجد نطاق كتلة:

a <- 1 { a <- 2 } message ( a ) ## 2

تتمتع الدوال بإمكانية الوصول إلى النطاق الذي تم إنشاؤها فيه:

a <- 1 f <- function () { message ( a ) } f () ## 1

تبقى المتغيرات التي يتم إنشاؤها أو تعديلها داخل دالة ما في مكانها:

a <- 1 f <- function () { message ( a ) a <- 2 message ( a ) } f () ## 1 ## 2 message ( a ) ## 1

تبقى المتغيرات التي يتم إنشاؤها أو تعديلها داخل دالة ما في مكانها ما لم يُطلب صراحةً تعيينها إلى النطاق المحيط بها:

a <- 1 f <- function () { message ( a ) a <<- 2 message ( a ) } f () ## 1 ## 2 message ( a ) ## 2

على الرغم من أن لغة R تتمتع بنطاق معجمي افتراضيًا، إلا أنه يمكن تغيير نطاقات الدوال:

a <- 1 f <- function () { message ( a ) } my_env <- new.env () my_env $ a <- 2 f () ## 1 environment ( f ) <- my_env f () ## 2