path: root/files/ar/web/javascript/guide/functions/index.html

---
title: الدوال
slug: Web/JavaScript/Guide/الدوال
tags:
  - الدوال
  - جافا سكريبت
  - دليل
translation_of: Web/JavaScript/Guide/Functions
---
<div>{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Loops_and_iteration", "Web/JavaScript/Guide/Expressions_and_Operators")}}</div>

<p class="summary" dir="rtl">الدوال هي واحدة من اللبنات الأساسية في جافاسكريبت. الدالة، هي عبارة عن مجموعة من التعليمات البرمجية التي تؤدي وظيفة معينة. حتى تتمكن من إستخدام الدالة، عليك أولا تعريفها في مكان ما من النطاق الذي تود إستدعائها منه.</p>

<div style="font-size: 15; font-family: 'tahoma';">
<p dir="rtl">يمكنك القاء نظرة في <a href="https://developer.mozilla.org/ar/docs/Web/JavaScript/Reference/%D8%A7%D9%84%D8%AF%D9%88%D8%A7%D9%84">مرجع مفصل عن دوال الجافاسكريبت</a> حتى تتعرف على تفاصيل اكثر.</p>

<h2 dir="rtl" id="انشاء_الدوال">انشاء الدوال</h2>

<h3 dir="rtl" id="الاعلان_عن_الدوال_-_الصيغة_الافتراضية_-_Function_declarations">الاعلان عن الدوال - الصيغة الافتراضية - Function declarations</h3>

<p dir="rtl"><strong>تعريف الدالة</strong>: تتكون الدالة من الكلمة المحجوزة <a href="https://developer.mozilla.org/ar/docs/Web/JavaScript/Reference/Statements/function">function</a>، متبوعة بـ :</p>

<ul dir="rtl">
 <li><strong>إسم الدالة</strong>.</li>
 <li>قائمة <strong>بارامترات</strong> الدالة، محصورة بين قوسين ويفصل بينها بفواصل.</li>
 <li>تعليمات الجافاسكريبت التي تُعرف الدالة، داخل <strong>الأقواس </strong>المتعرجة {}.</li>
</ul>

<p dir="rtl">على سبيل المثال، الكود التالي يعرف دالة بسيطة تسمى <code>square</code> :</p>

<pre class="brush: js">function square(number) {
  return number * number;
}
</pre>

<p dir="rtl">الدالة <code>square</code> تمتلك بارامتر واحد، هو <code>number</code>. وتعليمة برمجية واحدة تقوم بإرجاع بارامتر الدالة <code>number</code> مضروباً في نفسه. والتعليمة <a href="https://developer.mozilla.org/ar/docs/Web/JavaScript/Reference/Statements/return">return </a>تحدد القيمة التي سترجعها الدالة.</p>

<pre class="brush: js">return number * number;
</pre>

<p dir="rtl">يتم تمرير البارامترات الاولية <a class="glossaryLink" href="https://developer.mozilla.org/ar/docs/Web/JavaScript/Guide/Grammar_and_types#%D9%87%D9%8A%D8%A7%D9%83%D9%84_%D8%A7%D9%84%D8%A8%D9%8A%D8%A7%D9%86%D8%A7%D8%AA_%D9%88%D8%A7%D9%84%D8%A3%D9%86%D9%88%D8%A7%D8%B9_-_Data_structures_and_types" title="primitives: A primitive (primitive value, primitive data type) is data that is not an object and has no methods. In JavaScript, there are 6 primitive data types: string, number, boolean, null, undefined, symbol (new in ECMAScript 2015).">primitives</a> <code>(</code>كالسلاسل الحرفية، الاعداد...الخ<code>)</code> الى الدالة، بوسيلة تسمى، <strong>الاستدعاء بالقيمة</strong>، <a class="external external-icon" href="https://en.wikipedia.org/wiki/Evaluation_strategy#Call_by_value"> call by value </a> وهي، ان يتم تحليل <strong><code>argument</code></strong> الدالة، والقيمة الناتجة سَتُرسل <strong>نسخة</strong> منها فقط إلى المتغير المستقبل (بارامتر الدالة)، بعد ذالك تقوم الدالة بتخزين هذه القيمة في الذاكرة، ثم، إذا كانت الدالة قادرة على تعيين القيم للبارامترات الخاصة بها، تبدا بالعمل على هذه النسخة فقط، دون <strong>تغيير</strong> اي شئ في قيمة المتغير الاصلي.</p>

<p dir="rtl">في المثال التالي، لدينا المتغير <code>value</code> سنقوم بتمريره إلى الدالة square. ثم ضمن الدالة square سيتم إنشاء نسخة جديدة، وهكذا، حتى وان قمنا بتغيير القيمة داخل الدالة، فلن يؤثر هذا على قيمة المتغير الأصلي الذي تم تعريفه خارج الدالة. لان هذا التغيير لن يكون مرئيا خارج الدالة:</p>

<pre class="brush: js">function square(number) { // parameter = recipient
  return number * number;
}
var value = 10;
square(value);   // argument = Sender
document.write(value);  // log: 10
</pre>

<p dir="rtl">على عكس المثال السابق، اذا قمت بتمرير كائن (مثلا، قيمة غير اولية ك {{jsxref("Array")}} او كائن معرف من قبل المستخدم) كبارامتر، وقامت الدالة بتغيير خصائص الكائن، سيكون هذا التغيير مرئيا خارج الدالة:</p>

<pre class="brush: js">function myFunc(theObject) {
  theObject.make = "Toyota";
}

var mycar = {make: "Honda", model: "Accord", year: 1998};
var x, y;

x = mycar.make; // x gets the value "Honda"

myFunc(mycar);
y = mycar.make; // y gets the value "Toyota"
                // (the make property was changed by the function)
</pre>

<h3 dir="rtl" id="الاعلان_عن_الدوال_بصيغة_ال_Function_expressions">الاعلان عن الدوال بصيغة ال Function expressions</h3>

<p dir="rtl">في حين ان الدالة اعلاه تم الاعلان عنها بصيغة  <strong><code>function declaration</code></strong>، يمكن ايضا انشاء الدوال بصيغة ال <strong><code>function expression</code></strong>. كما يمكن ايضا للدوال ان تكون بصيغة ال <code><strong>anonymous</strong></code> (دوال مجهولة الاسم). على سبيل المثال، الدالة <code>square</code> يمكن تعريفها ايضا بصيغة ال <strong><code>function expression</code></strong> على النحو التالى:</p>

<pre class="brush: js">var square = function(number) { return number * number };
var x = square(4) // x gets the value 16</pre>

<p dir="rtl">يمكن تعيين اسم للدوال بصيغة ال <code>function expression</code>، لجعل الدالة تعيد استدعاء ذاتها (الاستدعاء الداتي)، أو استخدامه في المنقح <a href="/en-US/docs/Web/JavaScript/Reference/Statements/debugger">debugger</a>. او لتعقب اخطاء الدالة من خلال <a class="external external-icon" href="https://en.wikipedia.org/wiki/Stack_trace"> stack traces</a>.</p>

<pre class="brush: js">var factorial = function fac(n) { return n&lt;2 ? 1 : n*fac(n-1) };

console.log(factorial(3));
</pre>

<p dir="rtl">يمكنك تمرير دالة كبارامتر لدالة اخرى. يظهر المثال التالي الدالة <code>map</code> تستخدم دالة اخرى كبارامتر اول لها :</p>

<pre class="brush: js">function map(f,a) {
  var result = [], // Create a new Array
      i;
  for (i = 0; i != a.length; i++)
    result[i] = f(a[i]);
  return result;
}
</pre>

<p dir="rtl">طريقة استخدامها مع الصيغة <strong><code>function expression:</code></strong></p>

<pre class="brush: js">var multiply = function(x) { return x * x * x; };
map(multiply, [0, 1, 2, 5, 10]);
</pre>

<p dir="rtl">طريقة استخدامها مع الصيغة <code><strong>anonymous function</strong></code> مباشرة:</p>

<pre class="brush: js">map(function(x) {return x * x * x}, [0, 1, 2, 5, 10]);
</pre>

<p><code>returns [0, 1, 8, 125, 1000].</code></p>

<p dir="rtl">في الجافاسكريبت يمكن الاعلان عن دالة اعتمادا على شرط. على سبيل المثال، ستقوم التعليمة البرمجية التالية بالاعلان عن الدالة <code>myFunc</code> شرط ان يكون  <code>num</code> يساوي 0:</p>

<pre class="brush: js">var myFunc;
if (num === 0){
  myFunc = function(theObject) {
    theObject.make = "Toyota"
  }
}</pre>

<p dir="rtl">بالإضافة إلى انشاء الدوال كما هو موضح اعلاه، يمكنك ايضا استخدام الصيغة {{jsxref("Function")}} <strong><code>constructor</code></strong> لانشاء دوال من خلال السلاسل النصية، تنفذ وقت التشغيل، تماما كما في  {{jsxref("eval", "()eval")}}.</p>

<p dir="rtl">هناك فرق بين الدوال (<strong><code>functions</code></strong>) والوظائف (<strong><code>methods</code></strong>)، الدوال هي ما نناقشه في هذا الفصل، والوظائف هي تلك المرتبطة بالكائنات (قيمة لخاصية في الكائن)، اقرأ المزيد حول الكائنات والوظائف <a href="/ar/docs/Web/JavaScript/Guide/Working_with_Objects" title="en-US/docs/JavaScript/Guide/Working with Objects">العمل مع الكائنات <sub>[عربي]</sub></a>.</p>

<h2 dir="rtl" id="إستدعاء_الدوال">إستدعاء الدوال</h2>

<p dir="rtl">تعريف الدالة يعني ببساطة إعطاء إسم لها وتحديد ماستقوم به عندما يتم إستدعائها. أما إستدعاء الدالة فيقوم فعليا بتنفيذ الإجراءات مع البرامترات المحددة. على سبيل المثال، إذا قمت بتعريف الدالة square، فستقوم بإستدعائها كما يلي :</p>

<pre class="brush: js">square(5);
</pre>

<p dir="rtl">تقوم التعليمة البرمجية اعلاه باستدعاء الدالة مع البارامتر 5. ثم تقوم بتنفيذ التعليمات البرمجية المرتبطة بها وترجع القيمة 25.</p>

<p dir="rtl">الدوال يجب ان تنتمي للنطاق الذي استدعيت فيه، ولان الدوال بصيغة <strong><code>function declaration</code></strong> ترفع اعلى النطاق، فمن الممكن أن تعرف في وقت لاحق، كما في المثال التالي:</p>

<pre class="brush: js">console.log(square(5));
/* ... */
function square(n) { return n*n }
</pre>

<p dir="rtl">نطاق الدالة هو اما الدالة التي تم الإعلان عنها، أو البرنامج بأكمله إذا تم الاعلان عنها في المستوى العلوي.</p>

<div class="note">
<p dir="rtl"><strong>ملاحظة:</strong> سيعمل هذا فقط عندما يتم تعريف الدالة باستخدام الصيغة (مثل <code>{}</code><code>()function funcName</code>). اما التعليمة البرمجية التالية فسوف لن تعمل، وهذا يعني ان الية الرفع (hoisting) بالنسبة للدوال تعمل فقط مع الدوال ذات الصيغة function declaration ولا تعمل مع الدوال ذات الصيغة function expression.</p>
</div>

<pre class="brush: js example-bad">console.log(square); // square is hoisted with an initial value undefined.
console.log(square(5)); // TypeError: square is not a function
var square = function(n) {
  return n * n;
}
</pre>

<p dir="rtl"><code>arguments</code> الدالة لا تقتصر على الاعداد او السلاسل الحرفية فقط، يمكنك تمرير الكائنات ايضا. في القسم الخاص بالعمل مع الكائنات <a href="/ar/docs/Web/JavaScript/Guide/Working_with_Objects#استخدام_this_كمرجع_للكائنات" title="https://developer.mozilla.org/en-US/docs/JavaScript/Guide/Working_with_Objects#Objects_and_Properties">العمل مع الكائنات</a><a href="/ar/docs/Web/JavaScript/Guide/Working_with_Objects" title="en-US/docs/JavaScript/Guide/Working with Objects"><sub>[عربي]</sub></a> توجد دالة باسم <code>()</code><code>showProps</code> توضح كيفية تمرير <strong>كائن</strong> ك <code>argument</code> للدالة.</p>

<p dir="rtl">يمكن للدالة أن تقوم بإستدعاء ذاتها. على سبيل المثال، هذه الدالة تقوم بحساب المضروب بشكل متكرر :</p>

<pre class="brush: js">function factorial(n){
  if ((n === 0) || (n === 1))
    return 1;
  else
    return (n * factorial(n - 1));
}
</pre>

<p dir="rtl">في كل مرة تقوم الدالة باستدعاء ذاتها، يتم خصم 1 من قيمة البرامتر الممرر، ويتم ضرب القيمة المحصلة في القيمة العائدة من جديد، فرضا، اذا كانت القيمة الممررة 5، الاستدعاء الاول سيكون 5، الاستدعاء الثاني سيكون 4، الاستدعاء الثالث سيكون 3، وهكذا، ويتم ضرب هذه القيم العائدة مع بعضها البعض. بهذا الشكل :  5 * 4 * 3 * 2 * 1 == 120</p>

<p dir="rtl">امثلة متنوعة:</p>

<pre class="brush: js">var a, b, c, d, e;
a = factorial(1); // a gets the value 1    // 1 * 1
b = factorial(2); // b gets the value 2    // 2 * 1
c = factorial(3); // c gets the value 6    // 3 * 2 * 1
d = factorial(4); // d gets the value 24   // 4 * 3 * 2 * 1
e = factorial(5); // e gets the value 120  // 5 * 4 * 3 * 2 * 1
</pre>

<p dir="rtl">هناك طرق أخرى لاستدعاء الدوال. غالبا ما تكون هناك حالات تحتاج الى دالة تُستدعى بشكل ديناميكي، حيث يمكن التعامل مع مجموعة من ال <code>arguments</code>، وحيث سياق <strong><code>(context)</code></strong> استدعاء الدالة يجب ان ينشا في وظيفة لكائن يحدد وقت التشغيل. وهذا يبين ان الدوال هي نفسها كائنات، وهذه الكائنات بدورها لديها وظائف ( شاهد {{jsxref("Function")}} object). من ضمن هذه الوظائف، الوظيفة {{jsxref("Function.apply", "()apply")}} يمكن استخدامها لتحقيق هذه الاهداف.</p>

<h2 class="deki-transform" dir="rtl" id="نطاق_الدالة">نطاق الدالة</h2>

<p dir="rtl">المتغيرات المعرفة داخل الدالة لايمكن الوصول إليها من أي مكان آخر خارج الدالة، لأن هذه المتغيرات معرفة فقط داخل نطاق الدالة. على كل، يمكن للدالة الوصول إلى كل المتغيرات والدوال المعرفة في النطاق المعرفة فيه الدالة. بعبارة أخرى، الدالة المعرفة في النطاق العام تستطيع الوصول إلى كل المتغيرات المعرفة في النطاق العام. الدالة المعرفة داخل دالة أخرى يمكنها أيضا الوصول إلى كل المتغيرات المعرفة في دالتها الأم وكل المتغيرات الأخرى التي يمكن للدالة الأم الوصول لها.</p>

<pre class="brush: js">// المتغيرات التالية معرفة في النطاق العام
var num1 = 20,
    num2 = 3,
    name = "Chamahk";

// هذه الدالة معرفة في النطاق العام
function multiply() {
  return num1 * num2;
}

multiply(); // Returns 60

// مثال على دالة داخل دالة
function getScore () {
  var num1 = 2,
      num2 = 3;

  function add() {
    return name + " scored " + (num1 + num2);
  }

  return add();
}

getScore(); // Returns "Chamahk scored 5"
</pre>

<h2 dir="rtl" id="النطاق_ومكدس_الدوال">النطاق ومكدس الدوال</h2>

<h3 dir="rtl" id="الاستدعاء_الذاتي">الاستدعاء الذاتي</h3>

<p dir="rtl">يمكن للدالة ان تستدعي داتها بثلاثة طرق:</p>

<ol dir="rtl">
 <li>من خلال اسم الدالة</li>
 <li><code><a href="/en-US/docs/Web/JavaScript/Reference/Functions/arguments/callee">arguments.callee</a></code></li>
 <li>من خلال المتغيرات التي تشير إلى الدالة</li>
</ol>

<p dir="rtl">على سبيل المثال، انظر الدالة التالية:</p>

<pre class="brush: js">var foo = function bar() {
   // statements go here
};
</pre>

<p dir="rtl">تضمين الاستدعاء الذاتي داخل جسم الدالة <strong><code>bar</code></strong>:</p>

<ol>
 <li><code>()bar</code></li>
 <li><code>()arguments.callee</code></li>
 <li><code>()foo</code></li>
</ol>

<p dir="rtl">الدوال التي تقوم باستدعاء نفسها تسمى <em>recursive function</em>. الاستدعاء الداتي يشبه آلِية الحلقات في بعض النواحي، كلاهما ينفذان التعليمات البرمجية نفسها عدة مرات، وايضا كلاهما يتطلبان تعبيرا شرطيا (لتجنب التكرار الى ما لا نهاية، او بالاحرى، الاستدعاء الذاتي الى ما لا نهاية في حالتنا هذه). على سبيل المثال، الحلقة التالية:</p>

<pre class="brush: js">var x = 0;
while (x &lt; 10) { // "x &lt; 10" is the loop condition
   // do stuff
   x++;
}
</pre>

<p dir="rtl">المثال التالي يبين دالة تقوم بالاستدعاء الذاتي، يمكنها محاكات الحلقة :</p>

<pre class="brush: js">function loop(x) {
  if (x &gt;= 10) // "x &gt;= 10" is the exit condition (equivalent to "!(x &lt; 10)")
    return;
  // do stuff
  loop(x + 1); // the recursive call
}
loop(0);
</pre>

<p dir="rtl">ومع ذلك، لا يمكن أن تكون بعض الخوارزميات حلقات تكرارية بسيطة. على سبيل المثال، الوصول الى كافة العقد <code>nodes</code> في بنية الشجرة <code><a href="/en-US/docs/DOM">DOM</a></code> سيكون اسهل واكثر تفصيلا باستخدام الاستدعاء الذاتي:</p>

<pre class="brush: js">function walkTree(node) {
  if (node == null) //
    return;
  // do something with node
  for (var i = 0; i &lt; node.childNodes.length; i++) {
    walkTree(node.childNodes[i]);
  }
}
</pre>

<p dir="rtl">على عكس الحلقات التكرارية البسيطة، والتي تقوم بالتكرار السطحي على <code><a href="/en-US/docs/DOM">DOM</a></code>، تمكننا دوال الاستدعاء الداتي من تنفيذ عدة استدعاءات، كل استدعاء داتي ينتج عنه العديد من الاستدعاءات الفرعية، بمعنى ان هذا النوع من الدوال يمكنها الوصول الى عمق ال <code><a href="/en-US/docs/DOM">DOM</a></code>. لتتيح لك امكانية التعامل مع كل جزئية فيه. كما يوضح المثال التالي:</p>

<pre class="brush: js">var walkTree = function recycle( node, fn ) {
	fn( node );
	node = node .firstChild;
	while( node ){
		recycle( node, fn );
		node = node.nextSibling;
	}
}

walkTree( document.body , function( node ){
	if( node.nodeType == 1 ){
		// do something with [object HTMLElements]
	}
	if( node.nodeType == 3 ){
		// do something with [object Text]
	}
});
</pre>

<p dir="rtl">كلا الدالتين اعلاه، تؤدي نفس الغرض، لا اختلاف بينهما، الفرق الوحيد هو شكل بناء الدالة، حيث بنيت الدالة الاولى على طريقة ال  <strong><code>function declaration</code></strong>  فيما بنيت الدالة الثانية على شكل، ال  <strong><code>function expression</code></strong>  وال  <strong><code>anonymous function</code></strong>، وكلاهما تنتهج اسلوب <em>recursive function.</em></p>

<p dir="rtl">من الناحية النظرية، من الممكن تحويل أي خوارزمية الاستدعاء الذاتي الى خوارزمية الاستدعاء العادي (مع الحلقات، على سبيل المثال). عموما، المنطق الناتج أكثر تعقيداً ويتطلب استخدام  <a class="external external-icon" href="https://ar.wikipedia.org/wiki/%D9%85%D9%83%D8%AF%D8%B3_(%D8%A8%D9%86%D9%8A%D8%A9_%D8%A8%D9%8A%D8%A7%D9%86%D8%A7%D8%AA)">المكدس</a>. الاستدعاء الذاتي أيضا يستخدم المكدس، مكدس الدالة function <code>stack</code>.</p>

<p dir="rtl">سلوك مكدس الذاكرة المؤقتة يمكن أن ينظر إليه كما في المثال التالي:</p>

<pre class="brush: js">function foo(i) {
  if (i &lt; 0)
    return;
  console.log('begin:' + i);
  foo(i - 1);
  console.log('end:' + i);
}
foo(3);

// Output:

// begin:3
// begin:2
// begin:1
// begin:0
// end:0
// end:1
// end:2
// end:3</pre>

<h3 dir="rtl" id="الدوال_المتداخلة_و_الاغلاق_(closures)">الدوال المتداخلة  و الاغلاق (closures)</h3>

<p dir="rtl">يمكن انشاء دالة داخل دالة اخرى. الدالة الداخلية هي دالة خاصة <strong><code>private</code></strong> بالدالة الخارجة. الدالة الداخلية تشكل الاغلاق <strong><code>closure</code></strong>، والإغلاق هو فقط تعبير (عموما الاغلاق هو دالة). والذي يمكنه الوصول إلى المتغيرات المجانية free variables (المصطلح free variable يشير الى المتغيرات المستخدمة في الدالة، وهي ليست متغيرات محلية او بارامترات لهذه الدالة. بمعنى اخر هي متغيرات معرفة خارج الدالة وتستفيد منها الدالة، وهذا هو سبب تسميتها بالمتغيرات المجانية)،  كما يمكنه ايضا، الوصول الى اي شئ في البيئة التي ترتبط بها هذه المتغيرات المجانية.</p>

<p dir="rtl">بما ان الدالة الداخلية هي <code>closure</code>. فهذا يعني انها تستطيع ان ترث البرامترات والمتغيرات من الدالة الخارجية. بمعنى اخر، الدالة الداخلية تمتلك النطاق الخاص بالدالة الخارجية.</p>

<p dir="rtl">الخلاصة:</p>

<ul dir="rtl">
 <li>لايمكن الوصول إلى الدالة الداخلية الا من خلال التعليمات البرمجية الخاصة بالدالة الخارجية.</li>
 <li>الدالة الداخلية تشكل الاغلاق <strong><code>closure</code></strong>: الدالة الداخلية يمكنها استخدام البرامترات والمتغيرات الخاصة بالدالة الخارجية، فيما لا يمكن للدالة الخارجية استخدام البرامترات والمتغيرات الخاصة بالدالة الداخلية.</li>
</ul>

<p dir="rtl">يظهر المثال التالي الدوال المتداخلة:</p>

<pre class="brush: js">function addSquares(a,b) {
  function square(x) {
    return x * x;
  }
  return square(a) + square(b);
}
a = addSquares(2,3); // returns 13
b = addSquares(3,4); // returns 25
c = addSquares(4,5); // returns 41
</pre>

<p dir="rtl">بما ان الدالة الداخلية تشكل <strong><code>closure</code></strong>. فمن الضروري استدعاء الدالة الخارجية <strong>أولا،</strong> بعد ذالك يمكنك تحديد ال  <code>arguments</code> لكل منهما :</p>

<pre class="brush: js">function outside(x) {
  function inside(y) {
    return x + y;
  }
  return inside;
}
fn_inside = outside(3); // Think of it like: give me a function that adds 3 to whatever you give it
result = fn_inside(5); // returns 8

result1 = outside(3)(5); // returns 8
</pre>

<h3 dir="rtl" id="الحفاظ_على_المتغيرات">الحفاظ على المتغيرات</h3>

<p dir="rtl">في المثال اعلاه، لاحظ كيف تم الحفاظ على <strong><code>x</code></strong> عندما تم ارجاع الدالة <strong><code>inside</code></strong>. <strong>الاغلاق</strong> يحفاظ على البرامترات والمتغيرات في جميع النطاقات التي تشير إليه. مع كل استدعاء للدالة الخارجية، يمكنك تعيين <code>arguments</code> مختلفة، سيتم إنشاء إغلاق جديد مع كل استدعاء للدالة <strong><code>outside</code></strong>. يمكن تحرير الذاكرة فقط عندما يكون عائد الدلة <code>inside</code> غير متاحا.</p>

<p dir="rtl">وهذا لا يختلف عن تخزين المراجع في كائنات أخرى، ولكن غالبا ما يكون أقل وضوحاً نظراً لعدم تعيين المراجع مباشرة ولا يمكن فحصها.</p>

<h3 dir="rtl" id="الدوال_الاكثر_تداخلا">الدوال الاكثر تداخلا</h3>

<p dir="rtl">الدوال يمكن ان تكون اكثر تداخلا، بمعنى، الدالة <code>(A)</code> تحتضن الدالة <code>(B)</code>، والدالة <code>(B)</code> تحتضن الدالة <code>(C)</code>. هنا كل من الدالة <code>B و C</code> تشكل <strong><code>closures</code></strong>، وهكذا <code>B</code> يمكنها الوصول الى  <code>A</code>، و  <code>C</code> يمكنها الوصول الى <code>B</code>. بالاضافة الى ذالك، <code>C</code> يمكنها الوصول الى <code>B و A</code>، وبالتالي، الإغلاق يمكن أن يحتوي على عدة نطاقات. وهذا ما يسمى بسلسلة النطاق <em>scope chaining</em>. (سيتم شرح لماذا يطلق عليه "<code>تسلسل</code>" في وقت لاحق).</p>

<p dir="rtl">انظر في المثال التالي:</p>

<pre class="brush: js">function A(x) {
  function B(y) {
    function C(z) {
      console.log(x + y + z);
    }
    C(3);
  }
  B(2);
}
A(1); // logs 6 (1 + 2 + 3)
</pre>

<p dir="rtl">في هذا المثال <code>C</code> تصل الى <strong><code>y</code></strong> الخاصة ب <code>B</code> وايضا الى <strong><code>x</code></strong> الخاصة ب <code>A</code>، أصبح هذا ممكناً لأن:</p>

<ol dir="rtl">
 <li><code>B</code> تشكل closure، وتمتلك <code>A</code>، بمعنى <code>B</code> يمكنها الوصول الى البارامترات والمتغيرات الخاصة ب <code>A</code>.</li>
 <li><code>C</code> تشكل <strong><code>closure</code></strong>، وتمتلك <code>B</code>.</li>
 <li>بسبب ان <code>B</code> تمتلك <code>A</code>، فقد اصبح <code>C</code> يمتلك <code>A</code>، وعليه ف <code>C</code> يمكنه الوصول الى البارامترات والمتغيرات الخاصة ب <code>B و A</code>. بعبارات أخرى، <code>C</code> سلسلة نطاقات ل <code>B</code> و <code>A</code> في هذا الترتيب.</li>
</ol>

<p dir="rtl">العكس ليس صحيحاً. <code>A</code> لا يمكنها الوصول الى <code>C</code>، لان <code>A</code> لا يمكنها الوصول لاي من البارامترات او المتغيرات الخاصة ب <code>B</code>. (فيما <code>C</code> هي متغير لها). وهكذا، <code>C</code> ستصبح خاصة <strong><code>private</code></strong> فقط ب <code>B</code>.</p>

<h3 dir="rtl" id="تضارب_الاسماء">تضارب الاسماء</h3>

<p dir="rtl">عند وجود اثنين من البارامترات أو المتغيرات التي تحمل نفس <strong>الاسم</strong> في نطاقات الاغلاق، فهذا يسمى <strong>تضارب في الاسماء</strong>، وفي هذه الحالة، ستكون الاسبقية للنطاقات الاكثر عمقا في استخدام هذا <strong>الاسم</strong>، اما بالنسبة للنطاقات الأكثر سطحية سوف تحظى بأولوية أدنى لاستخدام هذا الاسم، من وجهة نظر سلسلة النطاق، النطاق الاول في السلسلة هو النطاق الاكثر عمقا ( اسفل السلسلة)، والنطاق الاخير في السلسلة هو النطاق الاكثر سطحية (اعلى السلسلة). شاهد المثال التالي:</p>

<pre class="brush: js">function outside() {
  var x = 10;
  function inside(x) {
    return x;
  }
  return inside;
}
result = outside()(20); // returns 20 instead of 10
</pre>

<p dir="rtl">يحدث تعارض الاسم  في التعليمة <strong><code>return</code></strong> <strong><code>x</code></strong>، وهو مابين الباراميتر <strong><code>x</code></strong> الخاص ب <strong><code>inside</code></strong> وبين المتغير <strong><code>x</code></strong> الخاص ب <strong><code>outside</code></strong>. سلسلة النطاق سترى الامر على هذا النحو <strong><code>{inside, outside, global object}</code></strong>. وبناءا عليه <strong><code>x</code></strong> الخاص ب <strong><code>inside</code></strong> سياخد الاسبقية على <strong><code>x</code></strong> الخاص ب <strong><code>outside</code></strong>، وبالتالي الناتج هو 20 (inside x) بدلا من 10 (outside x).</p>

<h2 dir="rtl" id="الاغلاقات_-_Closures">الاغلاقات - Closures</h2>

<p dir="rtl">الإغلاق هي واحدة من أقوى المميزات في جافا سكريبت. جافا سكريبت تسمح بتداخل الوظائف وتمنح الدوال الداخلية حق الوصول الكامل إلى كافة المتغيرات والدوال المعرفة داخل الدالة الخارجية (وجميع المتغيرات والدوال الأخرى التي يمكن للدالة الخارجية الوصول إليها). ومع ذالك، الدوال الخارجية لا يمكنها الوصول الى المتغيرات والدوال المعرفة داخل الدوال الداخلية. وهذا يوفر نوعا من الحماية للمتغيرات والدوال الداخلية. وأيضا، لأن الدوال الداخلية لديها حق الوصول إلى نطاق الدالة الخارجية، فالمتغيرات والدوال المعرفة داخل الدالة الخارجية ستدوم اطول من مدة تنفيذ الدالة الخارجىة، اذا تمكنت الدالة الداخلية ان تدوم أطول من الدالة الخارجية. يتم إنشاء الاغلاق عندما تكون الدالة الداخلية بطريقة أو بأخرى في متناول أي نطاق خارج الدالة الخارجية.</p>

<pre class="brush: js">var pet = function(name) {   // The outer function defines a paramrter called "name"
  var getName = function() {
    return name;             // The inner function has access to the "name" paramrter of the outer function
  }
  return getName;            // Return the inner function, thereby exposing it to outer scopes
},
myPet = pet("Vivie");

myPet();                     // Returns "Vivie"
</pre>

<p dir="rtl">من الناحية العملية، يمكن أن تكون المسالة أكثر تعقيداً من التعليمات البرمجية أعلاه. يمكن إرجاع كائن والذي سيحتوي على وظائف للتعامل مع المتغيرات الداخلية للدالة الخارجية:</p>

<pre class="brush: js">var createPet = function(name) {
  var sex;

  return {
    setName: function(newName) {
      name = newName;
    },

    getName: function() {
      return name;
    },

    getSex: function() {
      return sex;
    },

    setSex: function(newSex) {
      if(typeof newSex === "string" &amp;&amp; (newSex.toLowerCase() === "male" || newSex.toLowerCase() === "female")) {
        sex = newSex;
      }
    }
  }
}

var pet = createPet("Vivie");
pet.getName();                  // Vivie

pet.setName("Oliver");
pet.setSex("male");
pet.getSex();                   // male
pet.getName();                  // Oliver
</pre>

<p dir="rtl">في التعليمات البرمجية اعلاه، المتغير <code>name</code> الخاص بالدالة الخارجية يمكن الوصول اليه من الدوال الداخلية. من المعلوم ايضا، انه، ليس هناك طريقة أخرى للوصول إلى المتغيرات الداخلية إلا من خلال الدوال الداخلية. المتغيرات الداخلية الخاصة بالدوال االداخلية هي بمثابة مخازن آمنة بالنسبة للبارامترات و المتغيرات الخارجية. كما انها تتيح امكانية الوصول الى البيانات الداخلية بشكل دقيق وامن. بالنسبة للدوال، ليس من الضروري تعيينها إلى متغير أو حتى تسميتها.</p>

<pre class="brush: js">var getCode = (function(){
  var secureCode = "0]Eal(eh&amp;2";    // A code we do not want outsiders to be able to modify...

  return function () {
    return secureCode;
  };
})();

getCode();    // Returns the secureCode
</pre>

<p dir="rtl">ومع ذلك، يجب الاحتراس جيدا من الوقوع في بعض الفخاخ عند استخدام عمليات الإغلاق. إذا كانت دالة مغلقة تعرف متغير بنفس الاسم، كاسم متغير في النطاق الخارجي، فلا توجد طريقة للإشارة إلى المتغير في النطاق الخارجي مرة أخرى.</p>

<pre class="brush: js">var createPet = function(name) {  // Outer function defines a variable called "name"
  return {
    setName: function(name) {    // Enclosed function also defines a variable called "name"
      name = name;               // ??? How do we access the "name" defined by the outer function ???
    }
  }
}
</pre>

<p dir="rtl">الكلمة المحجوزة <strong><code><a href="/en-US/docs/Web/JavaScript/Reference/Operators/this">this</a></code></strong> (في بعض الاحيان تسمى بالمتغير العجيب)، ينبغي التعامل معها بحذر في حالات <strong>الإغلاق</strong>. احذر، ف <code>this</code> تشير إلى السياق حيث سيتم استدعاء الدالة وليس إلى المكان حيث تم تعريف الدالة.</p>

<h2 dir="rtl" id="استخدام_الكائن_arguments">استخدام الكائن arguments</h2>

<p dir="rtl">يمكنك التعامل مع  <code>arguments</code> الدالة من الداخل، من خلال الكائن <strong><code>(arguments او الحجج</code></strong>). يمكنك معالجة ال  <code>arguments</code> الممررة الى الدالة على النحو التالي:</p>

<pre class="brush: js">arguments[i]
</pre>

<p dir="rtl">حيث ان <strong><code>i</code></strong> هو الفهرس الرقمي لل <code>arguments</code>، ويبتدئ من <strong><code>0</code></strong>، وبالتالي، ال <code>argument</code> الاول الممرر الى الدالة سيكون <strong><code>arguments[0]</code></strong>. لمعرفة عدد ال <code>argument</code><strong><code>s</code></strong> الممررة نستخدم <strong><code>arguments.length</code></strong>.</p>

<p dir="rtl">باستخدام الكائن <strong><code>arguments</code></strong>، يمكنك استدعاء دالة مع <code>arguments</code> أكثر من التي تم التصريح بها رسميا. وهي مفيذة جدا، خصوصا إذا كنت لا تعرف مسبقاً كم عدد ال  <code>arguments</code> التي ستمرر اثناء استدعاء الدالة. يمكنك استخدام <code>arguments.length</code> لمعرفة عدد البرامترات الممرة الى الدالة، حتى تتمكن بعد ذالك من التعامل معها من خلال الكائن <strong><code>arguments</code></strong>.</p>

<p dir="rtl">على سبيل المثال، يمكننا انشاء دالة تقوم بوصل عدة سلاسل حرفية. ال <code>argument</code> الوحيد المحدد رسميا في الدالة، هو السلسلة الحرفية التي ستفصل بين باقي السلاسل الحرفية التي ستمرر ك <code>arguments</code> بعد ال <code>argument</code> الرسمي للدالة.  كما في المثال التالي:</p>

<pre class="brush: js">function myConcat(separator) {
   var result = "", // initialize list
       i;
   // iterate through arguments
   for (i = 1; i &lt; arguments.length; i++) {
      result += arguments[i] + separator;
   }
   return result;
}
</pre>

<p dir="rtl">يمكنك تمرير اي عدد من ال <code>arguments</code> لهذه الدالة، وسترتبط ببعضها البعض من خلال ما سيمرر الى ال <code>argument</code> الرسمي:</p>

<pre class="brush: js">// returns "red, orange, blue, "
myConcat(", ", "red", "orange", "blue");

// returns "elephant; giraffe; lion; cheetah; "
myConcat("; ", "elephant", "giraffe", "lion", "cheetah");

// returns "sage. basil. oregano. pepper. parsley. "
myConcat(". ", "sage", "basil", "oregano", "pepper", "parsley");
</pre>

<div class="note">
<p dir="rtl"><strong>ملاحظة:</strong> المتغير arguments هو شبه مصفوفة، ولكنه ليس مصفوفة. وانما يتصرف كالمصفوفة، يستخدم الفهرسة الرقمية، يستخدم الخاصية length، ومع ذالك، لا يمكنه استخدام الوظائف الخاصة بالمصفوفات مثل push او join ...الخ.</p>
</div>

<h4 dir="rtl" id="الفرق_بين_parameters_و_arguments">الفرق بين parameters و arguments</h4>

<p dir="rtl"><strong><code>Function parameters</code></strong> او بارامترات الدالة، هي الأسماء المدرجة في تعريف الدالة. فيما <strong><code>Function arguments</code></strong> هي القيم الحقيقية التي تمرر إلى الدالة عند الاستدعاء <code>(</code>راجع التعريف والاستدعاء اعلى الصفحة<code>)</code>. انظر المثال التالي:</p>

<pre class="brush: js">function foo( param1, param2, ...) // parameters {
    // Do things
}
foo(arg1, arg2, ...); // arguments
</pre>

