بناء جملة جافا سكريبت

الموسوعة الحرة
مقتطف من كود JavaScript مع الكلمات الرئيسية المميزة بألوان مختلفة

بناء جملة JavaScript هو مجموعة القواعد التي تحدد برنامج JavaScript منظم بشكل صحيح .

تستخدم الأمثلة أدناه وظيفة السجل الخاصة بكائن وحدة التحكم الموجودة في معظم المتصفحات لإخراج النص القياسي .

تفتقر مكتبة JavaScript القياسية إلى وظيفة إخراج نصية قياسية رسمية (باستثناء document.write). ونظرًا لأن JavaScript يستخدم بشكل أساسي في البرمجة النصية من جانب العميل داخل متصفحات الويب الحديثة ، وأن جميع متصفحات الويب تقريبًا توفر وظيفة التنبيه، alertفيمكن أيضًا استخدام .

الأصول

قام بريندان آيش بتلخيص أصل بناء الجملة في الفقرة الأولى من مواصفات JavaScript 1.1 [1] [2] على النحو التالي:

يستعير JavaScript معظم صيغته النحوية من Java ، ولكنه يرث أيضًا من Awk و Perl ، مع بعض التأثير غير المباشر من Self في نظام النموذج الأولي للكائنات.

الأساسيات

حساسية الحالة

JavaScript حساسة لحالة الأحرف . من الشائع أن تبدأ اسم المنشئ بحرف كبير ، واسم الدالة أو المتغير بحرف صغير.

مثال: 

var a = 5 ؛ console.log ( a )؛ // 5 console.log ( A ) ؛ // يُلقي خطأ مرجعي : A غير مُعرف

المسافات البيضاء والفاصلات المنقوطة

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

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

الرموز الخمسة التي تسبب المشاكل هي الأقواس المفتوحة " ("، والأقواس المفتوحة " ["، والشرطة المائلة " /"، وعلامة الجمع " +"، وعلامة الطرح " -". ومن بين هذه الرموز، فإن الأقواس المفتوحة شائعة في نمط تعبير الوظيفة المستدعاة فورًا ، كما تظهر الأقواس المفتوحة أحيانًا، بينما تكون الرموز الأخرى نادرة جدًا. مثال: 

أ = ب + ج ( د + هـ ). فو ()    
  

// يتم التعامل معها على أنها: 
// a = b + c(d + e).foo();

مع اقتراح أن يتم إنهاء العبارة السابقة بفاصلة منقوطة.

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

أ = ب + ج ؛( د + هـ ). فو ()    
  

// يتم التعامل معها على أنها: 
// أ = ب + ج؛ 
// (د + هـ).foo();

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

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

العودة 
أ + ب ؛  

// إرجاع غير محدد. يتم التعامل معه على النحو التالي: 
// return; 
// a + b; 
// يجب كتابته على النحو التالي: 
// return a + b;

تعليقات

صيغة التعليق هي نفسها الموجودة في C++ و Swift والعديد من اللغات الأخرى. 

// تعليق قصير من سطر واحد

/* هذا تعليق طويل ومتعدد الأسطر 
  حول نصي. أتمنى أن 
  يكون رائعًا يومًا ما. */

/* التعليقات /* قد لا تكون متداخلة */ خطأ في بناء الجملة * /

المتغيرات

لا تحتوي المتغيرات في JavaScript القياسية على نوع مرتبط، لذا يمكن تخزين أي قيمة (كل قيمة لها نوع) في أي متغير. بدءًا من ES6 ، الإصدار السادس من اللغة، يمكن إعلان المتغيرات باستخدام varمتغيرات ذات نطاق وظيفة، و letأو constالتي تكون لمتغيرات مستوى الكتلة . قبل ES6، لم يكن من الممكن إعلان المتغيرات إلا باستخدام varعبارة. لا يمكن تغيير القيم المعينة للمتغيرات المعلنة باستخدام const، ولكن يمكن تغيير خصائصها. varيجب ألا تستخدم بعد الآن منذ ذلك الحين letوتدعمها constالمتصفحات الحديثة. [4] يجب أن يبدأ معرف المتغير بحرف أو شرطة سفلية ( _)، أو علامة دولار ( $)، بينما يمكن أيضًا أن تكون الأحرف اللاحقة أرقامًا ( 0-9). JavaScript حساسة لحالة الأحرف، لذا فإن الأحرف الكبيرة "A" إلى "Z" تختلف عن الأحرف الصغيرة "a" إلى "z".

بدءًا من JavaScript 1.5، يمكن استخدام ISO 8859-1 أو أحرف Unicode (أو \uXXXXتسلسلات الهروب Unicode) في المعرفات. [5] في بعض تطبيقات JavaScript، يمكن استخدام علامة (@) في المعرف، لكن هذا يتعارض مع المواصفات ولا يُدعم في التطبيقات الأحدث. [ بحاجة لمصدر ]

تحديد النطاق والرفع

المتغيرات المعلنة باستخدام varتكون ذات نطاق معجمي على مستوى الوظيفة ، بينما المتغيرات التي تحتوي على letأو constلها نطاق على مستوى الكتلة . نظرًا لأن الإعلانات تتم معالجتها قبل تنفيذ أي كود، يمكن تعيين متغير واستخدامه قبل الإعلان عنه في الكود. [6] يُشار إلى هذا باسمالرفع ، وهو يعادل المتغيرات التي يتمإعلانها للأمامفي الجزء العلوي من الوظيفة أو الكتلة.[7]

مع varعبارات letو و و const، يتم رفع الإعلان فقط؛ ولا يتم رفع التعيينات. وبالتالي فإن العبارة في منتصف الدالة تعادل عبارة إعلان في أعلى الدالة وعبارة تعيين في تلك النقطة في منتصف الدالة. وهذا يعني أنه لا يمكن الوصول إلى القيم قبل إعلانها؛ ولا يمكن الرجوع إلى الأمام . مع قيمة المتغير تكون حتى يتم تهيئتها. لا يمكن الوصول إلى المتغيرات المعلنة باستخدام أو حتى يتم تهيئتها، لذا فإن الرجوع إلى مثل هذه المتغيرات قبل ذلك سيؤدي إلى حدوث خطأ. var x = 1var xx = 1varundefinedletconst

إن إعلانات الوظائف، التي تعلن عن متغير وتعين له دالة، تشبه عبارات المتغيرات، ولكن بالإضافة إلى رفع الإعلان، فإنها ترفع التعيين أيضًا - كما لو أن العبارة بأكملها ظهرت في أعلى الدالة الحامية - وبالتالي فإن المرجع الأمامي ممكن أيضًا: لا يهم موقع عبارة الدالة داخل الدالة المحيطة. وهذا يختلف عن تعيين تعبير دالة إلى متغير في عبارة varأو letأو const.

لذلك، على سبيل المثال، 

var func = function () { .. } // يتم رفع الإعلان فقط function func () { .. } // يتم رفع الإعلان والتعيين

يمكن إنتاج نطاق الكتلة عن طريق تغليف الكتلة بأكملها في دالة ثم تنفيذها - وهذا ما يعرف بنمط تعبير الوظيفة المستدعى على الفور - أو عن طريق إعلان المتغير باستخدام letالكلمة الأساسية.

التصريح والتكليف

المتغيرات المعلنة خارج نطاق معين تكون عالمية . إذا تم إعلان متغير في نطاق أعلى، فيمكن الوصول إليه من خلال نطاقات فرعية.

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

عند تعيين معرف، يمر JavaScript بنفس العملية تمامًا لاسترداد هذا المعرف، باستثناء أنه إذا لم يتم العثور عليه في النطاق العالمي ، فسوف ينشئ "المتغير" في النطاق الذي تم إنشاؤه فيه. [8] ونتيجة لذلك، فإن المتغير الذي لم يتم إعلانه أبدًا سيكون عالميًا، إذا تم تعيينه. سيؤدي إعلان متغير (باستخدام الكلمة الأساسية var) في النطاق العالمي (أي خارج أي نص دالة (أو كتلة في حالة let/const))، أو تعيين معرف لم يتم إعلانه مطلقًا أو إضافة خاصية إلى الكائن العالمي (عادةً window ) إلى إنشاء متغير عالمي جديد أيضًا.

لاحظ أن الوضع الصارم في JavaScript يمنع تعيين متغير غير معلن، مما يتجنب تلوث مساحة الأسماء العالمية.

أمثلة

فيما يلي بعض الأمثلة على إعلانات المتغيرات ونطاقها: 

var x1 = 0 ; // متغير عالمي، لأنه ليس في أي دالة let x2 = 0 ; // متغير عالمي أيضًا، هذه المرة لأنه ليس في أي كتلة    
    

