ما هو النظام المعياري غير الموجود في جافا سكريبت. العمليات في جافا سكريبت
بعد أن تحدثنا عن الأولويات والترابط والقضايا البسيطة الأخرى، يمكننا أن نبدأ في مناقشة المشغلين أنفسهم. يقدم هذا القسم وصفًا للعوامل الحسابية:
إضافة (+)
يضيف عامل الجمع معاملات رقمية أو ينفذ سلسلة تسلسلية. إذا كان أحد المعاملات عبارة عن سلسلة، فسيتم تحويل المعامل الآخر إلى سلسلة ويتم تنفيذ التسلسل. يتم تحويل معاملات الكائن إلى أرقام أو سلاسل يمكن إضافتها أو ربطها. يتم التحويل باستخدام أساليب valueOf() و/أو toString().
الطرح (-)
عندما يتم استخدام ناقص كعامل ثنائي، فإنه يطرح المعامل الثاني من الأول. إذا تم تحديد معاملات غير رقمية، فإنه يحاول تحويلها إلى أرقام.
عمليه الضرب (*)
يقوم عامل التشغيل * بضرب معامليه. يحاول تحويل المعاملات غير الرقمية إلى أرقام.
قسم (/)
يقوم عامل التشغيل / بتقسيم المعامل الأول على المعامل الثاني. محاولات لتحويل المعاملات غير الرقمية إلى أرقام. أولئك الذين اعتادوا على لغات البرمجة التي تميز بين الأعداد الصحيحة والأعداد الحقيقية قد يتوقعون الحصول على نتيجة عدد صحيح عند قسمة عدد صحيح على آخر.
ومع ذلك، في جافا سكريبت، جميع الأرقام حقيقية، لذلك تنتج جميع الأقسام نتيجة الفاصلة العائمة. العملية 5/2 تعطي 2.5، وليس 2. القسمة على صفر تعطي زائد أو دقائق لا نهاية لها كنتيجة، و0/0 يعطي NaN.
تقسيم مودولو (٪)
يحسب عامل التشغيل % الباقي الذي يتم الحصول عليه عندما يكون المعامل الأول عددًا صحيحًا مقسومًا على المعامل الثاني. إذا تم إعطاء معاملات غير رقمية، يحاول عامل التشغيل تحويلها إلى أرقام. علامة النتيجة تطابق علامة المعامل الأول. على سبيل المثال، 5% 2 يعطي 1.
عادةً ما يتم استخدام عامل القسمة modulo مع معاملات الأعداد الصحيحة، ولكنه يعمل أيضًا مع القيم الحقيقية. على سبيل المثال، -4.3% 2.1 يعطي نتيجة -0.1.
أحادي ناقص (-)
عندما يتم استخدام ناقص كمشغل أحادي قبل معامل واحد، فإنه ينفذ عملية تغيير الإشارة الأحادية. بمعنى آخر، فإنه يحول القيمة الموجبة إلى قيمة سالبة والعكس صحيح. إذا لم يكن المعامل رقمًا، فسيحاول هذا العامل تحويله إلى رقم.
أحادي زائد (+)
للتماثل مع عامل التشغيل الأحادي ناقص، تحتوي JavaScript أيضًا على عامل تشغيل أحادي زائد. يمكنك استخدام هذا العامل لتحديد إشارة القيم الحرفية الرقمية بشكل صريح إذا كنت تعتقد أن هذا سيجعل نص البرنامج أكثر قابلية للفهم:
الربح فار = +1000000؛
في مثل هذه التعليمات البرمجية، لا يقوم عامل التشغيل plus بأي شيء؛ ونتيجة عمله هي معنى حجته.
ومع ذلك، فإنه يحول الوسائط غير الرقمية إلى أرقام. إذا تعذر تحويل الوسيطة، فسيتم إرجاع NaN.
الزيادة (++)
يزيد هذا العامل (أي يزيد بمقدار واحد) معامله الفردي، والذي يجب أن يكون متغيرًا أو عنصر صفيف أو خاصية كائن. إذا كانت قيمة هذا المتغير أو عنصر الصفيف أو الخاصية ليست رقمًا، فسيحاول عامل التشغيل أولاً تحويلها إلى رقم. يعتمد السلوك الدقيق لهذا العامل على موقعه بالنسبة للمعامل. إذا وضعته قبل المعامل (عامل زيادة البادئة)، فسيتم إضافة 1 إلى المعامل، والنتيجة هي القيمة المتزايدة للمعامل. إذا تم وضعه بعد المعامل (عامل زيادة postfix)، فسيتم إضافة 1 إلى المعامل، ولكن النتيجة هي القيمة الأصلية للمعامل. إذا لم تكن القيمة التي تتم زيادتها رقمًا، فسيتم تحويلها إلى رقم أثناء عملية الحساب.
على سبيل المثال، التعليمة البرمجية التالية تحدد المتغيرات i وj إلى 2:
أنا = 1؛
ي = ++i;
وهذا يضبط i على 2 و j على 1:
أنا = 1؛
ي = أنا++;
يُستخدم هذا العامل، في كلا شكليه، في أغلب الأحيان لزيادة العداد الذي يتحكم في الحلقة.
لاحظ أنه لا يمكنك إدراج سطر جديد بين عامل زيادة البادئة أو اللاحقة والمعامل السابق لها، حيث يتم إدراج الفواصل المنقوطة تلقائيًا في JavaScript. إذا قمت بذلك، فسوف تتعامل JavaScript مع المعامل كتعليمات كاملة وتدرج فاصلة منقوطة بعدها.
إنقاص (−−)
يعمل هذا العامل على تقليل (أي تقليل بمقدار 1) المعامل الرقمي الفردي الخاص به، والذي يمكن أن يكون متغيرًا أو عنصر صفيف أو خاصية كائن. إذا كانت قيمة هذا المتغير أو العنصر أو الخاصية ليست رقمًا، فسيحاول عامل التشغيل أولاً تحويلها إلى رقم. كما هو الحال مع عامل التشغيل ++، فإن السلوك الدقيق للعامل - يعتمد على موضعه بالنسبة لمعامله. عند وضعها قبل المعامل، فإنها تقلل المعامل وتعيد القيمة المتناقصة. بعد المعامل، فإنه يقلل المعامل ولكنه يعيد القيمة الأصلية.
إذا كنت مستخدمًا جديدًا لجافا سكريبت، فقد تكون المصطلحات مثل "أدوات تجميع النماذج مقابل أدوات تحميل الوحدات النمطية" و"Webpack مقابل Browserify" و"AMD vs. CommonJS" مربكة.
قد يكون نظام وحدات JavaScript مخيفًا، لكن فهمه أمر حيوي للمطورين.
سأحاول في هذه المقالة شرح كل شيء بكلمات بسيطة (مع بعض أمثلة التعليمات البرمجية). أتمنى أن تجد هذه المقالة مفيدة.
ملاحظة: من أجل التيسير، سيتم تقسيم المقال إلى قسمين. في الجزء الأول، سنلقي نظرة على ماهية الوحدات ولماذا نستخدمها. في الجزء الثاني، سننظر في طرق مختلفة لدمج الوحدات في وحدة متماسكة.
هل يمكن لأحد أن يشرح ما هي الوحدات مرة أخرى؟
تمامًا مثل فصول الكتاب، الوحدات هي مجرد مجموعات من الكلمات (أو التعليمات البرمجية، حسب الحالة).
تحتوي الوحدات الجيدة على وظائف قائمة بذاتها بحيث يمكن إضافتها أو نقلها أو إزالتها حسب الحاجة دون كسر النظام بأكمله.
لماذا استخدام الوحدات على الإطلاق؟
في الواقع، الوحدات لها العديد من المزايا. وأهمها في رأيي ما يلي:
- قابلية الصيانة:حسب التعريف، الوحدة قائمة بذاتها. تهدف الوحدة المصممة جيدًا إلى تقليل تبعيات أجزاء من قاعدة التعليمات البرمجية الخاصة بك قدر الإمكان حتى تتمكن من النمو والتحسن بشكل مستقل عن بعضها البعض. يكون تحديث وحدة واحدة أسهل كثيرًا عندما يتم فصلها عن أجزاء أخرى من الكود، وبالعودة إلى كتابنا، على سبيل المثال، إذا كنت تريد إجراء تغيير بسيط في فصل واحد ويستلزم ذلك تغييرات في قسم آخر من كتابك، فهذا أمر سهل. سيكون كابوسا. لذلك، يجب كتابة الفصل بطريقة لا تؤثر عند إجراء التعديلات على الفصول الأخرى.
- مساحات الأسماء:في JavaScript، تعتبر المتغيرات التي تقع خارج وظائف المستوى الأعلى عالمية (يمكن للجميع الوصول إليها). لذلك، يعد "تلوث مساحة الاسم" أمرًا شائعًا جدًا، حيث يتم ربط التعليمات البرمجية غير المرتبطة تمامًا بمتغيرات عامة. تعد مشاركة المتغيرات العامة في التعليمات البرمجية غير المرتبطة ببعضها البعض أمرًا سيئًا للغاية في التطوير. سنرى لاحقًا في هذه المقالة أن الوحدات النمطية تسمح لنا بذلك تجنب تلويث مساحة الاسم العالمية عن طريق إنشاء مساحات خاصة لمتغيراتنا.
- إعادة الاستخدام:لنكن صادقين. لقد قمنا جميعًا بنسخ التعليمات البرمجية في المشاريع الجديدة التي كتبناها من قبل. على سبيل المثال، لنتخيل أنك قمت بنسخ بعض الأساليب المساعدة من مشروع سابق إلى مشروع جديد، حسنًا، ولكن إذا وجدت أفضل طريقة لكتابة هذا الجزء، فسيتعين عليك أن تتذكر جميع الأماكن التي ظهر فيها هذا الرمز حتى تتمكن من التحديث. وهذا بالتأكيد مضيعة كبيرة للوقت. سيكون من الأسهل بكثير كتابة وحدة وإعادة استخدامها مرارًا وتكرارًا.
كيف يمكن دمج الوحدات؟
هناك طرق عديدة لدمج الوحدات في برامجك. دعونا نلقي نظرة على بعض منهم:
نمط "الوحدة"
يُستخدم نمط الوحدة النمطية لمحاكاة مفهوم الفئات (نظرًا لأن JavaScript لم تكن تدعم الفئات أصلاً)، حتى نتمكن من تخزين الأساليب العامة والخاصة (المتغيرات) داخل كائن واحد، تمامًا مثل الفئات الموجودة في لغات أخرى مثل Java أو Python . يتيح لنا ذلك إنشاء واجهة برمجة تطبيقات عامة وتوفير القدرة على الوصول إلى الأساليب العامة، بينما يتم تغليف المتغيرات والأساليب الخاصة في عملية إغلاق.
هناك عدة طرق لتنفيذ نمط الوحدة النمطية. في المثال الأول سأستخدم عمليات الإغلاق المجهولة. سيساعدنا وضع الكود في وظيفة مجهولة على تحقيق هدفنا. (تذكر أن الوظائف في JavaScript هي الطريقة الوحيدة لإنشاء نطاق جديد).
مثال 1: عمليات الإغلاق المجهولة
(function () ( // نحافظ على خصوصية هذه المتغيرات داخل نطاق الإغلاق هذا var myGrades = ; var Average = function() ( var Total = myGrades.reduce(function(accumulator, item) ( returncumulator + item), 0); إرجاع "متوسط درجتك هو " + الإجمالي / myGrades.length + ") var Failing = function())( var FailingGrades = myGrades.filter(function(item) (عنصر الإرجاع< 70;}); return "You failed " + failingGrades.length + " times."; } console.log(failing()); }());
بهذه الطريقة، يكون لوظيفتنا المجهولة نطاقها الخاص أو "إغلاقها" ويمكننا تنفيذها على الفور. تسمح لنا هذه الطريقة بإخفاء المتغيرات من النطاق الأصلي (العالمي).
الشيء الجميل حقًا في هذا الأسلوب هو أنه يمكنك استخدام المتغيرات المحلية داخل هذه الوظيفة وعدم الخوف من الكتابة فوق المتغيرات العامة عن طريق الخطأ بنفس الاسم. ولكن لا يزال بإمكانك الوصول إلى المتغيرات العالمية، على سبيل المثال مثل هذا:
var global = "مرحبًا، أنا متغير عام :)"; (function () ( // نحافظ على خصوصية هذه المتغيرات داخل نطاق الإغلاق هذا var myGrades = ; var Average = function() ( var Total = myGrades.reduce(function(accumulator, item) ( returncumulator + item), 0); إرجاع "متوسط درجتك هو " + الإجمالي / myGrades.length + ") var Failing = function())( var FailingGrades = myGrades.filter(function(item) (عنصر الإرجاع< 70;}); return "You failed " + failingGrades.length + " times."; } console.log(failing()); console.log(global); }()); // "You failed 2 times." // "Hello, I am a global variable:)"
المثال 2: الاستيراد العالمي
هناك طريقة شائعة أخرى تستخدمها المكتبات مثل jQuery وهي الاستيراد العالمي. إنه مشابه لعمليات الإغلاق التي رأيناها للتو، لكننا الآن نقوم بتمرير المتغيرات العالمية كمعلمات.
(function (globalVariable) ( // احتفظ بهذه المتغيرات خاصة داخل نطاق الإغلاق هذا var PrivateFunction = function() ( console.log("Shhhh, this is Private!"); ) // كشف الطرق أدناه عبر واجهة globalVariable أثناء / / إخفاء تنفيذ الطريقة داخل كتلة // function() globalVariable.each = function(collection, iterator) ( if (Array.isArray(collection)) ( for (var i = 0; i< collection.length; i++) { iterator(collection[i], i, collection); } } else { for (var key in collection) { iterator(collection, key, collection); } } }; globalVariable.filter = function(collection, test) { var filtered = ; globalVariable.each(collection, function(item) { if (test(item)) { filtered.push(item); } }); return filtered; }; globalVariable.map = function(collection, iterator) { var mapped = ; globalUtils.each(collection, function(value, key, collection) { mapped.push(iterator(value)); }); return mapped; }; globalVariable.reduce = function(collection, iterator, accumulator) { var startingValueMissing = accumulator === undefined; globalVariable.each(collection, function(item) { if(startingValueMissing) { accumulator = item; startingValueMissing = false; } else { accumulator = iterator(accumulator, item); } }); return accumulator; }; }(globalVariable));
في هذا المثال، GlobalVariable هو المتغير العام الوحيد. ميزة هذا الأسلوب هو أنك تعلن عن جميع المتغيرات العامة مقدمًا، مما يجعل التعليمات البرمجية الخاصة بك شفافة للآخرين.
المثال 3: واجهة الكائن
هناك طريقة أخرى لإنشاء الوحدات وهي استخدام واجهات مستقلة قائمة على الكائنات، مثل هذا:
var myGradesCalculate = (function () ( // احتفظ بهذا المتغير خاصًا داخل نطاق الإغلاق هذا var myGrades = ; // كشف هذه الوظائف عبر واجهة أثناء إخفاء // تنفيذ الوحدة داخل كتلة الوظيفة () return ( Average: function () ( var Total = myGrades.reduce(function(accumulator, item) (returnتراكم + item; ), 0); return"متوسط درجتك هو " + الإجمالي / myGrades.length + "."; , فاشل: الوظيفة () ( var FailingGrades = myGrades.filter(function(item) ( return item< 70; }); return "You failed " + failingGrades.length + " times."; } } })(); myGradesCalculate.failing(); // "You failed 2 times." myGradesCalculate.average(); // "Your average grade is 70.33333333333333."
كما لاحظت، يتيح لنا هذا الأسلوب تحديد المتغيرات (الطرق) التي نريد جعلها خاصة (على سبيل المثال، علاماتي )، وأيها تكون عامة عن طريق وضعها في الكائن الذي تم إرجاعه (على سبيل المثال، متوسط و فشل ).
المثال 4: نمط الوحدة المنسدلة
هذا المثال مشابه جدًا للمثال السابق باستثناء أن جميع الأساليب والمتغيرات تظل خاصة حتى يتم الكشف عنها بشكل صريح.
var myGradesCalculate = (function () ( // احتفظ بهذا المتغير خاصًا داخل نطاق الإغلاق هذا var myGrades = ; var Average = function() ( var Total = myGrades.reduce(function(accumulator, item) ( إرجاع المركم + العنصر; ), 0); return"متوسط درجتك هو" + الإجمالي / myGrades.length + "."< 70; }); return "You failed " + failingGrades.length + " times."; }; // Explicitly reveal public pointers to the private functions // that we want to reveal publicly return { average: average, failing: failing } })(); myGradesCalculate.failing(); // "You failed 2 times." myGradesCalculate.average(); // "Your average grade is 70.33333333333333."
قد يبدو هذا كثيرًا من المعلومات، لكنه مجرد غيض من فيض عندما يتعلق الأمر بأنماط الوحدات. فيما يلي بعض الموارد المفيدة التي وجدتها في بحثي:
- بقلم آدي عثماني: هذا كنز دفين من التفاصيل ومحتوى مختصر مثير للإعجاب؛
- جيد بشكل كافٍ بقلم Ben Cherry: نظرة عامة مفيدة مع أمثلة للاستخدام المتقدم لنمط الوحدة؛
- مدونة Carl Danley: نظرة عامة على نمط الوحدة والموارد لأنماط JavaScript الأخرى؛
CommonJS و AMD
تشترك جميع الطرق المذكورة أعلاه في شيء واحد: تقوم جميعها بإنشاء متغير عام واحد تضع فيه رمز الوظيفة، وبالتالي إنشاء مساحة اسم خاصة واستخدام نطاق الإغلاق.
في حين أن كل من هذه الأساليب فعالة بطريقتها الخاصة، إلا أن لها عيوبها أيضًا.
كمطور، تحتاج إلى معرفة الترتيب الصحيح لتحميل الملفات. على سبيل المثال، لنفترض أنك تستخدم Backbone في مشروعك، لذلك تقوم بتضمين البرنامج النصي Backbone عبر علامة في ملفك. وبما أن Backbone يعتمد بشكل مباشر على Underscore.js، فلا يمكنك تضمين البرنامج النصي Backbone.js قبل Underscore.js.
قد تكون إدارة التبعيات كمطور بمثابة صداع في بعض الأحيان.
عيب آخر هو أنه لا يزال من الممكن حدوث تعارضات في مساحة الاسم. على سبيل المثال، قد يكون لديك وحدتين بنفس الاسم، أو إصدارين من نفس الوحدة، وتحتاج إلى كليهما.
وهذا يثير سؤالاً مثيرًا للاهتمام: هل يمكننا الوصول إلى واجهة الوحدة ليس من خلال النطاق العالمي؟
لحسن الحظ، الجواب هو نعم.
هناك طريقتان شائعتان ومُنفذتان بشكل جيد: CommonJS وAMD.
CommonJS
CommonJS هي مجموعة تطوعية من المطورين الذين يقومون بتصميم وتنفيذ واجهات برمجة تطبيقات JavaScript للإعلان عن الوحدات.
وحدة CommonJS هي جزء من كود JavaScript مصمم لإعادة استخدامه. يقوم بتصدير كائنات خاصة، مما يجعلها متاحة للوحدات النمطية الأخرى حتى تتمكن من تضمينها في تبعياتها. إذا كنت قد قمت بالبرمجة في Node.js، فسيكون هذا مألوفًا جدًا لك.
باستخدام CommonJS، يقوم كل ملف JavaScript بتخزين وحدة نمطية في سياقها الفريد (تمامًا مثل عمليات الإغلاق). في هذا الفضاء نستخدم الكائن Module.exports لتصدير الوحدات، و يتطلب لتوصيلهم.
قد يبدو تعريف وحدة CommonJS كما يلي:
الدالة myModule() ( this.hello = function() ( إرجاع "hello!"; ) this.goodbye = function() ( إرجاع "goodbye!"; ) ) Module.exports = myModule;
نحن نستخدم كائن خاص وحدة ووضع رابط لوظيفتنا في Module.exports . يسمح هذا لـ CommonJS بمعرفة أننا نريد الكشف عن الوحدة حتى تتمكن الملفات الأخرى من استخدامها.
بعد ذلك، عندما يريد شخص ما استخدام موقعنا myModule، فسيتمكن من توصيله دون أي مشاكل على النحو التالي:
var myModule = require("myModule"); var myModuleInstance = new myModule(); myModuleInstance.hello(); // "مرحبًا!" myModuleInstance.goodbye(); // "مع السلامة!"
يتمتع هذا النهج بميزتين واضحتين مقارنة بالطرق التي ناقشناها سابقًا:
- لا يوجد تلوث عالمي لمساحة الاسم؛
- جعل تبعياتنا أكثر وضوحا؛
بالإضافة إلى ذلك، بناء الجملة مضغوط للغاية، وأنا أحب ذلك حقا.
وتجدر الإشارة إلى أن CommonJS يستخدم الخادم أولاً يتم تحميل النهج والوحدات بشكل متزامن. وهذا مهم لأنه إذا كان لدينا ثلاث وحدات أخرى نحتاج إلى توصيلها، فسيتم تحميلها واحدة تلو الأخرى.
يعمل هذا بشكل رائع على الخادم الآن، ولكنه للأسف يجعل كتابة جافا سكريبت المستندة إلى المتصفح أمرًا صعبًا. يستغرق استرداد الوحدة النمطية من الإنترنت وقتًا أطول بكثير من استرداد الوحدة النمطية من القرص الصلب. أثناء قيام البرنامج النصي بتحميل الوحدة، يتم حظر المتصفح ولا يمكنك فعل أي شيء حتى ينتهي التحميل. يتصرف بهذه الطريقة لأن مؤشر ترابط JavaScript متوقف أثناء تحميل الكود (سأخبرك كيف يمكننا التغلب على هذه المشكلة في الجزء الثاني من المقالة، عندما ننظر إلى بناء الوحدات النمطية . في الوقت الحالي، هذا كل ما نحتاج إلى معرفته.)
أيه إم دي
يعد CommonJS أمرًا رائعًا، ولكن ماذا لو احتجنا إلى تحميل الوحدات بشكل غير متزامن؟ الإجابة على هذا السؤال هي "تعريف الوحدة غير المتزامنة" أو ببساطة AMD.
Define(["myModule", "myOtherModule"], function(myModule, myOtherModule) ( console.log(myModule.hello()); ));
تأخذ وظيفة تعريف الوحدة مصفوفة من التبعيات كوسيطة أولى لها. يتم تحميل هذه التبعيات بطريقة الخلفية (غير محظورة) واستدعاء وظيفة رد الاتصال التي تم تمريرها كوسيطة ثانية.
بعد ذلك، تأخذ وظيفة رد الاتصال التبعيات المحملة بالفعل كوسائط وتسمح لك باستخدامها. وأخيرًا، يجب أيضًا تحديد التبعيات نفسها باستخدام الكلمة الأساسية يُعرِّف .
على سبيل المثال، myModuleقد يبدو مثل هذا:
تعريف(, function() ( return ( hello: function() ( console.log("hello"); ), وداعا: function() ( console.log("goodbye"); ) ); ));
لذلك دعونا نتناولها مرة أخرى. على عكس CommonJS، تطبق AMD نهج المتصفح أولاً جنبًا إلى جنب مع السلوك غير المتزامن (لاحظ أن الكثير من الأشخاص يزعمون أن التحميل الديناميكي للملفات ليس مفيدًا لتنفيذ التعليمات البرمجية الخاصة بك. سنتحدث أكثر عن هذا في الجزء التالي من مقالتنا على بناء الوحدات).
بالإضافة إلى عدم التزامن، تتمتع AMD بميزة أخرى. يمكن أن تكون وحدات AMD عبارة عن وظائف ومنشئات وسلاسل وJSON وأنواع أخرى، بينما يدعم CommonJS الكائنات كوحدات نمطية فقط.
على الجانب السلبي، AMD غير متوافقة مع io ونظام الملفات والميزات الأخرى التي تركز على الخادم والتي تتوفر من خلال CommonJS. وصياغة وظيفة إعلان الوحدة مطولة مقارنة بالبسيطة يتطلب .
UMD
بالنسبة للمشاريع التي تتطلب دعمًا لكل من ميزات AMD وCommonJS، هناك تنسيق آخر. تعريف الوحدة الشاملة، أو ببساطة UMD.
بشكل أساسي، يوفر UMD القدرة على استخدام أي من الطريقتين أعلاه، بالإضافة إلى أنه يدعم تعريف الوحدات من خلال متغير عام. ونتيجة لذلك، يمكن تشغيل وحدات UMD على كل من العميل والخادم.
مثال سريع لكيفية عمل UMD:
(وظيفة (جذر، مصنع) ( if (typeofdef === "function" &&define.amd) ( // تعريف AMD(["myModule"، "myOtherModule"]، مصنع)؛ ) else if (typeofExports == = "object") ( // CommonJS Module.exports = Factory(require("myModule"), require("myOtherModule")); ) else ( // متصفح عالمي (ملاحظة: الجذر هو النافذة) root.returnExports = Factory( root.myModule, root.myOtherModule); ) (this, function (myModule, myOtherModule) ( // وظيفة الأساليب notHelloOrGoodbye())(); // وظيفة الطريقة الخاصة hello())(); لأنه تم إرجاعه (انظر أدناه) وظيفة وداعًا ()(; // طريقة عامة لأنه تم إرجاعه (انظر أدناه) // إرجاع الطرق العامة المكشوفة ( hello: hello, وداعًا: وداعًا )));
شبيبة أصلية
أوف. هل مازلت موجودا؟ هل فقدتك في هذه الغابة؟ بخير! لأن لدينا نوعًا آخر من تعريف الوحدة.
كما لاحظت أعلاه، لم تكن أي من الوحدات تحتوي على JavaScript أصليًا. بدلاً من ذلك، قمنا بمحاكاة نظام وحدة باستخدام إما نمط الوحدة أو CommonJS أو AMD.
لحسن الحظ، أضاف الأشخاص الأذكياء في TC39 (هيئة المعايير التي تحدد بناء الجملة ودلالات ECMAScript) وحدات مدمجة إلى ECMAScript 6 (ES6).
يقدم ES6 مجموعة متنوعة من الخيارات لاستيراد وتصدير الوحدات، والتي تمت مناقشتها أكثر من مرة. فيما يلي بعض الموارد:
- jsmodules.io
- Explorejs.com
ما الجيد في وحدات ES6 مقارنةً بـ CommonJS وAMD؟ أنه يجمع بين أفضل ما في العالمين: الاكتناز، وبناء الجملة التعريفي، والتحميل غير المتزامن، بالإضافة إلى فوائد إضافية مثل التبعيات الدائرية.
ربما تكون الميزة المفضلة لدي في وحدات ES6 هي أن الواردات هي أنواع صادرات حية للقراءة فقط (مقارنة بـ CommonJS، حيث يكون الاستيراد مجرد نسخة من التصدير).
وفيما يلي مثال على كيفية عمله:
// lib/counter.js var counter = 1; زيادة الدالة () ( counter++; ) تناقص الدالة () ( counter--; ) Module.exports = ( counter: counter, increment: increment, decrement: decrement); // src/main.js var counter = require("../../lib/counter"); counter.increment(); console.log(counter.counter); // 1
في هذا المثال، قمنا بعمل نسختين من الوحدة الأساسية: المرة الأولى عندما قمنا بتصديرها، والمرة الثانية عندما قمنا باستيرادها.
بالإضافة إلى ذلك، النسخة التي في main.jsتم الآن قطع الاتصال بالوحدة الأصلية. لذا، حتى عندما نزيد العداد، فإنه لا يزال يُرجع 1 لأنه عداد- هذا متغير استوردناه من الوحدة، منفصلاً عن الوحدة الأصلية.
لذا فإن زيادة العداد ستؤدي إلى زيادته في الوحدة، ولكنها لن تزيده في النسخة المنسوخة. الطريقة الوحيدة لتغيير النسخة المنسوخة هي زيادتها يدويًا:
Counter.counter++; console.log(counter.counter); // 2
ويقوم ES6، عند الاستيراد، بإنشاء عرض مباشر للقراءة فقط للوحدة:
// تصدير lib/counter.js Let counter = 1; زيادة وظيفة التصدير () ( counter++; ) تقليل وظيفة التصدير () ( counter--; ) // src/main.js import * as counter from "../../counter"; console.log(counter.counter); // 1 counter.increment(); console.log(counter.counter); // 2
مثير للاهتمام، أليس كذلك؟ ما أجده مقنعًا حقًا بشأن طرق العرض المباشرة للقراءة فقط هو أنها تسمح لك بتقسيم الوحدات النمطية الخاصة بك إلى أجزاء أصغر دون فقدان الوظائف.
يمكنك نشرها ودمجها مرة أخرى (في مشروع جديد) ولا توجد مشكلة. كل شيء سوف يعمل.
التطلع إلى الأمام قليلاً: تجميع الوحدات
رائع! كيف مر الوقت بسرعة. لقد كانت رحلة رائعة وآمل بشدة أن تكون هذه المقالة قد أعطتك فهمًا أفضل للوحدات النمطية في JavaScript.
في المقالة التالية، سنلقي نظرة على ربط الوحدات، ونغطي الموضوعات الرئيسية بما في ذلك:
- لماذا نقوم بجمع الوحدات؟
- طرق مختلفة للتجميع؛
- واجهة برمجة تطبيقات وحدة تحميل ECMAScript؛
- والكثير...
العوامل الحسابية ونوع الصب
تدعم JavaScript العوامل الحسابية التالية:
إحدى الميزات المثيرة للاهتمام في JavaScript هي القدرة على إجراء العمليات الحسابية على متغيرات من أنواع مختلفة. في هذه الحالة، يقوم المترجم بتنفيذ النوع نفسه وتنفيذ العملية المحددة. يتم استخدام القواعد التالية في عملية صيانة النوع:
1. إذا كان أحد المعاملات عبارة عن سلسلة، فسيتم تحويل جميع المعاملات الأخرى إلى شكل سلسلة.
Var1 = "العم" var2 = "Vanya" result = var1 + " " + var2 // نتيجة = "العم Vanya" مختلط = var2 + 100 // مختلط = "Vanya100"
2. يتم تحويل جميع المعاملات المنطقية إلى شكل رقمي، إلا عندما تكون جميع المعاملات في التعبير منطقية. في هذه الحالة، يتم تقليل الصواب إلى "1"، والخطأ - إلى "0". عند دمج المعاملات المنطقية مع السلاسل، يتم تحويل جميع المعاملات إلى نموذج نصي.
var1 = صحيح var2 = النتيجة الحقيقية = var1 + var2 // النتيجة = 2 مختلط = var2 + 100 // مختلط = 101 var3 = "string:" str = var3 + var1 // str = "string:true"
3. إذا فشل تحويل الكتابة، ستكون نتيجة التعبير "NaN" (على سبيل المثال، عند محاولة تقسيم سلسلة إلى شيء ما).
Var1 = "العم" var2 = "Vanya" result = var1 / var2 // نتيجة = "NaN" مختلط = var2 * صحيح // مختلط = "NaN"
ومع ذلك، في المرحلة الأولية، من الأفضل الامتناع عن أنواع الصب والحيل مع تحويل النتائج. هذا سيوفر لك من عدد كبير من الأخطاء.
كائن الرياضيات
يحتوي كائن Math على ثوابت رياضية أساسية ودوال رياضية قياسية. الأكثر استخدامًا موضحة في الجدول:
| ملكيات | |
| LN10 | قيمة اللوغاريتم الطبيعي للرقم 10 |
| LN2 | قيمة اللوغاريتم الطبيعي للرقم 2 |
| باي. | قيمة باي |
| طُرق | |
| القيمة المطلقة (رقم) | إرجاع القيمة المطلقة لرقم (أي الرقم دون مراعاة علامته) |
| السقف (عدد) | تقريب رقم إلى أقرب عدد صحيح أعلى (تقريب لأعلى) |
| إكسب (رقم) | إرجاع الرقم "e" إلى قوة "number" |
| رقم الدور) | تقريب رقم إلى أقرب عدد صحيح أقل (تقريبًا للأسفل) |
| الحد الأقصى (رقم 1، رقم 2) | إرجاع أكبر رقمين |
| دقيقة (رقم 1، رقم 2) | إرجاع أصغر رقمين |
| الأسرى (رقم 1، رقم 2) | إرجاع "number1" مرفوعًا إلى الأس "number2" |
| عشوائي() | إرجاع رقم عشوائي في النطاق من 0 إلى 1 |
| عدد مستديرة) | تقريب رقم وفقًا لقواعد التقريب القياسية |
| سرت (رقم) | إرجاع الجذر التربيعي لرقم. |
من بين جميع الوظائف المدرجة، من المنطقي تقديم المزيد من الشرح فقط لـ ceil() وfloor() وround(). دعونا نلقي نظرة على الاختلافات بينهما باستخدام مثال:
Num = 1.222 // أقرب عدد صحيح "لأسفل" هو 1 // أقرب عدد صحيح "لأعلى" هو 2 // مُقربًا حسابيًا إلى 1 تنبيه(Math.ceil(num)) تنبيه(Math.floor(num)) تنبيه(Math.round) (num)) // نحصل على ثلاث رسائل: 2, 1, 1 num = 1.777 // أقرب عدد صحيح "لأسفل" هو 1 // أقرب عدد صحيح "لأعلى" هو 2 // مقربًا حسابيًا إلى 2 تنبيه (Math.ceil) (num) ) تنبيه(Math.floor(num)) تنبيه(Math.round(num)) // نحصل على ثلاث رسائل: 2، 1، 2
تتيح لك مجموعة الوظائف الرياضية في جافا سكريبت حل مجموعة واسعة من المشكلات، لكن لا ينبغي إساءة استخدامها. لا تنس أن الكود يتم تنفيذه بواسطة مترجم، ولكن ليس هناك شك في تحسين الحسابات على مستوى منخفض، لذلك سيكون تحقيق الأداء العالي أمرًا صعبًا للغاية.
التعبيرات في جافا سكريبتهي مجموعات المعاملاتو العاملين.
عملياتفي التعبيرات يتم تنفيذها بشكل تسلسلي وفقًا لقيمة الأولوية (كلما ارتفعت قيمة الأولوية، ارتفعت). النتيجة التي يتم إرجاعها ليست دائمًا من نفس نوع نوع البيانات التي تتم معالجتها. على سبيل المثال، تتضمن عمليات المقارنة معاملات من أنواع مختلفة، لكن نتيجة الإرجاع ستكون دائمًا من النوع المنطقي.
أرز. 1. بنية التعبير في جافا سكريبت المعاملاتهي البيانات التي تتم معالجتها بواسطة برنامج JavaScript النصي. يمكن أن تكون المعاملات إما أنواع بيانات بسيطة أو معقدة، بالإضافة إلى تعبيرات أخرى.
العاملينهي رموز اللغة التي تؤدي عمليات مختلفة مع البيانات. يمكن كتابة عوامل التشغيل باستخدام علامات الترقيم أو الكلمات الأساسية.
اعتمادا على عدد المعاملات، يتم تمييز الأنواع التالية من العوامل:
أحادي— معامل واحد يشارك في العملية؛
الثنائية— العملية تنطوي على معاملين؛
ثلاثي- يجمع بين ثلاثة معاملات.
أبسط أشكال التعبير هو حرفي— شيء يتم تقييمه لنفسه، على سبيل المثال، الرقم 100، السلسلة النصية "Hello World" . يمكن للمتغير أيضًا أن يكون تعبيرًا، لأنه يتم تقييمه وفقًا للقيمة المخصصة له.
التعبيرات والمشغلين في جافا سكريبت
1. العوامل الحسابية
العمليات الحسابيةتم تصميمها لإجراء عمليات رياضية، فهي تعمل على المعاملات الرقمية (أو المتغيرات التي تخزن القيم الرقمية)، مما يؤدي إلى إرجاع قيمة رقمية نتيجة لذلك.
إذا كان أحد المعاملات عبارة عن سلسلة، فسيحاول مترجم JavaScript تحويلها إلى نوع رقمي ثم تنفيذ العملية المناسبة. إذا لم يكن تحويل النوع ممكنًا، فستكون النتيجة NaN (وليس رقمًا).
| المشغل/التشغيل | وصف | أولوية |
|---|---|---|
| + إضافة | يضيف المعاملات الرقمية. إذا كان أحد المعاملات عبارة عن سلسلة، فإن نتيجة التعبير هي سلسلة. | 12 |
| - الطرح | يطرح المعامل الثاني من الأول. | 12 |
| - الأحادي ناقص | تحويل رقم موجب إلى رقم سالب والعكس. | 14 |
| * عمليه الضرب | ضرب معاملين. | 13 |
| / قسم | قسمة المعامل الأول على الثاني. يمكن أن تكون نتيجة القسمة عددًا صحيحًا أو عددًا عائمًا. | 13 |
| % قسمة Modulo (القسمة المتبقية) | لحساب الباقي الناتج عن قسمة عدد صحيح للمعامل الأول على الثاني. ينطبق على كل من الأعداد الصحيحة وأرقام الفاصلة العائمة. | 13 |
2. مشغلي المهمة
مشغلي التعيينتستخدم لتعيين القيم للمتغيرات. تسمح لك عوامل التشغيل المجمعة بتخزين القيم الأصلية والقيم اللاحقة في متغير واحد.
فار أ = 5؛ // قم بتعيين القيمة الرقمية 5 للمتغير a var b = "hello"; // قم بتخزين السلسلة النصية في المتغير b var m = n = z = 10; // قم بتعيين المتغيرات m، n، z القيمة العددية 10 x += 10; // يعادل x = x + 10; س -= 10; // يعادل x = x - 10; س *= 10; // يعادل x = x * 10; س /= 10; // يعادل x = x / 10; س %= 10; // يعادل x = x % 10;3. عوامل الزيادة والنقصان
عمليات الزيادة والنقصانتكون أحادية وتزيد وتنقص قيمة المعامل بمقدار واحد. يمكن أن يكون المعامل متغيرًا، أو عنصر صفيف، أو خاصية كائن. في أغلب الأحيان، يتم استخدام مثل هذه العمليات لزيادة العداد في الحلقة.
فار x = y = m = n = 5, z, s, k, l; ض = ++x * 2; /* نتيجة للحسابات سيعود القيمة ض = 12، س = 6، أي. يتم أولاً زيادة قيمة x بمقدار 1، ثم يتم إجراء عملية الضرب */ s = y++ * 2; /* نتيجة للحسابات سيعود القيمة s = 10، y = 6، أي. أولاً، يتم إجراء عملية الضرب، ثم يتم تخزين القيمة المتزايدة بمقدار 1 في المتغير y */ k = --m * 2; // إرجاع القيمة k = 8, m = 4 l = n-- * 2; // قم بإرجاع القيمة ل = 10، ن = 44. عوامل المقارنة
عوامل المقارنةتستخدم لمطابقة المعاملات، يمكن أن تكون نتيجة التعبير إحدى القيمتين - صحيح أو خطأ. لا يمكن أن تكون المعاملات أرقامًا فحسب، بل قد تكون أيضًا سلاسل وقيم منطقية وكائنات. ومع ذلك، لا يمكن إجراء المقارنات إلا على الأرقام والسلاسل، لذلك يتم تحويل المعاملات التي ليست أرقامًا أو سلاسل.
إذا لم يكن من الممكن تحويل كلا المعاملين بنجاح إلى أرقام أو سلاسل، فستُرجع العوامل دائمًا false .
إذا كان كلا المعاملين عبارة عن سلاسل/أرقام أو يمكن تحويلهما إلى سلاسل/أرقام، فسيتم مقارنتهما كسلاسل/أرقام.
إذا كان أحد المعاملات عبارة عن سلسلة/تحويل إلى سلسلة والآخر عبارة عن رقم/تحويل إلى رقم، فسيحاول عامل التشغيل تحويل السلسلة إلى رقم وإجراء مقارنة أرقام. إذا لم تكن السلسلة رقمًا، فسيتم تحويلها إلى NaN وتكون نتيجة المقارنة خاطئة.
في أغلب الأحيان، يتم استخدام عمليات المقارنة عند تنظيم الفروع في البرامج.
| المشغل/التشغيل | وصف | أولوية |
|---|---|---|
| == المساواة | يختبر قيمتين لنفس القيمة، مما يسمح بتحويل النوع. إرجاع صحيح إذا كانت المعاملات هي نفسها، وخطأ إذا كانت مختلفة. | 9 |
| != عدم المساواة | يُرجع صحيحًا إذا كانت المعاملات غير متساوية | 9 |
| === الهوية | يختبر معاملين لـ "الهوية" باستخدام تعريف صارم للمطابقة. يُرجع صحيحًا إذا كانت المعاملات متساوية بدون تحويل النوع. | 9 |
| !== عدم الهوية | يقوم بالتحقق من الهوية. يُرجع صحيحًا إذا كانت المعاملات غير متساوية بدون تحويل النوع. | 9 |
| > المزيد | إرجاع صحيح إذا كان المعامل الأول أكبر من الثاني، وإلا فسيتم إرجاع خطأ. | 10 |
| >= أكبر من أو يساوي | يُرجع صحيحًا إذا كان المعامل الأول لا يقل عن الثاني، وإلا يُرجع خطأ. | 10 |
| إرجاع صحيح إذا كان المعامل الأول أقل من الثاني، وإلا فسيتم إرجاع خطأ. | 10 | |
| يُرجع صحيحًا إذا لم يكن المعامل الأول أكبر من الثاني، وإلا يُرجع خطأ. | 10 |
5. العوامل المنطقية
العوامل المنطقيةتسمح لك بدمج الشروط التي تُرجع قيمًا منطقية. غالبًا ما يتم استخدامه في عبارة if الشرطية.
(2 < 3) && (3===3); // вернет true, так как выражения в обеих скобках дают true (x < 10 && x >0)؛ // سيعود صحيحًا إذا كانت x في النطاق من 0 إلى 10 !false; // إرجاع صحيح6. مشغلي Bitwise
مشغلي Bitwiseتعمل على المعاملات كتسلسل 32 بت من الآحاد والأصفار وترجع قيمة رقمية تشير إلى نتيجة العملية، مكتوبة بالتدوين العشري. تعتبر الأرقام الصحيحة بمثابة معاملات؛ ويتم تجاهل الجزء الكسري من المعامل. يمكن استخدام عمليات Bitwise، على سبيل المثال، عند تشفير البيانات، والعمل مع العلامات، وتحديد حقوق الوصول.
| المشغل/التشغيل | وصف | أولوية |
|---|---|---|
| & Bitwise و | إذا كان كلا البتين 1، فإن البت الناتج سيكون 1. وإلا فإن النتيجة هي 0. | 8 |
| | Bitwise أو | إذا كان أحد المعاملات يحتوي على 1 في الموضع، فستحتوي النتيجة أيضًا على 1 في ذلك الموضع، وإلا ستكون النتيجة في هذا الموضع 0. | 6 |
| ^ حصريا أو | إذا كانت قيمة واحدة فقط تحتوي على 1 في أي موضع، فستحتوي النتيجة على 1 في ذلك الموضع، وإلا ستكون النتيجة في ذلك الموضع 0. | 7 |
| ~ الإنكار | يتم تنفيذ عملية النفي على مستوى البت على التمثيل الثنائي لقيمة التعبير. يتم استبدال أي موضع يحتوي على 1 في التعبير الأصلي بـ 0. أي موضع يحتوي على 0 في التعبير الأصلي يصبح 0 . تبدأ الأرقام الموجبة عند 0، وتبدأ الأرقام السالبة عند -1، لذا ~ n == -(n+1) . | 14 |
| يقوم المشغل بنقل بتات المعامل الأول إلى اليسار بعدد مواضع البت التي يحددها المعامل الثاني. يتم استخدام الأصفار لملء المناصب الموجودة على اليمين. قم بإرجاع نتيجة من نفس نوع المعامل الأيسر. | 11 | |
| >> تحويل اتجاه البت إلى اليمين | يقوم المشغل بإزاحة بتات المعامل الأول إلى اليمين بعدد مواضع البت التي يحددها المعامل الثاني. تتم إزالة الأرقام المنقولة خارج النطاق. يتم ترك البت الأكثر أهمية (32) دون تغيير للحفاظ على علامة النتيجة. إذا كان المعامل الأول موجبًا، فسيتم ملء الأجزاء الأكثر أهمية من النتيجة بالأصفار؛ إذا كان المعامل الأول سالبًا، فسيتم ملء الأجزاء الأكثر أهمية من النتيجة بأخرى. إن نقل قيمة إلى اليمين بموضع واحد يعادل القسمة على 2 (مع تجاهل الباقي)، والتحويل إلى اليمين بموضعين يعادل القسمة على 4، وما إلى ذلك. | 11 |
| >>> إزاحة لليمين باتجاه البت بدون إشارة | يقوم المشغل بإزاحة بتات المعامل الأول إلى اليمين بعدد مواضع البت التي يحددها المعامل الثاني. تتم إضافة الأصفار إلى اليسار، بغض النظر عن إشارة المعامل الأول. تتم إزالة الأرقام المنقولة خارج النطاق. | 11 |
7. مشغلي السلسلة
هناك العديد من العوامل التي تعمل مع السلاسل بطرق خاصة.
"1" + "10" ؛ // إرجاع "110" "1" + 10؛ // يُرجع "110" 2 + 5 + "أقلام ملونة"؛ // إرجاع "7 أقلام ملونة" "أقلام ملونة" + 2 + 5؛ // إرجاع "25 قلم رصاص ملون" "1" > "10"؛ // إرجاع خطأ "10"<= 10; // вернет true "СССР" == "ссср"; // вернет false x = "micro"; x+= "soft"; // вернет "microsoft"8. المشغلين الخاصين
| المشغل/التشغيل | وصف | أولوية |
|---|---|---|
| . الوصول إلى عقار | الوصول إلى خاصية الكائن. | 15 |
| ,حسابات متعددة | يقيم تعبيرات مستقلة متعددة مكتوبة على سطر واحد. | 1 |
| فهرسة المصفوفة | الوصول إلى عناصر المصفوفة أو خصائص الكائن. | 15 |
| () استدعاء الوظيفة، التجميع | عمليات المجموعات أو استدعاء وظيفة. | 15 |
| نوع تعريف نوع البيانات | عامل التشغيل الأحادي، يقوم بإرجاع نوع بيانات المعامل. | 14 |
| مثيل التحقق من نوع الكائن | يتحقق عامل التشغيل مما إذا كان الكائن هو مثيل لفئة معينة. يجب أن يكون المعامل الأيسر كائنًا، ويجب أن يحتوي المعامل الأيمن على اسم فئة الكائن. ستكون النتيجة صحيحة إذا كان الكائن الموجود على اليسار مثيلًا للفئة الموجودة على اليمين، وستكون النتيجة خاطئة بخلاف ذلك. | 10 |
| في التحقق من وجود الممتلكات | يجب أن يكون المعامل الأيسر عبارة عن سلسلة، ويجب أن يكون المعامل الأيمن مصفوفة أو كائنًا. إذا كانت القيمة اليسرى خاصية لكائن ما، فستكون النتيجة صحيحة. | 10 |
| جديد إنشاء كائن | يقوم المشغل بإنشاء كائن جديد بخصائص غير محددة، ثم يستدعي وظيفة المنشئ لتهيئته (تمرير المعلمات). يمكن استخدامه أيضًا لإنشاء مصفوفة. | 1 |
| حذف حذف | يسمح لك عامل التشغيل بإزالة خاصية من كائن أو عنصر من مصفوفة. يُرجع صحيحًا إذا تم الحذف بنجاح، ويُرجع خطأً في حالة عدم ذلك. عند حذف عنصر مصفوفة، لا يتغير طوله. | 14 |
| باطلة تحديد تعبير بدون قيمة الإرجاع | المشغل الأحادي، يتجاهل قيمة المعامل ويعود تحت التسطير . | 14 |
| ?: عامل التعبير الشرطي | يتيح لك المشغل الثلاثي تنظيم التفرع البسيط. يتضمن التعبير ثلاثة معاملات، الأول يجب أن يكون قيمة منطقية أو يتم تحويله إلى واحد، والثاني والثالث يجب أن يكونا أي قيم. إذا كان المعامل الأول صحيحًا، فسيأخذ التعبير الشرطي قيمة المعامل الثاني؛ إذا كاذبة - ثم الثالثة. | 3 |
9. التعليقات في جافا سكريبت
تعليق من سطر واحد: يجب أن تسبق نص التعليق بالرموز // .
المسؤول عن العمليات الحسابية. في هذه المقالة سوف نلقي نظرة على ثوابت وطرق هذا الفصل، ونتعلم أيضًا كيفية استخدامها في عملية البرمجة الصعبة.
لنبدأ بالثوابت كائن الرياضيات. دعونا نفكر في الثوابت هو باي.(معروف لك من الرياضيات). دعونا نطبعها على الفور:
Document.write(Math.E);
وثيقة.كتابة("
");
document.write(Math.PI);
إذا قمت بتشغيل هذا البرنامج النصي، فسترى قيم الثوابتين الأكثر شعبية في الرياضيات.
الآن دعنا ننتقل إلى الأساليب. كائن الرياضيات في جافا سكريبت. الطريقة الأولى هي القيمة المطلقة (خ)، الذي يأخذ رقمًا كمعلمة ويعيد معامله. على سبيل المثال، مثل هذا:
فار س = -15.2؛
document.write(Math.abs(x));
وستكون النتيجة الرقم " 15.2 ".
الطريقة التالية ستكون عشوائي(). طريقة شائعة جدًا تقوم بإنشاء رقم بشكل عشوائي من 0 إلى 1. علاوة على ذلك، 0 يأتي و 1 لم تعد مدرجة. دعونا نحصل على الرقم من 0 إلى 10.
Document.write(Math.random() * 10);
سيخرج هذا الخط الرقم من 0 إلى 10(وكسرى). .لاحظ أن 0 ربما ولكن 10 لا يمكن أن تكون.
طريقة الجذر التربيعي (خ)يحسب الجذر التربيعي لعدد. التطبيق واضح وبسيط جدا:
Document.write(Math.sqrt(9));
في هذا المثال بعد تشغيل السكربت سنرى الرقم " 3 ".
طريقة سجل (خ)يحسب اللوغاريتم الطبيعي لعدد.
Document.write(Math.log(Math.E * Math.E));
من الواضح أن الإجابة ستكون " 2 ".
طريقة أخرى لحساب قوة الرقم. الطريقة تسمى - الأسرى (س، ص). يأخذ معلمتين، الأول هو أساس الرقم، والثاني هو قوته. مجرد مثال:
Document.write(Math.pow(2, 5));
ومن المنطقي تماما أن يحدث ذلك 32 .
وأخيرًا، دعونا نفكر في مجموعة من الطرق التي تؤدي الدوال المثلثية:
فار س = 0.1؛
document.write(Math.sin(x) + "
"); // جيب الرقم
document.write(Math.cos(x) + "
"); // جيب التمام للرقم
document.write(Math.tan(x) + "
"); // ظل الرقم
document.write(Math.asin(x) + "
"); // قوس جيب الرقم
document.write(Math.acos(x) + "
"); // قوس جيب التمام للرقم
document.write(Math.atan(x) + "
"); // ظل قوسي للرقم.
لمنع دمج نتائج تنفيذ الدوال المثلثية، بعد كل تنفيذ هناك انتقال إلى سطر جديد (
).