<div class="note">
<p dir="rtl"><strong>ملاحظة:</strong> ال<strong> <code><a href="/en-US/docs/Glossary/Parameter">parameter</a></code></strong> هو متغير باسم معين يمرر الى الدالة. تستخدم الباراميترات لجلب ال <strong><code><a href="/en-US/docs/Web/JavaScript/Reference/Functions/arguments">arguments</a></code></strong> داخل الدوال.</p>
</div>

<p dir="rtl">راجع الكائن {{jsxref("Function")}} في مرجع الجافا سكريبت لمزيد من المعلومات.</p>

<h2 dir="rtl" id="بارامترات_الدالة">بارامترات الدالة</h2>

<p dir="rtl">بدأً من ECMAScript 6، أصبح هناك نوعان من البارامترات: البارامترات الإفتراضية وبقية البارامترات.</p>

<h3 dir="rtl" id="البارامترات_الإفتراضية">البارامترات الإفتراضية</h3>

<p dir="rtl">في الجافاسكريبت، القيمة الافتراضية لبرامترات الدوال هي <code>undefined</code>. ومع ذالك، في بعض الحالات، قد يكون من المفيد تعيين قيمة افتراضية مختلفة. البارامترات الافتراضية يمكنها تدارك الموقف.</p>

<p dir="rtl">قبل ECMAScript 2015، كانت الاستراتيجية العامة لوضع الافتراضات هي اختبار قيمة البارامتر في جسم الدالة وتعيين قيمة له اذا كانت قيمته <code>undefined</code>. على سبيل المثال، في التعليمة البرمجية التالية، لم يتم تحديد قيمة للبارامتر <strong><code>b</code></strong> في الاستدعاء، وبالتالي قيمتة ستساوي <code>undefined</code>، عند اختبار <code>(a * b)</code> ستعود الدالة <strong><code>multiply</code></strong> ب <code>NaN</code>. لتجنب هذا،  يقوم السطر الثاني في التعليمة البرمجية اسفله بتعيين قيمة افتراضية للبارامتر <strong><code>b</code></strong>:</p>