دالة f () { var z = 'foxes' , r = 'birds' ; // متغيران محليان m = 'fish' ; // عالمي، لأنه لم يتم إعلانه في أي مكان من قبل  
         
     

  دالة child () { var r = 'monkeys' ; // هذا المتغير محلي ولا يؤثر على "birds" r للدالة الأصلية. z = 'penguins' ; // الإغلاق: تتمكن الدالة الفرعية من الوصول إلى متغيرات الدالة الأصلية. }  
        
       
  

  twenty = 20 ; // يتم إعلان هذا المتغير في السطر التالي، ولكن يمكن استخدامه في أي مكان في الدالة، حتى قبل ذلك، كما هو الحال هنا var twenty ;   
   

  child (); 
return x1 + x2 ; // يمكننا استخدام x1 و x2 هنا، لأنهما عالميان }      


ف ();

console.log ( z ); // هذا السطر سوف يثير استثناء ReferenceError، لأن قيمة z لم تعد متوفرة 

بالنسبة إلى ( دع i = 0 ؛ i < 10 ؛ i ++ ) console.log ( i ) ؛ console.log( i ) ؛ // يُلقي خطأ مرجعي: i غير مُعرَّف         
 

بالنسبة إلى ( const i = 0 ؛ i < 10 ؛ i ++ ) console.log ( i )؛ // يُلقي خطأ TypeError: التعيين إلى متغير ثابت          

بالنسبة إلى ( const i من [ 1 ، 2 ، 3 ]) console.log ( i ) ؛ //لن يثير استثناءً. لا يتم إعادة تعيين i ولكن يتم إعادة إنشائه في كل تكرار      

const pi ; // يطرح خطأ في بناء الجملة: مُبدئ مفقود في إعلان const

أنواع البيانات البدائية

توفر لغة JavaScript ستة أنواع أساسية من البيانات :

  • غير محدد
  • رقم
  • بيجينت
  • خيط
  • منطقي
  • رمز

توفر بعض أنواع البيانات البدائية أيضًا مجموعة من القيم المسماة التي تمثل امتدادات حدود النوع. يتم وصف هذه القيم المسماة في الأقسام المناسبة أدناه.

غير محدد

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

ملاحظة: يعتبر النوع غير المحدد نوعًا بدائيًا أصيلًا. وما لم يتم تحويله صراحةً، فقد تتصرف القيمة غير المحددة بشكل غير متوقع مقارنةً بالأنواع الأخرى التي يتم تقييمها على أنها خطأ في سياق منطقي. 

دعونا نختبر ؛ // متغير معلن، ولكن غير معرف، ... // ... مضبوط على قيمة غير محددة const testObj = {}; console.log ( test ) ; // متغير اختبار موجود، ولكن القيمة غير محددة... // ... محدد، يعرض غير معرف console.log ( testObj.myProp ); // testObj موجود، الخاصية غير موجودة، ... // ... يعرض غير معرف console.log ( undefined == null ) ; // نوع غير مفروض أثناء الفحص ، يعرض القيمة true console.log ( undefined === null ) ; // فرض النوع أثناء الفحص، يعرض القيمة false

ملاحظة: لا يوجد حرف لغوي مدمج لـ undefined. وبالتالي، لا توجد طريقة أكيدة للتحقق مما إذا كان المتغير غير معرف، لأنه في الإصدارات التي تسبق ECMAScript 5، من القانوني لأي شخص أن يكتب . والنهج الأكثر قوة هو المقارنة باستخدام . (x === undefined)var undefined = "I'm defined now";(typeof x === 'undefined')

لن تعمل الوظائف مثل هذه بالشكل المتوقع: 

دالة isUndefined ( x ) { دع u ؛ ارجع x === u ؛ } // مثل هذا... دالة isUndefined ( x ) { ارجع x === void 0 ؛ } // ... أو تلك الثانية دالة isUndefined ( x ) { ارجع ( نوع x ) === "غير محدد" ؛ } // ... أو تلك الثالثة

هنا، يؤدي الاستدعاء isUndefined(my_var)إلى إثارة ReferenceError إذا كان my_var معرفًا غير معروف، بينما لا يحدث هذا. typeof my_var === 'undefined'

رقم

يتم تمثيل الأرقام في النظام الثنائي على هيئة أرقام عشرية عشرية عشرية وفقًا لمعيار IEEE 754. وعلى الرغم من أن هذا التنسيق يوفر دقة تصل إلى ما يقرب من 16 رقمًا مهمًا ، إلا أنه لا يمكنه دائمًا تمثيل الأرقام الحقيقية بدقة، بما في ذلك الكسور.

تصبح هذه مشكلة عند مقارنة الأرقام أو تنسيقها. على سبيل المثال: 

console.log ( 0.2 + 0.1 === 0.3 ) ; // يعرض قيمة خاطئة console.log ( 0.94 - 0.01 ) ; // يعرض 0.92999999999999999

ونتيجة لذلك، يجب استخدام روتين مثل طريقة toFixed() لتقريب الأرقام كلما تم تنسيقها للإخراج.

يمكن تحديد الأرقام بأي من هذه التدوينات: 

345 ; // "عدد صحيح"، على الرغم من وجود نوع رقمي واحد فقط في JavaScript 34.5 ; // رقم فاصل عائم 3.45e2 ; // رقم فاصل عائم آخر، مكافئ لـ 345 0b1011 ; // عدد صحيح ثنائي يساوي 11 0o377 ; // عدد صحيح ثماني يساوي 255 0xFF ; // عدد صحيح سداسي عشر يساوي 255، الأرقام ممثلة بـ ... // ... يمكن أن تكون أحرف AF كبيرة أو صغيرة

هناك أيضًا فاصل رقمي، _ (الشرطة السفلية)، تم تقديمه في ES2021: 

// ملاحظة: لا يدعم بناء جملة ويكيبيديا الفواصل الرقمية بعد 
1 _000_000_000 ; // يستخدم مع الأعداد الكبيرة 1 _000_000 .5 ; // يدعم مع الكسور العشرية 1 _000e1_000 ; // يدعم مع الأسس    
      
      

// دعم مع الثنائي والثماني والسداسي 
0b0000 _0000_0101_1011 ; 
0o0001 _3520_0237_1327 ; 
0xFFFF _FFFF_FFFF_FFFE ;

// ولكن لا يمكنك استخدامها بجوار جزء رقم غير رقمي، أو في البداية أو النهاية 
_12 ; // لم يتم تعريف المتغير (الشرطة السفلية تجعله معرفًا للمتغير) 12 _ ; // خطأ في بناء الجملة (لا يمكن أن يكون في نهاية الأرقام) 12 _ .0 ; // خطأ في بناء الجملة (لا معنى لوضع فاصل بجوار النقطة العشرية) 12. _0 ; // خطأ في بناء الجملة 12 e_6 ; // خطأ في بناء الجملة (بجوار "e"، رقم غير رقمي. لا معنى لوضع فاصل في البداية) 1000 ____0000 ; // خطأ في بناء الجملة (بجوار "_"، رقم غير رقمي. يُسمح بفاصل واحد فقط في كل مرة

يمكن الحصول على المدى +∞ و −∞ و NaN (ليس رقمًا) لنوع الرقم من خلال تعبيرين للبرنامج: 

ما لا نهاية ؛ // ما لا نهاية موجبة (يتم الحصول على قيمة سالبة باستخدام -Infinity على سبيل المثال) NaN ؛ // قيمة Not-A-Number، والتي يتم إرجاعها أيضًا كفشل في ... // ... تحويلات السلسلة إلى رقم

اللانهاية وNaN هي أرقام: 

typeof Infinity ; // يعيد "number" typeof NaN ; // يعيد "number"

تتوافق هذه القيم الخاصة الثلاث وتتصرف كما يصفها IEEE-754 .

يمكن استخدام منشئ الأرقام (الذي يستخدم كدالة)، أو علامة + أو - الأحادية، لإجراء تحويل رقمي صريح: 

ثابت myString = "123.456" ؛ ثابت myNumber1 = رقم ( myString ) ؛ ثابت myNumber2 = + myString ؛

عند استخدامه كمنشئ، يتم إنشاء كائن غلاف رقمي (على الرغم من قلة استخدامه): 

const myNumericWrapper = رقم جديد ( 123.456 )؛

ومع ذلك، NaN لا يساوي نفسه: 

ثابت نان = نان ; وحدة التحكم . سجل ( NaN == NaN )؛ // وحدة تحكم زائفة . سجل ( NaN === NaN )؛ // وحدة تحكم زائفة . سجل ( NaN !== NaN ); // وحدة التحكم الحقيقية . سجل ( نان !== نان )؛ // حقيقي   
          
         
         
         

// يمكنك استخدام طرق isNaN للتحقق من NaN 
console.log ( isNaN ( " مُحوَّل إلى NaN" ) ); // true console.log ( isNaN ( NaN ) ); // true console.log ( Number.isNaN ( "غير مُحوَّل" ) ) ; // false console.log ( Number.isNaN ( NaN ) ) ; // true

بيجينت

يمكن استخدام BigInts للأعداد الصحيحة الكبيرة بشكل عشوائي . وخاصة الأعداد الصحيحة الأكبر من 2 53 - 1، وهو أكبر رقم يمكن لجافا سكريبت تمثيله بشكل موثوق باستخدام البدائية Number ويتم تمثيله بواسطة الثابت Number.MAX_SAFE_INTEGER.

عند تقسيم BigInts، يتم اقتطاع النتائج .

خيط

السلسلة في JavaScript هي عبارة عن سلسلة من الأحرف. في JavaScript، يمكن إنشاء السلاسل بشكل مباشر (كأحرف) عن طريق وضع سلسلة الأحرف بين علامتي اقتباس مزدوجتين (") أو مفردتين ('). يجب كتابة مثل هذه السلاسل على سطر واحد، ولكن قد تتضمن أحرف سطر جديد مفلتة (مثل \n). يسمح معيار JavaScript باستخدام علامة الاقتباس العكسي (`، أو علامة التهجئة الخطيرة أو علامة التكعيب العكسي) لاقتباس سلاسل حرفية متعددة الأسطر، بالإضافة إلى أحرف القالب، والتي تسمح باستيفاء التعبيرات المقيمة القسرية النوعية داخل سلسلة. [9] 

const greeting = "مرحبًا بالعالم!" ؛ const anotherGreeting = "تحياتي، يا أهل الأرض".؛ const aMultilineGreeting = " مع أطيب التحيات، جون دو".   
   
   


// تقوم أحرف القالب بإجبار التعبيرات التي تم تقييمها على النوع وتدخلها في السلسلة. 
const templateLiteral = `هذا ما يتم تخزينه في anotherGreeting: ${ anotherGreeting } .` ; console . log ( templateLiteral ); // 'هذا ما يتم تخزينه في anotherGreeting: 'تحياتي، يا أهل الأرض.''

يمكن الوصول إلى الأحرف الفردية داخل السلسلة باستخدام طريقة charAt (المقدمة بواسطة String.prototype ). هذه هي الطريقة المفضلة عند الوصول إلى الأحرف الفردية داخل السلسلة، لأنها تعمل أيضًا في المتصفحات غير الحديثة: 

ثابت h = تحية . charAt ( 0 );

في المتصفحات الحديثة، يمكن الوصول إلى الأحرف الفردية داخل سلسلة (كسلاسل تحتوي على حرف واحد فقط) من خلال نفس طريقة التدوين مثل المصفوفات: 

ثابت h = تحية [ 0 ]؛

ومع ذلك، فإن سلاسل JavaScript غير قابلة للتغيير : 

التحية [ 0 ] = "H" ; // فشل.

يؤدي تطبيق عامل المساواة ("==") على سلسلتين إلى إرجاع القيمة true، إذا كانت السلسلتان تحتويان على نفس المحتوى، مما يعني: نفس الطول وتحتويان على نفس تسلسل الأحرف (الحالة مهمة للأبجدية). وبالتالي: 

const x = "World" ; const compare1 = ( "Hello, " + x == "Hello, World" ); // هنا compare1 تحتوي على true. const compare2 = ( "Hello, " + x == "hello, World" ); // هنا compare2 تحتوي على ... // ... false لأن ... // ... الأحرف الأولى ... // ... لكلا المتعاملين ... // ... ليست من نفس الحالة.

لا يمكن تضمين علامات الاقتباس من نفس النوع إلا إذا تم إفلاتها . 

دع x = '"Hello, World!" he said.' ; // جيد جدًا. x = "" Hello , World ! " he said." ; // ليس جيدًا. x = "\"Hello, World!\" he said." ; // يعمل عن طريق الإفلات من " بـ \"

يقوم منشئ السلسلة بإنشاء كائن سلسلة (كائن يلف سلسلة): 

const greeting = new String ( "مرحبا بالعالم!" );

تحتوي هذه الكائنات على طريقة valueOf التي تقوم بإرجاع السلسلة البدائية المضمنة بداخلها: 

const s = new String ( "Hello !" ); typeof s ; // Is 'object'. typeof s . valueOf (); // Is 'string'.

لا يتصرف التساوي بين كائنين من سلسلة كما هو الحال مع بدائيات السلسلة:

const s1 = new String ( "Hello !" ); const s2 = new String ( "Hello !" ); s1 == s2 ; // خطأ، لأنهما كائنان مختلفان. s1 . valueOf () == s2 . valueOf (); // صحيح.

منطقي

توفر JavaScript نوع بيانات Boolean مع حروف true و false . يعيد عامل typeof السلسلة "boolean" لهذه الأنواع البدائية . عند استخدامها في سياق منطقي، يتم تقييم 0 و -0 و null و NaN و undefined والسلسلة الفارغة ( "" ) على أنها false بسبب التحويل التلقائي للنوع . يتم تقييم جميع القيم الأخرى (المكملة للقائمة السابقة) على أنها true ، بما في ذلك السلاسل "0" و "false" وأي كائن.

تحويل النوع

يمكن تجنب إكراه النوع التلقائي بواسطة مشغلات مقارنة المساواة ( ==و !=) باستخدام مشغلات المقارنة التي تم فحص النوع ( ===و !==).

عندما يكون تحويل النوع مطلوبًا، يقوم JavaScript بتحويل المتغيرات Boolean أو Number أو String أو Object على النحو التالي: [10]

الرقم والسلسلة
يتم تحويل السلسلة إلى قيمة رقمية. يحاول JavaScript تحويل السلسلة الرقمية الحرفية إلى قيمة من نوع Number. أولاً، يتم استخلاص قيمة رياضية من السلسلة الرقمية الحرفية. بعد ذلك، يتم تقريب هذه القيمة إلى أقرب قيمة من نوع Number.
منطقي
إذا كان أحد المتغيرات عبارة عن متغير بولياني، يتم تحويل المتغير البولياني إلى 1 إذا كان صحيحًا ، أو إلى 0 إذا كان خطأ .
هدف
إذا تمت مقارنة كائن برقم أو سلسلة، يحاول JavaScript إرجاع القيمة الافتراضية للكائن. يتم تحويل الكائن إلى قيمة سلسلة أو رقم بدائية، باستخدام طريقتي .valueOf() أو .toString() للكائن. إذا فشل هذا، يتم إنشاء خطأ وقت التشغيل.

تحويل النوع المنطقي

يدافع دوغلاس كروكفورد عن مصطلحي "حقيقي" و"خاطئ" لوصف كيفية تصرف قيم الأنواع المختلفة عند تقييمها في سياق منطقي، وخاصة فيما يتعلق بالحالات الهامشية. [11] أعادت المشغلات المنطقية الثنائية قيمة منطقية في الإصدارات المبكرة من جافا سكريبت، لكنها الآن تعيد أحد المتغيرات بدلاً من ذلك. يتم إرجاع المتغير الأيسر، إذا كان من الممكن تقييمه على أنه: false ، في حالة الاقتران : ( )، أو true ، في حالة الفصل : ( )؛ وإلا يتم إرجاع المتغير الأيمن. قد يختلف الإكراه التلقائي للنوع بواسطة مشغلات المقارنة في حالات المتغيرات المنطقية المختلطة والمتوافقة مع الأرقام (بما في ذلك السلاسل التي يمكن تقييمها كرقم، أو الكائنات التي يمكن تقييمها كسلسلة)، لأنه سيتم مقارنة المتغير المنطقي كقيمة عددية. قد يكون هذا غير متوقع. يمكن تحويل تعبير بشكل صريح إلى بدائي منطقي عن طريق مضاعفة عامل النفي المنطقي : ( !! )، باستخدام الدالة Boolean() ، أو باستخدام عامل الشرط : ( ). a && ba || bc ? t : f


// إكراه النوع التلقائي console.log ( true == 2 ); // false... true → 1 !== 2 ← 2 console.log ( false == 2 ); // false... false → 0 !== 2 ← 2 console.log ( true == 1 ) ; // true.... true → 1 === 1 ← 1 console.log( false == 0 ) ; // true .... false → 0 === 0 ← 0 console.log ( true == " 2" ); // false... true → 1 !== 2 ← "2" console.log(false == "2"); // false... false → 0 !== 2 ← "2" console.log ( true == " 1 " ) ; // true .... true → 1 === 1 ← " 1 " console.log ( false == " 0 " ); // صحيح.... خطأ → 0 === 0 ← "0" console.log ( خطأ == " " ); // صحيح.... خطأ → 0 === 0 ← "" console.log ( خطأ == NaN ) ; // خطأ... خطأ → 0 ! == NaN       
      
       
      
     
    
     
    
     
    

console.log ( NaN == NaN ); // false...... NaN لا يعادل أي شيء، بما في ذلك NaN .   

// مقارنة تم فحص النوع (لا يوجد تحويل للأنواع والقيم) 
console . log ( true === 1 ); // false...... أنواع البيانات لا تتطابق   


// إكراه النوع الصريح console.log(true === !! 2); // true.... أنواع البيانات والقيم متطابقة console.log(true === !! 0 ) ; // false ... أنواع البيانات متطابقة ، لكن القيم تختلف console.log ( 1 ? true : false ) ; // true .... فقط ±0 وNaN هي أرقام "خاطئة" console.log ( " 0 " ? true : false ); // true .... فقط السلسلة الفارغة هي "خاطئة" console.log ( Boolean ({})); // true.... كل الكائنات " صحيحة "

يمكن استخدام عامل التشغيل الجديد لإنشاء غلاف كائن لبدائية Boolean. ومع ذلك، لا يعيد عامل التشغيل typeof قيمة boolean لغلاف الكائن، بل يعيد object . ولأن جميع الكائنات يتم تقييمها على أنها true ، فيجب استخدام طريقة مثل .valueOf() أو .toString() لاسترداد القيمة المغلّفة. وللإجبار الصريح على النوع Boolean، توصي Mozilla باستخدام دالة Boolean() (بدون new ) بدلاً من الكائن Boolean. 

const b = new Boolean ( false ); // Object false {} const t = Boolean ( b ); // Boolean true const f = Boolean ( b . valueOf ()); // Boolean false let n = new Boolean ( b ); // غير موصى به n = new Boolean ( b . valueOf ()); // مفضل       
              
    
           
    

إذا ( 0 || - 0 || "" || null || غير معرف || b . valueOf () || ! جديد Boolean () || ! t ) { console.log ( " لا تفعل هذا أبدًا" ); } وإلا إذا ([] && {} && b && typeof b === "object" && b . toString () === "false" ) { console.log ( " دائمًا هذا" ) ; }

رمز

جديد في ECMAScript6. الرمز هو معرف فريد وغير قابل للتغيير.

مثال: 

دع x = رمز ( 1 )؛ ثابت y = رمز ( 1 )؛ x === y ؛ // => خطأ   
   
   

كائن رمز ثابت = {}؛ كائن طبيعي ثابت = {}؛   
   

// بما أن x و y فريدان، 
// فيمكن استخدامهما كمفاتيح فريدة في كائن 
symbolObject [ x ] = 1 ; symbolObject [ y ] = 2 ;  
  

symbolObject [ x ]; // => 1 symbolObject [ y ]; // => 2 
 

// بالمقارنة مع المفاتيح الرقمية العادية 
normalObject [ 1 ] = 1 ; normalObject [ 1 ] = 2 ; // يتجاوز قيمة 1  
   

كائن طبيعي [ 1 ]; // => 2 

// تغيير قيمة x لا يغير المفتاح المخزن في الكائن 
x = Symbol ( 3 ); symbolObject [ x ]; // => غير محدد  
 

// تغيير x مرة أخرى يؤدي فقط إلى إنشاء رمز فريد آخر 
x = Symbol ( 1 ); symbolObject [ x ]; // => غير محدد

وهناك أيضًا رموز معروفة .

أحدها هو Symbol.iterator؛ إذا تم تنفيذ شيء ما Symbol.iterator، فهو قابل للتكرار: 

const x = [ 1 , 2 , 3 , 4 ]; // x عبارة عن مصفوفة x [ Symbol . iterator ] === Array . prototype [ Symbol . iterator ]; // والمصفوفات قابلة للتكرار       
   

const xIterator = x [ Symbol . iterator ](); // يجب أن توفر الدالة [Symbol.iterator] مُكررًا لـ x xIterator . next (); // { value: 1, done: false } xIterator . next (); // { value: 2, done: false } xIterator . next (); // { value: 3, done: false } xIterator . next (); // { value: 4, done: false } xIterator . next (); // { value: undefined, done: true } xIterator . next (); // { value: undefined, done: true }    
 
 
 
 
 
 


// تقوم حلقات for..of بتكرار القيم تلقائيًا for ( قيمة ثابتة لـ x ) { console.log ( قيمة ); // 1 2 3 4 }     
    


// المجموعات قابلة للتكرار أيضًا: 
[ Symbol . iterator ] in Set . prototype ; // true   

بالنسبة إلى ( قيمة ثابتة للمجموعة الجديدة ([ ' apple' , 'orange' ])) { console.log( value ) ; // " apple " " orange " }

الأشياء الأصلية

توفر لغة JavaScript عددًا قليلًا من الكائنات الأصلية . وتعتبر كائنات JavaScript الأصلية جزءًا من مواصفات JavaScript. وبصرف النظر عن بيئة JavaScript، يجب أن تكون مجموعة الكائنات هذه متاحة دائمًا.

مصفوفة

المصفوفة عبارة عن كائن JavaScript تم إنشاؤه من Arrayالمنشئ المصمم خصيصًا لتخزين قيم البيانات المفهرسة بمفاتيح الأعداد الصحيحة. على عكس نوع الكائن الأساسي، يتم إنشاء المصفوفات باستخدام الأساليب والخصائص لمساعدة المبرمج في المهام الروتينية (على سبيل المثال، joinو sliceو و push).

كما هو الحال في عائلة C ، تستخدم المصفوفات مخطط فهرسة يعتمد على الصفر: القيمة التي يتم إدخالها في مصفوفة فارغة عن طريق pushالطريقة تشغل الفهرس 0 للمصفوفة. 

const myArray = []; // وجه المتغير myArray إلى مصفوفة فارغة تم إنشاؤها حديثًا ... // ... myArray . push ( "hello World" ); // املأ الفهرس الفارغ التالي، في هذه الحالة 0 console . log ( myArray [ 0 ]); // مكافئ لـ console.log("hello World");

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

من الممكن الوصول إلى عناصر Arrays باستخدام تدوين الوصول إلى خصائص الكائن العادي: 

myArray [ 1 ]; // العنصر الثاني في myArray myArray [ "1" ];

إن الأمرين المذكورين أعلاه متكافئان. ليس من الممكن استخدام تدوين "النقطة" أو السلاسل مع التمثيلات البديلة للرقم: 

myArray .1 ; // خطأ في بناء الجملة myArray [ "01" ]; // ليس نفس myArray[1]

يمكن لإعلان المصفوفة استخدام Arrayحرفي أو Arrayمنشئ: 

دع myArray ؛ 

// مصفوفات حرفية 
myArray = [ 1 , 2 ]; // طول 2 myArray = [ 1 , 2 ,]; // نفس المصفوفة - يمكنك أيضًا الحصول على فاصلة إضافية في النهاية    
    

// من الممكن أيضًا عدم ملء أجزاء من المصفوفة 
myArray = [ 0 , 1 , /* hole */ , /* hole */ , 4 , 5 ]; // طول 6 myArray = [ 0 , 1 , /* hole */ , /* hole */ , 4 , 5 ,]; // نفس المصفوفة myArray = [ 0 , 1 , /* hole */ , /* hole */ , 4 , 5 , /* hole */ ,]; // طول 7        
        
         

// باستخدام المنشئ 
myArray = new Array ( 0 , 1 , 2 , 3 , 4 , 5 ); // طول 6 myArray = new Array ( 365 ); // مصفوفة فارغة بطول 365

يتم تنفيذ المصفوفات بحيث تستخدم العناصر المحددة فقط الذاكرة؛ فهي " مصفوفات متفرقة ". يستخدم الإعداد و فقط المساحة لهذين العنصرين، تمامًا مثل أي كائن آخر. سيظل طول المصفوفة 58. يبلغ الحد الأقصى لطول المصفوفة 4,294,967,295 وهو ما يتوافق مع رقم ثنائي مكون من 32 بت (1 ...myArray[10] = 'someThing'myArray[57] = 'somethingOther'length

من الممكن استخدام إعلان الكائن الحرفي لإنشاء كائنات تتصرف مثل المصفوفات الترابطية في اللغات الأخرى: 

const dog = { color : "brown" , size : "large" }; dog [ "color" ]; // ينتج عنه "brown" dog . color ; // ينتج عنه أيضًا "brown"

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

const cats = [{ color : "brown" , size : "large" }, { color : "black" , size : "small" }]; cats [ 0 ][ "size" ]; // ينتج عنه "large"      
       
      

const dogs = { rover : { color : "brown" , size : "large" }, spot : { color : "black" , size : "small" }}; dogs [ "spot" ][ "size" ]; // ينتج عنه "small" dogs . rover . color ; // ينتج عنه "brown"

تاريخ

يخزن الكائن Dateعددًا من الملي ثانية موقّعًا حيث يمثل الصفر 1970-01-01 00:00:00 UT ونطاقًا من ±10 8 أيام. هناك عدة طرق لتوفير الوسائط للمنشئ Date. لاحظ أن الأشهر تعتمد على الصفر. 

new Date (); // إنشاء مثيل تاريخ جديد يمثل الوقت/التاريخ الحالي. new Date ( 2010 , 2 , 1 ); // إنشاء مثيل تاريخ جديد يمثل 2010-Mar-01 00:00:00 new Date ( 2010 , 2 , 1 , 14 , 25 , 30 ); // إنشاء مثيل تاريخ جديد يمثل 2010-Mar-01 14:25:30 new Date ( "2010-3-1 14:25:30" ); // إنشاء مثيل تاريخ جديد من سلسلة.

يتم توفير طرق لاستخراج الحقول، بالإضافة إلى ما يلي مفيد toString: 

const d = تاريخ جديد ( 2010 ، 2 ، 1 ، 14 ، 25 ، 30 )؛ // 2010-مارس-01 14:25:30؛          


// يعرض '2010-3-1 14:25:30': console.log ( d.getFullYear ( ) + ' - ' + ( d.getMonth ( ) + 1 ) + ' -' + d.getDate ( ) + ' ' + d.getHours () + ' :' + d.getMinutes ( ) + ' :' + d.getSeconds ( ) ) ;            
             

// تعيد الدالة toString المضمنة شيئًا مثل 'Mon Mar 01 2010 14:25:30 GMT-0500 (EST)': 
console . log ( d );

خطأ

يمكن إنشاء رسائل الخطأ المخصصة باستخدام Errorالفصل: 

قم بإلقاء خطأ جديد ( "حدث خطأ ما." );

يمكن التقاط هذه الاستثناءات باستخدام كتل try...catch...finally كما هو موضح في القسم الخاص بمعالجة الاستثناءات.

الرياضيات

يحتوي كائن Math على ثوابت مختلفة متعلقة بالرياضيات (على سبيل المثال، π ) ووظائف (على سبيل المثال، جيب التمام). (لاحظ أن كائن Math ليس له منشئ، على عكس Array أو Date . كل طرقه "ثابتة"، أي طرق "فئة"). تستخدم جميع الدوال المثلثية زوايا معبر عنها بالراديان ، وليس الدرجات أو التدرجات .

بعض الثوابت الموجودة في كائن الرياضيات
ملكية القيمة المرتجعة
مقربة إلى 5 أرقام		 وصف
الرياضيات.هـ 2.7183 هـ : قاعدة اللوغاريتم الطبيعي
الرياضيات.LN2 0.69315 اللوغاريتم الطبيعي لـ 2
الرياضيات.LN10 2.3026 اللوغاريتم الطبيعي لـ 10
الرياضيات.LOG2E 1.4427 اللوغاريتم للقاعدة 2 من e
الرياضيات.LOG10E 0.43429 اللوغاريتم للقاعدة 10 من e
الرياضيات.PI 3.14159 π : محيط/قطر الدائرة
الرياضيات.SQRT1_2 0.70711 الجذر التربيعي لـ ½
الرياضيات.SQRT2 1.4142 الجذر التربيعي لـ 2
طرق كائن الرياضيات
مثال القيمة المرتجعة
مقربة إلى 5 أرقام		 وصف
الرياضيات.abs(-2.3) 2.3 القيمة المطلقة
الرياضيات.acos(الرياضيات.SQRT1_2) 0.78540  راد = 45 درجة قوس كوزين
الرياضيات.asin(الرياضيات.SQRT1_2) 0.78540 راد = 45 درجة قوس الجيب
الرياضيات.آتان(1) 0.78540 راد = 45 درجة نصف دائرة قوس الظل ( ⁠ ⁠ إلى ⁠ ⁠ )
الرياضيات.atan2(-3.7، -3.7) −2.3562 راد =-135 درجة الدائرة الكاملة الظلية ( ⁠ ⁠ إلى ⁠ ⁠ )
ماث سيل(1.1) 2 السقف: تقريب إلى أصغر عدد صحيح ≥ وسيطة
الرياضيات.cos(الرياضيات.PI/4) 0.70711 جيب التمام
تجربة الرياضيات(1) 2.7183 الدالة الأسية : e مرفوعة إلى هذا الأس
الرياضيات.الأرضية(1.9) 1 الأرضية: التقريب للأسفل إلى أكبر عدد صحيح ≤ وسيطة
الرياضيات.log(الرياضيات.E) 1 اللوغاريتم الطبيعي، القاعدة e
الرياضيات.الحد الأقصى(1، -2) 1 الحد الأقصى: (x > y) ؟ x : y
الرياضيات.الحد الأدنى(1، -2) -2 الحد الأدنى: (x < y) ؟ x : y
الرياضيات.pow(-3، 2) 9 الأس (مرفوع إلى القوة): Math.pow(x, y) يعطي x y
الرياضيات.عشوائي() مثلا 0.17068 رقم عشوائي زائف بين 0 (شامل) و1 (حصري)
الرياضيات.round(1.5) 2 التقريب إلى أقرب عدد صحيح؛ يتم تقريب نصف الكسور لأعلى (على سبيل المثال، يتم تقريب 1.5 إلى 2)
الرياضيات.الخطيئة(الرياضيات.PI/4) 0.70711 جيب التمام
الرياضيات.الجذر التربيعي(49) 7 الجذر التربيعي
الرياضيات.tan(الرياضيات.PI/4) 1 المماس

تعبير منتظم

/expression/.test(string ) ; // إرجاع قيمة منطقية "string" .search ( / expression / ) ; // إرجاع رقم الموضع "string" .replace ( /expression/ , replacement );     
 
 

// فيما يلي بعض الأمثلة 
if ( /Tom/ . test ( "My name is Tom" )) console . log ( "Hello Tom!" ); console . log ( "My name is Tom" . search ( /Tom/ )); // == 11 (حرفًا قبل Tom) console . log ( "My name is Tom" . replace ( /Tom/ , "John" )); // == "My name is John"

فئات الشخصيات

// \d - رقم 
// \D - غير رقم 
// \s - مسافة 
// \S - غير مسافة 
// \w - حرف كلمة 
// \W - غير كلمة 
// [ ] - واحد من 
// [^] - واحد ليس من 
// - - نطاق

إذا ( /\d/ . اختبار ( '0' )) console . تسجيل ( 'رقم' ); إذا ( /[0-9]/ . اختبار ( '6' )) console . تسجيل ( 'رقم' ); إذا ( /[13579]/ . اختبار ( '1' )) console . تسجيل ( 'رقم فردي' ); إذا ( /\S\S\s\S\S\S/ . اختبار ( 'اسمي' )) console . تسجيل ( 'تنسيق جيد' ); إذا ( /\w\w\w/ . اختبار ( 'توم' )) console . تسجيل ( 'مرحبا توم' ); إذا ( /[a-zA-Z]/ . اختبار ( 'ب' )) console . تسجيل ( 'حرف' );

مطابقة الأحرف

// A...Z a...z 0...9 - أبجدي رقمي 
// \u0000...\uFFFF - Unicode سداسي عشري 
// \x00...\xFF - ASCII سداسي عشري 
// \t - tab 
// \n - سطر جديد 
// \r - CR 
// . - أي حرف 
// | - أو

إذا ( /Tm/ . اختبار ( 'توم' )) console . تسجيل ( 'مرحبا توم، تام أو تيم' ); إذا ( /A|B/ . اختبار ( "أ" )) console . تسجيل ( 'أ أو ب' );

المكررات

// ? - 0 أو 1 تطابق 
// * - 0 أو أكثر 
// + - 1 أو أكثر 
// {n} - n بالضبط 
// {n,} - n أو أكثر 
// {0,n} - n أو أقل 
// {n,m} - نطاق n إلى m

إذا ( /ab?c/ . test ( "ac" )) console.log ( " موافق" ); //مطابقة: "ac"، "abc" إذا ( /ab*c/ . test ( " ac " )) console.log ( "موافق" ); // مطابقة: "ac"، "abc"، "abbc"، "abbbc" وما إلى ذلك. إذا ( / ab+c/ . test ( "abc" )) console.log ( "موافق" ); //مطابقة: "abc"، "abbc"، "abbbc" وما إلى ذلك. إذا ( / ab{3}c/ . test ( " abbbc" )) console.log ( " موافق" ) ; //مطابقة: "abbbc" إذا ( /ab{3,}c/ . test ( " abbbc " )) console.log ( "موافق" ); // مطابقة: "abbbc"، "abbbbc"، "abbbbbc" وما إلى ذلك. إذا ( /ab{1,3}c/ . اختبار ( " abc" )) console.log ( " موافق" ); // مطابقة: "abc"، "abbc"، "abbbc"

المراسي

// ^ - تبدأ السلسلة بـ 
// $ - تنتهي السلسلة بـ

إذا ( /^My/.test ( "اسمي توم" ) ) console.log ( " مرحبًا!" ) ; إذا ( /Tom$/ . test ( " اسمي توم" )) console.log ( " مرحبًا توم!" ) ;

التعبير الفرعي

// ( ) - مجموعات الأحرف

إذا ( /water(mark)?/ . test ( "watermark" )) console . log ( "هذا ماء!" ); // match: "water", "watermark", إذا ( /(Tom)|(John)/ . test ( "John" )) console . log ( "مرحبا توم أو جون!" );

الأعلام

// /g - عالمي 
// /i - تجاهل الأحرف الكبيرة/الصغيرة 
// /m - السماح للمطابقات بامتداد أسطر متعددة

console . log ( "مرحبًا توم!" . استبدال ( /Tom/i ، "جون" )); // == "مرحبًا جون!" console . log ( "راتاتام" . استبدال ( /ta/ ، "tu" )); // == "راتوتام" console . log ( "راتاتام" . استبدال ( /ta/g ، "tu" )); // == "راتوتوم"

طرق متقدمة

my_array = my_string . split ( my_delimiter ); // مثال my_array = "dog,cat,cow" . split ( "," ); // my_array==["dog","cat","cow"];  

        

my_array = my_string . match ( my_expression ); // مثال my_array = "نبدأ في الساعة 11:30 و12:15 و16:45" . match ( /\d\d:\d\d/g ); // my_array==["11:30","12:15","16:45"];

التقاط المجموعات

const myRe = /(\d{4}-\d{2}-\d{2}) (\d{2}:\d{2}:\d{2})/ ; const results = myRe . exec ( "التاريخ والوقت هما 2009-09-08 09:37:08." ); if ( results ) { console . log ( "مطابق: " + results [ 0 ]); // المطابقة الكاملة const my_date = results [ 1 ]; // المجموعة الأولى == "2009-09-08" const my_time = results [ 2 ]; // المجموعة الثانية == "09:37:08" console . log ( `إنه ${ my_time } في ${ my_date } ` ); } else console . log ( "لم يتم العثور على تاريخ صالح!" );

وظيفة

كل وظيفة في JavaScript هي عبارة عن مثيل Functionللمنشئ: 

// x, y هي الحجة. 'return x + y' هو نص الدالة، وهو الأخير في قائمة الحجة. 
const add = new Function ( 'x' , 'y' , 'return x + y' ); add ( 1 , 2 ); // => 3

يمكن أيضًا تعريف وظيفة الإضافة أعلاه باستخدام تعبير الوظيفة: 

const add = function ( x , y ) { return x + y ; }; add ( 1 , 2 ); // => 3

في ES6، تمت إضافة بناء جملة وظيفة السهم، مما يسمح للوظائف التي ترجع قيمة بأن تكون أكثر إيجازًا. كما أنها تحتفظ بـ thisالكائن العالمي بدلاً من وراثته من المكان الذي تم استدعاؤه فيه / ما تم استدعاؤه عليه، على عكس التعبير function() {}. 

const add = ( x , y ) => { return x + y ;}; // يمكن أيضًا إرجاع القيم ضمنيًا (أي لا يلزم وجود عبارة return) const addImplicit = ( x , y ) => x + y ;         

        

إضافة ( 1 ، 2 )؛ // => 3 إضافة ضمنية ( 1 ، 2 ) // => 3

بالنسبة للوظائف التي تحتاج إلى الرفع، هناك تعبير منفصل: 

دالة add ( x , y ) { return x + y ; } add ( 1 , 2 ); // => 3

يسمح لك الرفع باستخدام الوظيفة قبل "إعلانها": 

إضافة ( 1 ، 2 )؛ // => 3، ليست دالة ReferenceError إضافة ( x ، y ) { إرجاع x + y ؛ }

تحتوي مثيلات الوظيفة على خصائص وطرق. 

دالة طرح ( x ، y ) { إرجاع x - y ؛ }   
     


console.log ( subtract.length ) ; // = > 2 ، عدد الدالة (عدد الوسائط) console.log ( subtract.toString ( ) ) ; 


/* 
"دالة الطرح (x، y) { 
  إرجاع x - y؛ 
}" 
*/

المشغلين

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

// قم بربط سلسلتين 
console . log ( 'He' + 'llo' ); // يعرض Hello   


// أضف رقمين console .log ( 2 + 6 ); // يعرض 8    

// إضافة رقم وسلسلة ينتج عنها تسلسل (من اليسار إلى اليمين) 
console . log ( 2 + '2' ); // يعرض 22 console . log ( '$' + 3 + 4 ); // يعرض 34، ولكن ربما كان من المتوقع إضافة 7 console . log ( '$' + ( 3 + 4 )); // يعرض 7 console . log ( 3 + 4 + '7' ); // يعرض 77، تظل الأرقام أرقامًا حتى تتم إضافة سلسلة      
      
     
     

// تحويل سلسلة إلى رقم باستخدام علامة الجمع الأحادية 
console . log ( + '2' === 2 ); // يعرض true console . log ( + 'Hello' ); // يعرض NaN

وبنفس الطريقة، يتم تحميل عامل '*' بشكل زائد: حيث يمكنه تحويل سلسلة إلى رقم. 

console.log ( 2 + '6' * 1 ) ; // يعرض 8 console.log ( 3 * ' 7' ) ; // 21 console.log ( ' 3' * '7' ); // 21 console.log ( ' hello ' * 'world' ); // يعرض NaN

الحساب

يدعم JavaScript العمليات الحسابية الثنائية التالية :

+ إضافة
- الطرح
* الضرب
/ القسمة (ترجع قيمة فاصلة عائمة)
% modulo (إرجاع الباقي)
** الأسس

يدعم JavaScript المعاملات الحسابية الأحادية التالية :

+ تحويل أحادي من سلسلة إلى رقم
- نفي أحادي (يعكس الإشارة)
++ الزيادة (يمكن أن تكون بادئة أو لاحقة)
-- التناقص (يمكن أن يكون بادئة أو لاحقة) 
دع x = 1 ؛ console.log ( ++ x )؛ // x يصبح 2؛ يعرض 2 console.log ( x ++ ) ؛ // يعرض 2؛ x يصبح 3 console.log ( x )؛ // x يساوي 3؛ يعرض 3 console.log ( x -- ) ؛ // يعرض 3؛ x يصبح 2 console.log ( x ) ؛ // يعرض 2؛ x يساوي 2 console.log ( -- x ) ؛ // x يصبح 1؛ يعرض 1

يعرض عامل modulo الباقي بعد القسمة على modulo. إذا كانت الأرقام سالبة، فإن القيمة المرتجعة تعتمد على المتغير. 

const x = 17 ؛ console.log ( x % 5 )؛ // يعرض 2 console.log ( x % 6 ) ؛ // يعرض 5 console.log ( - x % 5 ) ؛ // يعرض -2 console.log ( - x % - 5 ) ؛ // يعرض -2 console.log ( x % - 5 ) ؛ // يعرض 2

لإرجاع رقم غير سلبي دائمًا، أعد إضافة المعامل وقم بتطبيق عامل المعامل مرة أخرى: 

const x = 17 ؛ console.log ( ( - x % 5 + 5 ) % 5 )؛ // يعرض 3

يمكنك أيضًا القيام بما يلي: 

const x = 17 ؛ console.log ( Math.abs ( -x % 5 ) ) ; // أيضًا 3​

تكليف

= تعيين
+= إضافة وتعيين
-= طرح وتعيين
*= اضرب وخصص
/= تقسيم وتعيين
%= modulo وتعيين
**= الأسس والتعيين

تعيين الأنواع البدائية 

دع x = 9 ؛ x += 1 ؛ console.log ( x )؛ // يعرض: 10 x *= 30 ؛ console.log ( x )؛ // يعرض: 300 x / = 6 ؛ console.log ( x )؛ // يعرض: 50 x - = 3 ؛ console.log ( x )؛ // يعرض : 47 x %= 7 ؛ console.log ( x )؛ // يعرض : 5

تعيين أنواع الكائنات 

/** 
* لتعلم كائنات JavaScript... 
*/ 
const object_1 = { a : 1 }; // تعيين مرجع للكائن الذي تم إنشاؤه حديثًا إلى object_1 let object_2 = { a : 0 }; let object_3 = object_2 ; // يشير object_3 إلى نفس الكائن الذي يشير إليه object_2 object_3 . a = 2 ; message (); // يعرض 1 2 2 object_2 = object_1 ; // يشير object_2 الآن إلى نفس الكائن الذي يشير إليه object_1 // لا يزال object_3 يشير إلى ما أشار إليه object_2 قبل message (); // يعرض 1 1 2 object_2 . a = 7 ; // يعدل object_1 message (); // يعرض 7 7 2    		
    
   	    
	 
  
	        	
	 
  		
	        	        
		        
	 
    	        
		        

object_3 . a = 5 ; // object_3 لا يغير رسالة object_2 (); // يعرض 7 7 5                   
	                

object_3 = object_2 ؛ object_3.a = 4 ؛ // يغير object_3 الرسالة object_1 و object_2 ()؛ // يعرض 4 4 4  	
                  
                     

/** 
* طباعة رسالة console.log 
*/ 
function message () { console.log ( object_1 . a + " " + object_2 . a + " " + object_3 . a ) ; }

مهمة التفكيك

في JavaScript الخاص بشركة Mozilla، منذ الإصدار 1.7، تسمح عملية التعيين بالتفكيك بتعيين أجزاء من هياكل البيانات لعدة متغيرات في وقت واحد. الجانب الأيسر من التعيين هو نمط يشبه كائنًا/مصفوفة متداخلة بشكل عشوائي تحتوي على قيم l-l في أوراقها والتي من المفترض أن تتلقى الهياكل الفرعية للقيمة المخصصة. 

دع a ، b ، c ، d ، e ؛ [ a ، b ، c ] = [ 3 ، 4 ، 5 ]؛ console.log ( ` $ { a } ، ${ b } ، ${ c } ` )؛ // يعرض : 3،4،5 e = { foo : 5 ، bar : 6 ، baz : [ 'Baz' ، 'Content' ]}؛ const arr = []؛ ({ baz : [ arr [ 0 ]، arr [ 3 ]]، foo : a ، bar : b } = e )؛ console.log (`${a }، ${b}، ${arr}`)؛ // يعرض: 5،6،Baz،,,Content[a، b] = [b، a]؛ // تبديل محتويات a وb console.log(`${a} ، $ { b } ، $ { arr } ` )؛ // يعرض: 5،6،Baz،,,Content [ a ، b ] = [ b ، a ]؛ // تبديل محتويات a وb console.log( ` ${a}، ${b}، ${ arr } ` )؛ سجل ( أ + ',' + ب )؛ // يعرض: 6,5     
      
 
        
   
        
	
    		
    		

[ a , b , c ] = [ 3 , 4 , 5 ]; // التبديلات [ a , b , c ] = [ b , c , a ]; console.log ( ` ${ a } , ${ b } , ${ c } ` ); // يعرض : 4,5,3

عامل الانتشار/الراحة

قدم معيار ECMAScript 2015 ...عامل المصفوفة " " للمفاهيم ذات الصلة بـ "نحو الانتشار" [12] و"معلمات السكون". [13] تمت إضافة انتشار الكائنات في ECMAScript 2018.

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

بعبارة أخرى، ...يحول " " [...foo]" إلى " [foo[0], foo[1], foo[2]]"، و" this.bar(...foo);" إلى " this.bar(foo[0], foo[1], foo[2]);"، و" { ...bar }" إلى { prop: bar.prop, prop2: bar.prop2 }. 

ثابت أ = [ 1 ، 2 ، 3 ، 4 ]؛      

//يمكن استخدامه عدة مرات في نفس التعبير
ثابت ب = [... أ ، ... أ ]؛ // ب = [1، 2، 3، 4، 1، 2، 3، 4]؛     

//يمكن دمجه مع العناصر غير المنتشرة.
ثابت ج = [ 5 ، 6 ، ... أ ، 7 ، 9 ]؛ // ج = [5، 6، 1، 2، 3، 4، 7، 9]؛        

// للمقارنة، قم بذلك بدون عامل الانتشار
//ينشئ مصفوفة متداخلة.
ثابت د = [ أ ، أ ]؛ // د = [[1، 2، 3، 4]، [1، 2، 3، 4]]     

//يعمل بنفس الطريقة مع استدعاءات الوظيفة
دالة foo ( arg1 ، arg2 ، arg3 ) {    
    console.log ( ` ${ arg1 } : $ { arg2 } : ${ arg3 } ` ) ;
}

// يمكنك استخدامه حتى لو مر بمعلمات أكثر مما ستستخدمه الوظيفة
foo (... a ); // "1:2:3" → foo(a[0], a[1], a[2], a[3]); 

// يمكنك مزجها مع المعلمات غير المنتشرة
foo ( 5 ، ... أ ، 6 ); // "5:1:2" → foo (5 ، أ [0] ، أ [1] ، أ [2] ، أ [3] ، 6) ؛   

// للمقارنة، قم بذلك بدون عامل الانتشار
// يقوم بتعيين المصفوفة إلى arg1، ولا شيء للمعلمات الأخرى.
foo ( a ); // "1,2,3,4:غير محدد:غير محدد" 

ثابت شريط = { أ : 1 ، ب : 2 ، ج : 3 }؛          

// سيؤدي هذا إلى نسخ الكائن
const copy = { ... bar }; // copy = { a: 1, b: 2, c: 3 };      

// سيتم تجاوز "b" هنا
const override = { ... bar , b : 4 }; // override = { a: 1, c: 3, b: 4 }

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

دالة foo ( a ، b ، ... c ) { console.log ( c.length ) ; }​​​    
    


foo ( 1 , 2 , 3 , 4 , 5 ); // "3" → c = [3, 4, 5] foo ( 'a' , 'b' ); // "0" → c = []

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

مقارنة

== متساوي
!= ليس متساويا
> أكبر من
>= أكبر من أو يساوي
< أقل من
<= أقل من أو يساوي
=== متطابقة (متساوية ومن نفس النوع)
!== غير متطابقة

المتغيرات التي تشير إلى الكائنات تكون متساوية أو متطابقة فقط إذا كانت تشير إلى نفس الكائن: 

const obj1 = { a : 1 }; const obj2 = { a : 1 }; const obj3 = obj1 ; console.log ( obj1 == obj2 ) ; // false console.log ( obj3 == obj1 ) ; // true console.log ( obj3 === obj1 ) ; // true

انظر أيضًا سلسلة.

منطقي

يوفر JavaScript أربعة عوامل منطقية:

في سياق عملية منطقية، يتم تقييم أي تعبير على أنه صحيح باستثناء ما يلي :

  • السلاسل: ""، ''،
  • الأرقام: 0، -0، NaN،
  • خاص: null، undefined،
  • بولياني: false.

يمكن استخدام الدالة Boolean لتحويل صريح إلى بدائي من النوع Boolean: 

// فقط السلاسل الفارغة ترجع قيمة false 
console . log ( Boolean ( " " ) === false ); console . log ( Boolean ( " false " ) === true ); console . log ( Boolean ( " 0 " ) === true );       
  
      

// فقط صفر وNaN يعيدان القيمة false 
console . log ( Boolean ( NaN ) === false ); console . log ( Boolean ( 0 ) === false ); console . log ( Boolean ( - 0 ) === false ); // يعادل -1*0 console . log ( Boolean ( - 2 ) === true );  
    
    
   

// كل الكائنات ترجع true 
console . log ( Boolean ( this ) === true ); console . log ( Boolean ({}) === true ); console . log ( Boolean ([]) === true );  
    
    

// هذه الأنواع تعيد قيمة false 
console . log ( Boolean ( null ) === false ); console . log ( Boolean ( undefined ) === false ); // تعادل Boolean()

يقوم عامل NOT بتقييم متغيره كقيمة منطقية ويعيد النفي. يؤدي استخدام العامل مرتين على التوالي، كقيمة سلبية مزدوجة ، إلى تحويل تعبير بشكل صريح إلى بدائي من النوع المنطقي: 

console.log ( ! 0 === Boolean ( ! 0 ) ); console.log ( ! 1 === Boolean ( ! 0 ) === !! 1 ); console.log ( !! 0 === Boolean ( ! 1 )); console.log( ! 1 === Boolean ( ! 1 ) ) ; console.log ( ! "" === Boolean ( ! " " ) ) ; console.log( ! "" === !! "s"); console.log( !! "s" === Boolean( "s " )); console.log( !! " " === Boolean ( " " ) ) ; console.log ( Boolean ( " " ) === ! " s " ) ; console.log ( !! " " === Boolean ( " " ) ) ; console.log ( Boolean ( " " ) === ! "s "); console.log ( !! " " === Boolean ( " " ) ) ; console.log ( Boolean ( " " ) === ! "s" ) ; console . سجل ( ! "s" === Boolean ( ! "s" ));

يمكن أيضًا استخدام العامل الثلاثي للتحويل الصريح: 

console . log ([] == false ); console . log ([] ? true : false ); // "truthy"، ولكن المقارنة تستخدم [].toString() console . log ([ 0 ] == false ); console . log ([ 0 ] ? true : false ); // [0].toString() == "0" console . log ( "0" == false ); console . log ( "0" ? true : false ); // "0" → 0 ... (0 == 0) ... 0 ← false console . log ([ 1 ] == true ); console . log ([ 1 ] ? true : false ); // [1].toString() == "1" console . log ( " 1" == true ); console . log ( "1" ? true : false ); // "1" → 1 ... (1 == 1) ... 1 ← true console . log ([ 2 ] != true ); console . log ([ 2 ] ? true : false ); // [2].toString() == "2" console . log ( "2" != true ); console . log ( "2" ? true : false ); // "2" → 2 ... (2 != 1) ... 1 ← true

إن التعبيرات التي تستخدم ميزات مثل الزيادة اللاحقة ( ) لها تأثير جانبيi++ متوقع . توفر JavaScript تقييمًا مختصرًا للتعبيرات؛ يتم تنفيذ المتغير الأيمن فقط إذا لم يكن المتغير الأيسر كافيًا لتحديد قيمة التعبير. 

console.log ( a || b ); // عندما تكون a صحيحة، فلا يوجد سبب لتقييم b. console.log ( a && b ) ; // عندما تكون a خاطئة، فلا يوجد سبب لتقييم b. console.log(c ? t: f ) ; // عندما تكون c صحيحة ، فلا يوجد سبب لتقييم f .

في الإصدارات المبكرة من JavaScript و JScript ، أرجعت المعاملات المنطقية الثنائية قيمة منطقية (مثل معظم لغات البرمجة المشتقة من C). ومع ذلك، فإن جميع التطبيقات المعاصرة تعيد أحد متغيراتها بدلاً من ذلك: 

console . log ( a || b ); // إذا كانت a صحيحة، فقم بإرجاع a، وإلا فقم بإرجاع b console . log ( a && b ); // إذا كانت a خاطئة، فقم بإرجاع a، وإلا فقم بإرجاع b

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

const s = t || "(default)" ; // يعين t، أو القيمة الافتراضية، إذا كان t فارغًا، أو فارغًا، وما إلى ذلك.

التعيين المنطقي

??= تعيين فارغ
||= منطقي أو واجب
&&= منطقي وتكليف

بت وايز

يدعم JavaScript مشغلات البتات الثنائية التالية :

& و
| أو
^ إكس أو آر
! لا
<< التحول إلى اليسار (ملء صفر في اليمين)
>> التحول إلى اليمين (نشر الإشارة)؛
يتم نقل نسخ من البت الموجود في أقصى اليسار (بت الإشارة) من اليسار
>>> انقل إلى اليمين (املأ الصفر على اليسار). بالنسبة للأرقام الموجبة،
>>وأعطي >>>نفس النتيجة.

أمثلة: 

const x = 11 & 6 ؛ console.log ( x ) ؛ // 2

يدعم JavaScript عامل البت الأحادي التالي :

~ NOT (يقلب البتات)

التعيين بالبت

يدعم JavaScript مشغلات التعيين الثنائية التالية :

&= و
|= أو
^= اكزور
<<= التحول إلى اليسار (ملء صفر في اليمين)
>>= التحول إلى اليمين (نشر الإشارة)؛
يتم نقل نسخ من البت الموجود في أقصى اليسار (بت الإشارة) من اليسار
>>>= انقل إلى اليمين (املأ الصفر على اليسار). بالنسبة للأرقام الموجبة،
>>=وأعطي >>>=نفس النتيجة.

أمثلة: 

دع x = 7 ؛ console.log ( x )؛ // 7 x << = 3 ؛ console.log ( x )؛ // 7->14->28- > 56

خيط

= تكليف
+ سلسلة
+= ربط وتعيين

أمثلة: 

دع str = "ab" + "cd" ؛ // "abcd" str += "e" ; // "اي بي سي دي"       
        

const str2 = "2" + 2 ; // "22"، وليس "4" أو 4.

؟؟

أقرب مشغل لجافا سكريبت?? هو "عامل الاندماج الصفري"، والذي تمت إضافته إلى المعيار في الإصدار الحادي عشر من ECMAScript . [14] في الإصدارات السابقة، يمكن استخدامه عبر مكون إضافي لـ Babel ، وفي TypeScript . يقوم بتقييم المتعامل الأيسر، وإذا لم تكن قيمة النتيجة "صفرية" ( nullأو undefined)، فإنه يأخذ تلك القيمة كنتيجة له؛ وإلا فإنه يقيم المتعامل الأيمن ويأخذ القيمة الناتجة كنتيجة له.

في المثال التالي aسيتم تعيين قيمة إذا لم تكن bالقيمة هي أو ، وإلا فسيتم تعيينها 3. bnullundefined

ثابت أ = ب ؟؟ 3 ؛

قبل عامل الاندماج الصفري، كان المبرمجون يستخدمون عامل OR المنطقي ( ||). ولكن حيث ??يبحث العامل تحديدًا عن nullأو undefined، ||يبحث العامل عن أي قيمة خاطئة: null، undefined، ""، 0، NaN، وبالطبع، false.

في المثال التالي، aسيتم تعيين القيمة bإذا كانت قيمة bصحيحة، وإلا فسيتم تعيينها 3. 

ثابت أ = ب || 3 ؛

هياكل الرقابة

عبارات مركبة

يشكل زوج من الأقواس المتعرجة { }وتسلسل مغلق من العبارات عبارة مركبة، والتي يمكن استخدامها حيثما يمكن استخدام عبارة.

إذا ... وإلا

إذا ( expr ) { //عبارات؛ } وإلا إذا ( expr2 ) { //عبارات؛ } وإلا { //عبارات؛ }

عامل شرطي (ثلاثي)

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

النتيجة الثابتة = الشرط ؟ التعبير : البديل ؛

هو نفس الشيء: 

إذا ( شرط ) { نتيجة ثابتة = تعبير ؛ } وإلا { نتيجة ثابتة = بديل ؛ }

على عكس عبارة if ، لا يمكن لمشغل الشرط حذف "فرعه الآخر".

بيان التبديل

بناء جملة عبارة التبديل في JavaScript هو كما يلي: 

 switch ( expr ) { case SOMEVALUE : // عبارات؛ break ؛ case ANOTHERVALUE : // عبارات عندما يكون ANOTHERVALUE || ORNAOTHERONE // لا توجد عبارة break، تقع في الحالة التالية case ORANOTHERONE : // عبارات خاصة بـ ORANOTHERONE (أي !ANOTHERVALUE && ORANOTHER)؛ break ؛ // تتوقف المسؤولية هنا. case YETANOTHER : // عبارات؛ break ؛ default : // عبارات؛ break ؛ }
  • break;يعد هذا اختياريًا؛ ومع ذلك، فهو ضروري عادةً، لأنه بخلاف ذلك سيستمر تنفيذ التعليمات البرمجية إلى نص كتلة الحالة التالية. يمكن استخدام سلوك السقوط هذا عندما تنطبق نفس مجموعة العبارات في عدة حالات، مما يؤدي فعليًا إلى إنشاء فصل بين هذه الحالات.
  • أضف عبارة break إلى نهاية الحالة الأخيرة كإجراء احترازي، في حالة إضافة حالات إضافية لاحقًا.
  • يمكن أيضًا استخدام القيم الحرفية للسلسلة لقيم الحالة.
  • يمكن استخدام التعبيرات بدلاً من القيم.
  • يتم تنفيذ الحالة الافتراضية (اختياري) عندما لا يتطابق التعبير مع أي حالات أخرى محددة.
  • يجب استخدام الأقواس.

حلقة من أجل

بناء جملة حلقة JavaScript for هو كما يلي: 

 for ( initial ؛ condition ؛ loop statement ) { /*    سيتم تنفيذ العبارات في كل مرة يتم فيها    تشغيل حلقة for{}، طالما    تم استيفاء الشرط   */ }

أو 

 بالنسبة إلى ( البداية ؛ الشرط ؛ عبارة الحلقة ( التكرار )) // عبارة واحدة

ل... في الحلقة

بناء جملة JavaScript for ... in loopهو كما يلي: 

بالنسبة إلى ( var property_name في some_object ) { // العبارات التي تستخدم some_object[property_name]؛ }
  • يتكرر خلال جميع الخصائص القابلة للعد في الكائن.
  • يتكرر خلال كل الفهارس المستخدمة في المصفوفة بما في ذلك كل الخصائص التي يحددها المستخدم لكائن المصفوفة، إن وجدت. وبالتالي قد يكون من الأفضل استخدام حلقة for التقليدية مع فهرس رقمي عند التكرار عبر المصفوفات.
  • توجد اختلافات بين متصفحات الويب المختلفة فيما يتعلق بالخصائص التي سيتم عكسها باستخدام عبارة حلقة for...in. من الناحية النظرية، يتم التحكم في ذلك بواسطة خاصية حالة داخلية محددة بواسطة معيار ECMAscript المسمى "DontEnum"، ولكن في الممارسة العملية، يقوم كل متصفح بإرجاع مجموعة مختلفة قليلاً من الخصائص أثناء الفحص الذاتي. من المفيد اختبار خاصية معينة باستخدام }. وبالتالي، فإن إضافة طريقة إلى النموذج الأولي للمصفوفة باستخدام }. قد يتسبب في تكرار الحلقات على اسم الطريقة.if (some_object.hasOwnProperty(property_name)) { ...Array.prototype.newMethod = function() {...for ... in

حلقة أثناء

بناء جملة حلقة while في JavaScript هو كما يلي: 

بينما ( شرط ) { بيان 1 ؛ بيان 2 ؛ بيان 3 ؛ ... }

افعل ... حلقة while

بناء جملة JavaScript do ... while loopهو كما يلي: 

افعل { بيان 1 ؛ بيان 2 ؛ بيان 3 ؛ ... } بينما ( شرط )؛

مع

تضيف عبارة with جميع خصائص وطرق الكائن المحدد إلى نطاق الكتلة التالية، مما يسمح بالإشارة إليها كما لو كانت متغيرات محلية. 

مع ( المستند ) { ثابت أ = getElementById ( 'أ' )؛ ثابت ب = getElementById ( 'ب' )؛ ثابت ج = getElementById ( 'ج' )؛ };
  • لاحظ غياب document. قبل كل استدعاء getElementById() .

الدلالات مشابهة لبيان with في باسكال .

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

العلامات

يدعم JavaScript العلامات المتداخلة في معظم التطبيقات. يمكن تسمية الحلقات أو الكتل لعبارة break، والحلقات لـ continue. على الرغم من gotoأنها كلمة محجوزة، إلا أن [15] goto غير منفذة في JavaScript. 

loop1 : for ( let a = 0 ; a < 10 ; ++ a ) { if ( a === 4 ) break loop1 ; // يتوقف بعد المحاولة الرابعة console.log ( 'a = ' + a ); loop2 : for ( let b = 0 ; b < 10 ; ++ b ) { if ( b === 3 ) continue loop2 ; // يتم تخطي الرقم 3 if ( b === 6 ) continue loop1 ; // يستمر في الحلقة الأولى، ولا يتم عرض كلمة 'finished' console.log ( ' b = ' + b ) ; } // نهاية الحلقة2 console.log ( ' finished' ); } // نهاية الحلقة1 block1 : { console.log ( ' Hello' ); // يعرض كلمة ' Hello' break block1 ; console.log ( 'World' ); // لن يصل إلى هنا أبدًا } goto block1 ; // خطأ في التحليل .

الوظائف

الدالة عبارة عن كتلة تحتوي على قائمة معلمات (ربما تكون فارغة) يتم إعطاؤها اسمًا عادةً. قد تستخدم الدالة متغيرات محلية. إذا خرجت من الدالة بدون عبارة return، فسيتم إرجاع القيمة undefined .

دالة gcd ( number1 , number2 ) { if ( isNaN ( number1 * number2 )) throw TypeError ( " غير مسموح بالحجج غير الرقمية." ); number1 = Math.round ( number1 ); number2 = Math.round ( number2 ) ; let Difference = number1 - number2 ; if ( five === 0 ) return number1 ; return Difference > 0 ? gcd ( number2 , Difference ) : gcd ( number1 , - Difference ) ; } console.log ( gcd ( 60 , 40 ) ) ; // 20   
     
    
    
       
       
           

  

//في حالة عدم وجود أقواس بعد المعرف 'gcd' على الجانب الأيمن من التعيين أدناه، 
//'gcd' يعيد مرجعًا إلى الدالة نفسها دون استدعائها. 
let mygcd = gcd ; // mygcd و gcd يشيران إلى نفس الدالة. console . log ( mygcd ( 60 , 40 )); // 20

الوظائف هي كائنات من الدرجة الأولى ويمكن تخصيصها لمتغيرات أخرى.

قد لا يتوافق عدد الوسائط المعطاة عند استدعاء دالة بالضرورة مع عدد الوسائط في تعريف الدالة؛ فالوسيطة المسماة في التعريف التي لا تحتوي على وسيطة مطابقة في الاستدعاء سيكون لها القيمة غير المحددة (والتي يمكن تحويلها ضمناً إلى false). داخل الدالة، يمكن أيضًا الوصول إلى الوسائط من خلال كائن الوسائط ؛ وهذا يوفر الوصول إلى جميع الوسائط باستخدام الفهارس (على سبيل المثال )، بما في ذلك تلك التي تتجاوز عدد الوسائط المسماة. (بينما تحتوي قائمة الوسائط على خاصية، إلا أنها ليست مثيلًا لـ Array ؛ ولا تحتوي على طرق مثل .slice() و. sort() وما إلى ذلك.) arguments[0], arguments[1], ... arguments[n].length

دالة add7 ( x , y ) { if ( ! y ) { y = 7 ; } console.log ( x + y + arguments.length ) ; } ; add7 ( 3 ); // 11 add7 ( 3 , 4 ) ; // 9

يتم تمرير القيم الأولية (الرقم، القيمة المنطقية، السلسلة) حسب القيمة. بالنسبة للكائنات، يتم تمرير المرجع إلى الكائن. 

const obj1 = { a : 1 } ; const obj2 = { b : 2 }; function foo ( p ) { p = obj2 ; // يتجاهل المعلمة الفعلية p.b = arguments [ 1 ]; } foo ( obj1 , 3 ); // لا يؤثر على obj1 على الإطلاق. 3 هو معلمة إضافية console.log ( ` $ { obj1.a } $ { obj2.b } ` ) ; // يكتب 1 3

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

دع t = " Top" ؛ دع bar ، baz ؛ دالة foo () { دع f = " foo var" ؛ bar = دالة () { console.log ( f ) }؛ baz = دالة ( x ) { f = x ؛ }؛ } foo ()؛ baz ( "baz arg" )؛ bar ()؛ // "baz arg " (ليس "foo var") حتى لو تم الخروج من foo(). console.log ( t ) ؛ // Top

غير متزامن/انتظار

لا يمكن استخدام عامل الانتظار في JavaScript إلا من داخل دالة غير متزامنة أو في المستوى الأعلى من الوحدة النمطية . إذا كانت المعلمة عبارة عن وعد ، فسيتم استئناف تنفيذ الدالة غير المتزامنة عند حل الوعد (ما لم يتم رفض الوعد، وفي هذه الحالة سيتم إلقاء خطأ يمكن التعامل معه باستخدام معالجة استثناءات JavaScript العادية ). إذا لم تكن المعلمة عبارة عن وعد، فسيتم إرجاع المعلمة نفسها على الفور. [16]

توفر العديد من المكتبات كائنات وعد يمكن استخدامها أيضًا مع await، طالما أنها تتطابق مع مواصفات وعود JavaScript الأصلية. ومع ذلك، لم تكن الوعود من مكتبة jQuery متوافقة مع Promises/A+ حتى jQuery 3.0. [17]

فيما يلي مثال (تم تعديله من هذه المقالة [18] ): 

دالة async createNewDoc () { let response = await db.post ( { }); // انشر مستندًا جديدًا return db.get ( response.id ); // البحث حسب المعرف }   
       
    


دالة غير متزامنة main () { حاول { دع doc = await createNewDoc ( ); console.log ( doc ) ; } catch ( err ) { console.log ( err ); } } main ( ) ;
تتضمن النسخة 8 من Node.js أداة مساعدة تتيح استخدام أساليب استدعاء المكتبة القياسية باعتبارها وعودًا. [19]

أشياء

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

تحتوي لغة JavaScript على عدة أنواع من الكائنات المضمنة، وهي Array, Boolean, Date, Function, Math, Number, Object, RegExpو String. أما الكائنات الأخرى فهي "كائنات مضيفة"، لا يتم تعريفها بواسطة اللغة، بل بواسطة بيئة التشغيل. على سبيل المثال، في المتصفح، تنتمي كائنات المضيف النموذجية إلى DOM (النافذة، والنموذج، والروابط، وما إلى ذلك).

إنشاء الكائنات

يمكن إنشاء الكائنات باستخدام منشئ أو كائن حرفي. يمكن للمنشئ استخدام دالة كائن مضمنة أو دالة مخصصة. من المعتاد أن يتم إعطاء وظائف المنشئ اسمًا يبدأ بحرف كبير: 

// المنشئ 
const anObject = new Object ();    

// كائن حرفي 
const objectA = {}; const objectA2 = {}; // A != A2, {}s إنشاء كائنات جديدة كنسخ. const objectB = { index1 : 'value 1' , index2 : 'value 2' };   
     
      

// منشئ مخصص (انظر أدناه)

تسمح لك كائنات الحرفي وحرفيات المصفوفة بإنشاء هياكل بيانات مرنة بسهولة: 

const myStructure = { الاسم : { الأول : "ميل" ، الأخير : "سميث" }، العمر : 33 ، الهوايات : [ "الشطرنج" ، "الركض" ] };

هذا هو الأساس لـ JSON ، وهو تدوين بسيط يستخدم صيغة تشبه صيغة JavaScript لتبادل البيانات.

طُرق

الطريقة هي ببساطة دالة تم تعيينها لاسم خاصية لكائن. وعلى عكس العديد من اللغات الموجهة للكائنات، لا يوجد تمييز بين تعريف الدالة وتعريف الطريقة في JavaScript المرتبطة بالكائنات. بل يحدث التمييز أثناء استدعاء الدالة؛ حيث يمكن استدعاء الدالة كطريقة.

عند استدعائها كطريقة، يتم تعيين المتغير المحلي القياسي this تلقائيًا إلى مثيل الكائن على يسار " . ". (توجد أيضًا طرق call و apply التي يمكنها تعيين this صراحةً - بعض الحزم مثل jQuery تفعل أشياء غير عادية مع this .)

في المثال أدناه، يتم استخدام Foo كمنشئ. لا يوجد شيء خاص في المنشئ - فهو مجرد دالة بسيطة تقوم بتهيئة كائن. عند استخدامه مع الكلمة الأساسية new ، كما هو الحال عادة، يتم تعيين this على كائن فارغ تم إنشاؤه حديثًا.

لاحظ أنه في المثال أدناه، يقوم Foo ببساطة بتعيين قيم للفتحات، بعضها عبارة عن وظائف. وبالتالي، يمكنه تعيين وظائف مختلفة لمثيلات مختلفة. لا يوجد نموذج أولي في هذا المثال. 

دالة px () { إرجاع هذا البادئة + " X" ؛ }       

دالة Foo ( yz ) { this.prefix = " a- " ; if ( yz > 0 ) { this.pyz = function ( ) { return this.prefix + " Y " ; } ; } else { this.pyz = function ( ) { return this.prefix + " Z " ; } ; } this.m1 = px ; return this ; }​​  
    
      
            
    
            
  
    
   


const foo1 = new Foo ( 1 ); const foo2 = new Foo ( 0 ); foo2 . prefix = "b-" ;    
    
  

console.log ( "foo1 / 2" + foo1.pyz () + foo2.pyz ()); // foo1 / 2 aY bZ    


foo1 . m3 = px ; // يعين الدالة نفسها، وليس نتيجتها المقيمة، أي ليس px() const baz = { "prefix" : "c-" }; baz . m4 = px ; // ليست هناك حاجة إلى منشئ لإنشاء كائن.   
    
   

console.log ( " m1/m3/m4" + foo1.m1 ( ) + foo1.m3 ( ) + baz.m4 ( ) ) ; // m1/m3/m4 aX aX cX      


foo1 . m2 (); // يُلقي استثناءً، لأن foo1.m2 غير موجود.

البناة

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

مثال: التلاعب بالكائن: 

دالة MyObject ( attributeA , attributeB ) { this.attributeA = attributeA ; this.attributeB = attributeB ; }​​​​   
    
    


MyObject . staticC = "blue" ; // في دالة MyObject، وليس الكائن console . log ( MyObject . staticC ); // blue   
 

كائن ثابت = كائن MyObject جديد ( 'أحمر' ، 1000 )؛     

console.log ( object.attributeA ) ; // أحمر console.log ( object.attributeB ) ; // 1000​​​​ 
 

console.log ( object.staticC ); // undefined object.attributeC = new Date ( ) ; // إضافة خاصية جديدة 
    

حذف الكائن . attributeB ؛ // إزالة خاصية الكائن console.log ( object . attributeB ) ؛ // غير محدد

يتم الرجوع إلى المنشئ نفسه في فتحة المنشئ الخاصة بالنموذج الأولي للكائن . لذا، 

// استخدام "new" يحدد فتحات النموذج الأولي (على سبيل المثال، // x = new Foo() سيضبط النموذج الأولي لـ x إلى Foo.prototype، // وFoo.prototype لديه فتحة منشئ تشير إلى Foo). const x = new Foo ( ) ; // ما سبق يعادل تقريبًا const y = { }; y . buildor = Foo ; y . buildor (); // باستثناء x . buildor == y . buildor ; // true x instanceof Foo ; // true y instanceof Foo ; // false // النموذج الأولي لـ y هو Object.prototype، وليس // Foo.prototype، لأنه تم تهيئته باستخدام // {} بدلاً من new Foo. // على الرغم من تعيين Foo على فتحة منشئ y، // يتم تجاهل هذا بواسطة instanceof - يتم اعتبار فتحة منشئ النموذج الأولي لـ y فقط .

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

نادرًا ما يتم استخدام حذف الكائن لأن محرك النصوص سوف يقوم بتجميع الكائنات التي لم تعد تتم الإشارة إليها.

الميراث

يدعم JavaScript التسلسل الهرمي للوراثة من خلال النمذجة الأولية بطريقة Self .

في المثال التالي، ترث الفئة Derived من الفئة Base . عند إنشاء d كـ Derived ، يتم نسخ المرجع إلى المثيل الأساسي لـ Base إلى d.base .

لا يحتوي Derive على قيمة لـ aBaseFunction ، لذا يتم استردادها من aBaseFunction عند الوصول إلى aBaseFunction . يتضح هذا من خلال تغيير قيمة base.aBaseFunction ، وهو ما ينعكس في قيمة d.aBaseFunction .

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

دالة Base () { this.anOverride = function ( ) { console.log ( " Base :: anOverride()" ); } ;  
       

  هذا . aBaseFunction = function () { console.log ( "Base :: aBaseFunction()" ); } ; }     


دالة مشتقة () { this.anOverride = function ( ) { console.log ( " Derived::anOverride()" ) ; } ; }  
       


const base = new Base (); Derived . prototype = base ; // يجب أن يكون قبل new Derived() Derived . prototype . buildor = Derived ; // مطلوب لجعل `instanceof` يعمل    
   
   

const d = new Derived (); // نسخ Derived.prototype إلى فتحة النموذج الأولي المخفية في مثيل d. d instanceof Derived ; // true d instanceof Base ; // true        
   
      

base.aBaseFunction = function () { console.log ( " Base ::aNEWBaseFunction()" ) ; } ;     

d.anOverride ( ); // Derived ::anOverride() d.aBaseFunction ( ) ; // Base :: aNEWBaseFunction ( ) console.log ( d.aBaseFunction == Derived.prototype.aBaseFunction ) ; // true    
 
   

console.log ( d .__ proto__ == base ); // true في التنفيذات المستندة إلى Mozilla وfalse في العديد من التنفيذات الأخرى .

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

دالة m1 () { إرجاع "واحد" ؛ } دالة m2 () { إرجاع "اثنين" ؛ } دالة m3 () { إرجاع "ثلاثة" ؛ }     
     
     

دالة Base () {}  

قاعدة .prototype .m = m2 ؛ const bar = new Base ( ) ؛ console .log ( "bar.m " + bar .m ()); // bar.m اثنان  
    
   

دالة Top ( ) { this.m = m3 ; } const t = new Top () ;      
    

const foo = new Base (); Base .prototype = t ; // لا يوجد تأثير على foo، يتم نسخ *المرجع* إلى t. console . log ( "foo.m " + foo . m ()); // foo.m اثنان    
  

   

const baz = new Base (); console.log ( " baz.m" + baz.m ()) ; // baz.m ثلاثة    
   

t.m = m1 ؛ // هل يؤثر على baz وأي فئات مشتقة أخرى. console.log ( " baz.m1" + baz.m ( )); // baz.m1 واحد

في الممارسة العملية، يتم استخدام العديد من الاختلافات لهذه المواضيع، ويمكن أن تكون قوية ومربكة في نفس الوقت.

معالجة الاستثناءات

يتضمن JavaScript عبارة try ... catch ... finally معالجة الاستثناءات للتعامل مع أخطاء وقت التشغيل.

try ... catch ... finallyتلتقط العبارة الاستثناءات الناتجة عن خطأ أو عبارة رمي. صيغتها النحوية هي كما يلي: 

try { // العبارات التي قد يتم فيها طرح استثناءات } catch ( errorValue ) { // العبارات التي يتم تنفيذها في حالة حدوث استثناء } finally { // العبارات التي يتم تنفيذها بعد ذلك بأي طريقة }

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

في كل الأحوال، يتم تنفيذ العبارات الموجودة في الكتلة finally دائمًا. ويمكن استخدام هذا لتحرير الموارد، على الرغم من أن الذاكرة يتم تجميعها تلقائيًا.

يمكن حذف إما جملة catch أو جملة finally. يلزم وجود وسيطة catch.

يتيح تنفيذ Mozilla استخدام عبارات catch متعددة، كإضافة لمعيار ECMAScript. وهي تتبع بناء جملة مشابهًا لذلك المستخدم في Java : 

حاول { بيان ؛ } catch ( e if e == "InvalidNameException" ) { بيان ؛ } catch ( e if e == "InvalidIdException" ) { بيان ؛ } catch ( e if e == "InvalidEmailException" ) { بيان ؛ } catch ( e ) { بيان ؛ }

في المتصفح، يتم استخدام حدث onerror بشكل أكثر شيوعًا لاحتجاز الاستثناءات. 

onerror = function ( errorValue , url , lineNr ) {...; return true ;};

الوظائف والطرق الأصلية

(لا علاقة لها بمتصفحات الويب.)

تقييم (تعبير)

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

> ( دالة foo () { ... var x = 7 ؛ ... console.log ( " val " + eval ( "x + 2" )); ... } )(); val 9 غير محدد

انظر أيضا

مراجع

  1. ^ مواصفات JavaScript 1.1
  2. ^ "الفصل 1. أساسيات جافا سكريبت". speakingjs.com . مؤرشف من الأصل في 10 فبراير 2022 . تم الاسترجاع 22 سبتمبر 2020 .
  3. ^ فلاناغان، ديفيد (2006). JavaScript: The definitive Guide . ص 16. ISBN 978-0-596-10199-2إن حذف الفواصل المنقوطة ليس ممارسة برمجة جيدة؛ لذا يجب عليك أن تتعود على إدراجها.
  4. ^ "تخزين المعلومات التي تحتاجها - المتغيرات - تعلم تطوير الويب | MDN". developer.mozilla.org . 9 مايو 2023 . تم الاسترجاع في 23 يونيو 2023 .
  5. ^ "القيم والمتغيرات والحرفيات - MDC". شبكة مطوري موزيلا. 16 سبتمبر 2010. مؤرشف من الأصل في 29 يونيو 2011. تم الاسترجاع 1 فبراير 2020 .
  6. ^ "JavaScript Hoisting". W3Schools . في JavaScript، يمكن إعلان المتغير بعد استخدامه. بعبارة أخرى؛ يمكن استخدام المتغير قبل إعلانه.
  7. ^ "JavaScript Scoping and Hoisting"، Ben Cherry، Adequately Good، 2010-02-08
  8. ^ أوضحت طبعة ECMA-262 5e هذا السلوك باستخدام سجل البيئة الإعلانية وسجل بيئة الكائن . باستخدام هذه الصيغة، يكون الكائن العالمي هو سجل بيئة الكائن للبيئة المعجمية العالمية ( النطاق العالمي ).
  9. ^ "حرفيات القالب". وثائق ويب MDN . تم الاسترجاع في 4 نوفمبر 2023 .
  10. ^ "مشغلات المقارنة - مركز وثائق MDC". موزيلا. 5 أغسطس 2010. تم الاسترجاع في 5 مارس 2011 .
  11. ^ "عناصر أسلوب JavaScript". دوغلاس كروكفورد . تم الاسترجاع في 5 مارس 2011 .
  12. ^ "نحو الانتشار (...) - JavaScript | MDN". developer.mozilla.org . 25 سبتمبر 2023.
  13. ^ "معلمات الراحة".
  14. ^ "مواصفات لغة ECMAScript 2020". Ecma International . يونيو 2020.
  15. ^ ECMA-262، الإصدار 3، 7.5.3 الكلمات المحجوزة للمستقبل
  16. ^ "await - JavaScript (MDN)" . تم الاسترجاع في 2 مايو 2017 .
  17. ^ "دليل ترقية jQuery Core 3.0" . تم الاسترجاع في 2 مايو 2017 .
  18. ^ "ترويض الوحش غير المتزامن باستخدام ES7" . تم الاسترجاع في 12 نوفمبر 2015 .
  19. ^ Foundation, Node.js (30 مايو 2017). "Node v8.0.0 (Current) - Node.js". Node.js .
  20. ^ "eval()". وثائق ويب MDN . تم الاسترجاع في 29 يناير 2020 .

قراءة إضافية

  • داني جودمان: الكتاب المقدس بلغة جافا سكريبت ، وايلي، جون وأولاده، رقم ISBN 0-7645-3342-8 . 
  • ديفيد فلاناغان، باولا فيرجسون: جافا سكريبت: الدليل النهائي ، أوريلي وشركاه، ISBN 0-596-10199-6 . 
  • توماس أ. باول، فريتز شنايدر: جافا سكريبت: المرجع الكامل ، شركات ماكجرو هيل، ISBN 0-07-219127-9 . 
  • أكسل راوشماير: التحدث بلغة جافا سكريبت: دليل متعمق للمبرمجين ، 460 صفحة، أوريلي ميديا، 25 فبراير 2014، ISBN 978-1449365035 . (إصدار مجاني عبر الإنترنت) 
  • إميلي فاندير فير: جافا سكريبت للمبتدئين، الطبعة الرابعة ، وايلي، ISBN 0-7645-7659-3 . 
يحتوي موقع Wikibooks على كتاب حول موضوع: JavaScript
  • إعادة تقديم JavaScript - مركز مطوري Mozilla
  • حلقات جافا سكريبت
  • مراجع معيار ECMAScript: ECMA-262
  • دروس JavaScript التفاعلية - تعتمد على الأمثلة
  • JavaScript على About.com: دروس وشرح أرشيف 25 فبراير 2017 على موقع Wayback Machine
  • تدريب جافا سكريبت
  • مراجع أساسية لمركز مطوري Mozilla لإصدارات JavaScript 1.5 و1.4 و1.3 و1.2
  • توثيق لغة JavaScript في Mozilla
Retrieved from "https://en.wikipedia.org/w/index.php?title=JavaScript_syntax&oldid=1249089027"
Original text
Rate this translation
Your feedback will be used to help improve Google Translate