<pre class="brush: js">function multiply(a, b) {
  b = typeof b !== 'undefined' ?  b : 1;

  return a*b;
}

multiply(5); // 5
</pre>

<p dir="rtl">ابتداءا من ECMAScript 2015، اصبح من الممكن عمل اعدادات افتراضية على غرار <code>(php)</code>، والاختبار في جسم الدالة لم يعد ضروريا. الان، ببساطة يمكنك تعيين <strong><code>1</code></strong> كقيمة افتراضية للبارامتر <strong><code>b</code></strong> في تعريف الدالة:</p>

<pre class="brush: js">function multiply(a, b = 1) {
  return a*b;
}

multiply(5); // 5</pre>

<p dir="rtl">لمزيد من التفاصيل، راجع  <a href="/en-US/docs/Web/JavaScript/Reference/Functions/Default_parameters">default parameters</a> في مرجع الجافاسكريبت.</p>

<h3 dir="rtl" id="بقية_البارامترات_-_rest_parameter">بقية البارامترات - rest parameter</h3>

<p dir="rtl">الصيغة <a href="/en-US/docs/Web/JavaScript/Reference/Functions/rest_parameters">rest parameter</a> تسمح بتمثيل عدد غير محدود من ال <code>arguments</code> كمصفوفة. في هذا المثال، نستخدم بقية البارامترات لتجميع ال <code>arguments</code> ابتداءا من البرامتر الثاني لغاية النهاية. ثم نقوم بضربها باول بارامتر. هذا المثال يستخدم دالة السهم، والتي سندرسها في القسم التالي.</p>

<pre class="brush: js">function multiply(multiplier, ...theArgs) {
  return theArgs.map(x =&gt; multiplier * x);
}

var arr = multiply(2, 1, 2, 3);
console.log(arr); // [2, 4, 6]</pre>

<h2 dir="rtl" id="دوال_السهم_-_Arrow_functions">دوال السهم - Arrow functions</h2>

<p dir="rtl"><a href="/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions">تعبيرات دوال السهم </a>تسمح لك باستخدام تعبيرا أكثر إيجازاً من التعبير عن الوظائف الكلاسيكية. والقيمة <code>this</code> يتم ربطها بشكل نحوي. فيما تكون دوال السهم مجهولة الاسم <code>anonymous</code>. راجع ايضا هذه المدونة  <a href="https://hacks.mozilla.org/2015/06/es6-in-depth-arrow-functions/">ES6 In Depth: Arrow functions</a>.</p>

<p dir="rtl">اثنين من العوامل التي أثرت في مقدمة دوال السهم: الدوال المختصرة و lexical <code>this</code>.</p>

<h3 dir="rtl" id="الدوال_المختصرة">الدوال المختصرة</h3>

<p dir="rtl">في بعض الأنماط الوظيفية، الدوال المختصرة هي موضع ترحيب. قارن التعليمات البرمجية التالية:</p>

<pre class="brush: js">var a = [
  "Hydrogen",
  "Helium",
  "Lithium",
  "Beryl­lium"
];

var a2 = a.map(function(s){ return s.length });

var a3 = a.map( s =&gt; s.length );</pre>

<h3 dir="rtl" id="التعليمة_Lexical_this"><code>التعليمة </code> Lexical <code>this</code></h3>

<p dir="rtl">قبل وجود وظائف السهم، كانت كل دالة جديدة تعرف قيمة ال <code>this</code> الخاصة بها (كائن جديد في حالة الدالة الإنشائية، <code>undefined</code> في استدعاءات الدوال مع الوضع الصارم، في سياق الكائن قيد التشغيل في حالة الوظيفة، إلخ.). وهذا يمكن أن يسبب بعض المشاكل مع نمط البرمجة الكائنية:</p>

<pre class="brush: js">function Person() {
  // The Person() constructor defines 'this' as itself.
  this.age = 0;

  setInterval(function growUp() {
    // In nonstrict mode, the growUp() function defines 'this'
    // as the global object, which is different from the 'this'
    // defined by the Person() constructor.
  this.age++;
  }, 1000);
}
var p = new Person();</pre>

<p dir="rtl">في ECMAScript 3/5، تم إصلاح هذه المشكلة عن طريق تخزير القيمة <code>this</code> في متغير اخر.</p>

<pre class="brush: js">function Person() {
  var self = this; // Some choose `that` instead of `self`.
                   // Choose one and be consistent.
  self.age = 0;

  setInterval(function growUp() {
    // The callback refers to the `self` variable of which
    // the value is the expected object.
    self.age++;
  }, 1000);
}</pre>

<p dir="rtl">بدلا من ذلك، يمكننا إنشاء دالة ملزمة <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind">bound function</a> بحيث تكون "احسن"  قيمة <code>this</code> سيتم تمريرها إلى الدالة <code>()growUp</code>.</p>

<p dir="rtl">دوال السهم تلتقط القيمة this من السياق المغلق (enclosing context)، لذا ستعمل التعليمة البرمجية التالية كما هو متوقع.</p>

<pre class="brush: js">function Person(){
  this.age = 0;

  setInterval(() =&gt; {
    this.age++; // |this| properly refers to the person object
  }, 1000);
}

var p = new Person();</pre>

<h2 dir="rtl" id="دوال_معرفة_مسبقا">دوال معرفة مسبقا</h2>

<p dir="rtl">جافا سكريبت لديها العديد من الوظائف المدمجة ذات المستوى الاعلى top-level :</p>

<dl>
 <dt>{{jsxref("Global_Objects/eval", "()eval")}}</dt>
 <dd>
 <p dir="rtl">الوظيفة<code><strong> ()</strong></code><code><strong>eval</strong></code> تستخدم لاختبار شفرة الجافا سكريبت على شكل سلسلة حرفية.</p>
 </dd>
 <dt>{{jsxref("Global_Objects/uneval", "()uneval")}} {{non-standard_inline}}</dt>
 <dd>
 <p dir="rtl">الوظيفة<code><strong> ()</strong></code><code><strong>uneval </strong></code>تستخدم لانشاء سلسلة حرفية عبارة عن مصدر كود الكائن {{jsxref("Object")}}.</p>
 </dd>
 <dt>{{jsxref("Global_Objects/isFinite", "()isFinite")}}</dt>
 <dd>
 <p dir="rtl">الدالة العامة <code><strong>()</strong></code> <code><strong>isFinite</strong></code> تقوم بتحديد ما إذا كانت القيمة التي تم تمريرها عدد محدود. إذا لزم الأمر، يتم تحويل البارامتر إلى رقم.</p>
 </dd>
 <dt>{{jsxref("Global_Objects/isNaN", "()isNaN")}}</dt>
 <dd>
 <p dir="rtl">تستخدم الدالة<code><strong>()</strong></code><code><strong>isNaN</strong></code> للتاكد من ان القيمة ليست رقمية {{jsxref("Global_Objects/NaN", "NaN")}}  ملاحظة: يمكننا ايضا استخدام {{jsxref("Number.isNaN()")}}, الجديدة في ECMAScript 6 او استخدام التعليمة <code><a href="/en-US/docs/Web/JavaScript/Reference/Operators/typeof">typeof</a></code>. كلها تادي نفس الغرض.</p>
 </dd>
 <dt>{{jsxref("Global_Objects/parseFloat", "()parseFloat")}}</dt>
 <dd>
 <p dir="rtl">تستخدم الدالة <code><strong>()</strong></code><code><strong>parseFloat</strong></code> لتحويل سلسلة حرفية الى عدد كسري.</p>
 </dd>
 <dt>{{jsxref("Global_Objects/parseInt", "()parseInt")}}</dt>
 <dd>
 <p dir="rtl">تستخدم الدالة <code><strong>()</strong></code><code><strong>parseInt</strong></code> لتحويل سلسلة حرفية الى عدد صحيح (البارامتر الثاني خاص بالتعامل مع القاعدة في الأنظمة العددية الرياضية).</p>
 </dd>
 <dt>{{jsxref("Global_Objects/decodeURI", "()decodeURI")}}</dt>
 <dd>
 <p dir="rtl">تستخدم الدالة<code><strong> ()</strong></code><code><strong>decodeURI</strong></code> لفك تشفير معرف الموارد الموحد (Uniform Resource Identifier (URI التي تم إنشاؤها مسبقا من طرف {{jsxref("Global_Objects/encodeURI", "encodeURI")}} او عن طريق نفس الروتين.</p>
 </dd>
 <dt>{{jsxref("Global_Objects/decodeURIComponent", "()decodeURIComponent")}}</dt>
 <dd>
 <p dir="rtl">تستخدم الوظيفة<code><strong> ()</strong></code><code><strong>decodeURIComponent</strong></code> لفك تشفير معرف عناصر الموارد الموحدة (Uniform Resource Identifier (URI التي تم إنشاؤها مسبقا من طرف {{jsxref("Global_Objects/encodeURIComponent", "encodeURIComponent")}} او عن طريق نفس الروتين.</p>
 </dd>
 <dt>{{jsxref("Global_Objects/encodeURI", "()encodeURI")}}</dt>
 <dd>
 <p dir="rtl">تستخدم الوظيفة<code><strong> ()</strong></code><code><strong>encodeURI</strong></code> لتشفير معرف الموارد الموحد (Uniform Resource Identifier (URI باستبدال كل مثيل من أحرف معينة بواحد، اثنان، ثلاثة، أو أربعة تهريبات متوالية تمثل ترميز الاحرف UTF-8 (لن يكون إلا أربع تهريبات متوالية لرموز تتألف من اثنين من الحروف "البديلة").</p>
 </dd>
 <dt>{{jsxref("Global_Objects/encodeURIComponent", "()encodeURIComponent")}}</dt>
 <dd>
 <p dir="rtl">تستخدم الوظيفة <code><strong>()</strong></code><code><strong>encodeURIComponent</strong></code> لتشفير معرف عناصر الموارد الموحدة (Uniform Resource Identifier (URI باستبدال كل مثيل من أحرف معينة بواحد، اثنان، ثلاثة، أو أربعة تهريبات متوالية تمثل ترميز الاحرف UTF-8 (لن يكون إلا أربع تهريبات متوالية لاحرف تتألف من اثنين من الحروف "البديلة").</p>
 </dd>
 <dt>{{jsxref("Global_Objects/escape", "()escape")}} {{deprecated_inline}}</dt>
 <dd>
 <p dir="rtl">الوظيفة<code><strong> ()</strong></code><code><strong>escape</strong></code> الغير مرغوب فيها. تحتسب سلسلة جديدة من بعض الأحرف التي يجب استبدلها من قبل hexadecimal escape sequence. استخدم {{jsxref("Global_Objects/encodeURI", "encodeURI")}} او استخدم {{jsxref("Global_Objects/encodeURIComponent", "encodeURIComponent")}} بدلا عنها.</p>
 </dd>
 <dt>{{jsxref("Global_Objects/unescape", "()unescape")}} {{deprecated_inline}}</dt>
 <dd>
 <p dir="rtl">الوظيفة<code><strong>()</strong></code><code><strong>unescape</strong></code> الغير مرغوب فيها. تحتسب سلسلة جديدة بحيث hexadecimal escape sequence. اسبدلت مع الرمز الذي يمثلها. متتالية التهريب يمكن ان تاتى من دالة مثل {{jsxref("Global_Objects/escape", "escape")}}. على العموم استخدم {{jsxref("Global_Objects/decodeURI", "decodeURI()")}} او استخدم {{jsxref("Global_Objects/decodeURIComponent", "decodeURIComponent")}} بدلا عنها.</p>
 </dd>
</dl>

<p> </p>
</div>

<p>{{PreviousNext("Web/JavaScript/Guide/Loops_and_iteration", "Web/JavaScript/Guide/Expressions_and_Operators")}}</p>