Parsefloat جافا سكريبت 2 منازل عشرية. طرق تقريب الأرقام في JavaScript. التقريب لأقرب رقم

تقريب الرياضيات لجافا سكريبت لأقرب منزلتين عشريتين (9)

لدي بناء جملة JavaScript التالي:

Vardiscount = Math.round (100 - (السعر / سعر القائمة) * 100) ؛

يتم تقريب هذا إلى عدد صحيح. كيف يمكنني إرجاع نتيجة مكونة من منزلتين عشريتين؟

هنا مثال عملي

varvalue = 200.2365455 ؛ النتيجة = Math.round (القيمة * 100) / 100 // ستكون النتيجة 200.24

للتعامل مع التقريب إلى أي عدد من المنازل العشرية ، تكفي وظيفة ذات سطرين من التعليمات البرمجية لمعظم الاحتياجات. هنا رمز مثال للعبة.

var testNum = 134.9567654 ؛ var decPL = 2 ؛ var testRes = roundDec (testNum، decPl) ؛ تنبيه (testNum + "تقريبه إلى" + decPl + "المنازل العشرية هي" + testRes) ؛ الدالة roundDec (nbr ، dec_places) (var mult = Math.pow (10، dec_places) ؛ إرجاع Math.round (nbr * mult) / mult ؛)

أفضل وأسهل حل وجدته هو

جولة الدالة (القيمة ، الكسور العشرية) (رقم الإرجاع (Math.round (القيمة + "e" + decimals) + "e -" + decimals) ؛) round (1.005، 2) ؛ // 1.01

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

فار الخصم = + ((السعر / سعر القائمة) .toFixed (2)) ؛

تم التعديل: اكتشفت للتو ما يبدو أنه خطأ في Firefox 35.0.1 ، مما يعني أن ما سبق قد يعطي NaN بعض القيم.
لقد غيرت الكود الخاص بي إلى

Vardiscount = Math.round (السعر / listprice * 100) / 100 ؛

هذا يعطي رقما بدقة منزلتين عشريتين. إذا احتجت إلى ثلاثة ، فستضرب وتقسم على 1000 ، وهكذا.
يريد OP منزلتين عشريتين دائمًا ، ولكن إذا تم كسر toFixed () في Firefox ، يحتاج المرء إلى إصلاحه أولاً.
انظر https://bugzilla.mozilla.org/show_bug.cgi؟id=1134388

للحصول على النتيجة مع منزلتين عشريتين ، يمكنك القيام بما يلي:

Vardiscount = Math.round ((100 - (السعر / سعر القائمة) * 100) * 100) / 100 ؛

يتم ضرب القيمة المراد تقريبها في 100 للاحتفاظ بالرقمين الأولين ، ثم نقسم على 100 للحصول على النتيجة الفعلية.

اعتقد انه أفضل طريقةالرقم الذي رأيته هو الضرب في 10 في عدد الأرقام ، ثم عمل Math.round ، ثم أخيرًا اقسمه على 10 على عدد الأرقام. فيما يلي وظيفة بسيطة أستخدمها في الكتابة المطبوعة:

الدالة roundToXDigits (القيمة: رقم ، أرقام: رقم) (القيمة = القيمة * Math.pow (10 ، أرقام) ؛ القيمة = Math.round (القيمة) ؛ القيمة = القيمة / Math.pow (10 ، أرقام) ؛ قيمة الإرجاع ؛ )

أو جافا سكريبت بسيط:

الدالة roundToXDigits (قيمة ، أرقام) (إذا (! أرقام) (أرقام = 2 ؛) القيمة = القيمة * Math.pow (10 ، أرقام) ؛ القيمة = Math.round (القيمة) ؛ القيمة = القيمة / Math.pow (10 ، أرقام) ؛ قيمة الإرجاع ؛)

ملحوظة. - راجع تحرير 4 إذا كانت الدقة المكونة من 3 أرقام مهمة.

Vardiscount = (السعر / سعر القائمة) .toFixed (2) ؛

يتم تقريب القيمة الثابتة لأعلى أو لأسفل بناءً على قيم أكبر من منزلتين عشريتين.

يتغير.كما ذكر آخرون ، سيؤدي هذا إلى تحويل النتيجة إلى سلسلة. لتجنب هذا:

Vardiscount = + ((السعر / سعر القائمة) .toFixed (2)) ؛

تحرير 2- كما هو مذكور في التعليقات ، لا يتم تنفيذ هذه الوظيفة ببعض الدقة ، على سبيل المثال في حالة 1.005 سترجع 1.00 بدلاً من 1.01. إذا كانت الدقة بهذه الأهمية ، فقد وجدت هذه الإجابة: https: //.com/a/32605063/1726511 والتي يبدو أنها تعمل بشكل جيد مع جميع الاختبارات التي جربتها.

يلزم تعديل طفيف واحد ، ولكن الوظيفة في الإجابة أعلاه تُرجع الأعداد الصحيحة عندما يتم تقريبها إلى واحد ، لذلك على سبيل المثال 99.004 سيعيد 99 بدلاً من 99.00 ، وهو أمر غير مثالي لعرض الأسعار.

تحرير 3- يبدو أنه تم الإصلاح على إرجاع STILL الفعلي كان يفسد بعض الأرقام ، ويبدو أن هذا التعديل النهائي يعمل. الجيز الكثير من التعويضات!

Vardiscount = roundTo ((السعر / قائمة الأسعار) ، 2) ؛ الدالة roundTo (ن ، أرقام) (إذا (أرقام === غير محدد) (أرقام = 0 ؛) فار مضاعف = Math.pow (10 ، أرقام) ؛ ن = parseFloat ((n * مضاعف) .toFixed (11)) ؛ var test = (Math.round (n) / المضاعف) ؛ إرجاع + (test.toFixed (أرقام)) ؛)

تحرير 4- انت تقتلوني. يفشل التحرير 3 على الأرقام السالبة دون البحث في سبب سهولة جعل الرقم السالب موجبًا قبل إجراء التقريب ثم إعادته قبل إرجاع النتيجة.

الدالة roundTo (ن ، أرقام) (فار سلبي = خطأ ؛ إذا (أرقام === غير محدد) (أرقام = 0 ؛) إذا (ن< 0) { negative = true; n = n * -1; } var multiplicator = Math.pow(10, digits); n = parseFloat((n * multiplicator).toFixed(11)); n = (Math.round(n) / multiplicator).toFixed(2); if(negative) { n = (n * -1).toFixed(2); } return n; }

الطريقه الأسرع- أسرع من toFixed ():

شارتان

ثلاثة عشرية

جولة الدالة (num، dec) (num = Math.round (num + "e" + dec) إرجاع الرقم (num + "e -" + dec)) // التقريب إلى رقم عشري من اختيارك: round (1.3453،2)

لماذا التقريب ضروري؟

0.1 * 0.2; > 0.020000000000000004 0.3 - 0.1 > 0.19999999999999998
للأغراض العملية ، لا يهم عدم الدقة هذا ، في حالتنا نحن نتحدث عن خطأ في كوينتيليون سهم ، ومع ذلك ، قد يخيب ظن شخص ما. يمكننا أيضًا الحصول على بعض النتائج الغريبة عند التعامل مع الأرقام التي تمثل العملات أو النسب المئوية أو أحجام الملفات. لتصحيح هذه الأخطاء ، نحتاج فقط إلى أن نكون قادرين على تقريب النتائج ، ويكفي ضبط الدقة العشرية.

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

تقريب الكسور العشرية

1. إذا لم يتم تعريف الوسيطة لـ toFixed () ، فستكون القيمة الافتراضية للصفر ، مما يعني 0 منزلة عشرية ، ويكون الحد الأقصى للوسيطة هو 20.
2. إذا لم يتم إعطاء أي وسيطة لـ toPrecision ، فسيتم ترك الرقم دون تغيير

دع randNum = 6.25 ؛ دعونا تقريب = randNum.toFixed () ؛ // "6" console.log (randNum + rounded) ؛ > "6.256"
إذا كنت تريد أن تكون النتيجة من نوع بيانات رقمي ، فستحتاج إلى استخدام parseFloat:

دع randNum = 6.25 ؛ let rounded = parseFloat (randNum.toFixed (1)) ؛ سجل وحدة التحكم (مدور) ؛ > 6.3
لاحظ أنه تم تقريب 5 قيم إلا في حالات نادرة.

تعد طريقتا toFixed () و toPrecision () مفيدة ، لأنها لا تقطع الجزء الكسري فحسب ، بل يمكنها أيضًا ملء المنازل العشرية ، وهو أمر مناسب عند التعامل مع العملات:

لنفترض أن wholeNum = 1 let dollarCents = wholeNum.toFixed (2) ؛ console.log (دولارسنت) ؛ > "1.00"
لاحظ أن toPrecision سيعيد النتيجة في شكل تدوين أسي إذا كان عدد الأعداد الصحيحة أكبر من الدقة نفسها:

لنفترض أن num = 123.435 num.toPrecision (2) ؛ > "1.2e + 2"

كيفية تجنب أخطاء التقريب بالأرقام العشرية

دع numTest = 1.005 ؛ numTest.toFixed (2) ، > "1.00"
يجب أن تكون نتيجة الحساب أعلاه 1.01 ، وليس 1. إذا كنت تريد تجنب هذا النوع من الخطأ ، فيمكننا استخدام الحل الذي اقترحه Jack L Moore ، والذي يستخدم الأرقام الأسية للحساب:

جولة الدالة (القيمة ، الكسور العشرية) (رقم الإرجاع (Math.round (القيمة + "e" + الكسور العشرية) + "e -" + decimals) ؛)
الآن:

دائري (1.005،2) ؛ > 1.01
إذا كنت تريد حلاً أكثر قوة من الحل الموضح أعلاه ، يمكنك الانتقال إلى MDN.

آلة إبسيلون التقريب

0.1 + 0.2 === 0.3> خطأ
نستخدم Math.EPSILON في وظيفتنا للحصول على المقارنة الصحيحة:

الدالة epsEqu (x، y) (إرجاع Math.abs (x - y)< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y)); }
تأخذ الدالة وسيطين: الأول هو الحساب الحالي ، والثاني هو النتيجة المتوقعة. تقوم بإرجاع مقارنة بين الاثنين:

EpsEqu (0.1 + 0.2، 0.3)> صحيح
تدعم جميع المتصفحات الحديثة بالفعل وظائف الرياضيات ES6 ، ولكن إذا كنت تريد دعمًا في متصفحات مثل IE 11 ، فاستخدم polyfill.

لقطة كسرية

وظيفة مقطوعة (عدد) (إرجاع Math.trunc (العدد * 100) / 100 ؛) مقطوع (3.1416)> 3.14
إذا كنت ترغب في تكييف الطريقة مع أي عدد من المنازل العشرية ، فيمكنك استخدام نفي مزدوج أحادي:

تم اقتطاع الدالة (num ، decimalPlaces) (دع numPowerConverter = Math.pow (10، decimalPlaces) ؛ إرجاع ~~ (num * numPowerConverter) / numPowerConverter ؛)
الآن:

دع randInt = 35.874993 ؛ مقطوع (راند إنت ، 3) ؛ > 35.874

التقريب لأقرب رقم

Math.round (4.3)> 4 Math.round (4.5)> 5
لاحظ أن "نصف القيمة" ، 0.5 يتم تقريبها بواسطة قواعد الرياضيات.

التقريب لأسفل لأقرب عدد صحيح

الرياضيات.الطابق (42.23) ؛ > 42 Math.floor (36.93) ؛ > 36
لاحظ أن التقريب لأسفل يصلح لجميع الأرقام ، بما في ذلك الأرقام السالبة. تخيل ناطحة سحاب بعدد لا نهائي من الطوابق ، بما في ذلك الطوابق السفلية (تمثل أرقامًا سالبة). إذا كنت في مصعد في الطابق السفلي بين 2 و 3 (وهي قيمة -2.5) ، فسيأخذك Math.floor إلى -3:

Math.floor (-2.5) ؛ > -3
ولكن إذا كنت تريد تجنب هذا النوع من المواقف ، فاستخدم Math.trunc ، المدعومة في جميع المتصفحات الحديثة (باستثناء IE / Edge):

Math.trunc (-41.43) ؛ > -41
في MDN ستجد polyfill الذي سيوفر الدعم لـ Math.trunc في المتصفحات و IE / Edge.

التقريب لأقرب رقم صحيح

الرياضيات.ceil (42.23) ؛ > 43 Math.ceil (36.93) ؛ > 37 Math.ceil (-36.93) ؛ > -36

التقريب لأعلى / لأسفل حسب الحاجة

الدالة roundTo5 (عدد) (إرجاع Math.round (عدد / 5) * 5 ؛)
الآن:

RoundTo5 (11) ، > 10
إذا كنت تريد التقريب إلى مضاعفات القيمة الخاصة بك ، فإننا نستخدم دالة أكثر عمومية ، وتمرير القيمة الأولية ومضاعفات:

الدالة roundToMultiple (عدد ، متعدد) (إرجاع Math.round (عدد / مضاعف) * مضاعف ؛)
الآن:

دع رقم initialNumber = 11 ؛ دع مضاعف = 10 ؛ roundToMultiple (initialNumber ، متعددة) ؛ > 10 ؛

تحديد رقم في نطاق

دع lowBound = 1 ؛ اسمحوا highBound = 100 ؛ دع numInput = 123 ؛ دعها مثبتة = Math.max (lowBound، Math.min (numInput، highBound)) ؛ سجل وحدة التحكم (مثبت) ؛ > 100 ؛
مرة أخرى ، يمكننا إعادة استخدام العملية ولفها كلها في دالة ، باستخدام الحل الذي اقترحه دانيال إكس. مور:

Number.prototype.clamp = وظيفة (min ، max) (إرجاع Math.min (Math.max (this ، min) ، max) ؛) ؛
الآن:

NumInput.clamp (lowBound، highBound) ؛ > 100 ؛

التقريب الغاوسي

الدالة gaussRound (num، decimalPlaces) (دع d = decimalPlaces || 0، m = Math.pow (10، d)، n = + (d؟ num * m: num) .toFixed (8)، i = Math.floor (ن) ، f = n - i ، e = 1e-8 ، r = (f> 0.5 - e && f< 0.5 + e) ? ((i % 2 == 0) ? i: i + 1) : Math.round(n); return d ? r / m: r; }
الآن:

غاوس الجولة (2.5)> 2 غاوس الجولة (3.5)> 4 غاوس الجولة (2.57 ، 1)> 2.6
الفاصلة العشرية في CSS:

نظرًا لاستخدام JavaScript غالبًا لإنشاء تحويلات موضعية لعناصر HTML ، فقد تتساءل عما يحدث إذا قمنا بإنشاء قيم عشرية لعناصرنا:

# box (العرض: 63.667731993px ؛)
الخبر السار هو أن المتصفحات الحديثة ستحترم القيم العشرية في نموذج الصندوق ، بما في ذلك النسبة المئوية أو وحدات البكسل.

فرز

رتب ترتيب أبجدي

دع الفاكهة = ["قرع الجوز" ، "مشمش" ، "شمام"] ؛ نوع الفاكهة () ؛ > "مشمش" ، "قرع الجوز" ، "شمام"]
ومع ذلك ، فإننا نواجه مشكلة بمجرد أن يكون أحد العناصر كبيرًا:

دع الفاكهة = ["قرع الجوز" ، "مشمش" ، "كانتالوب"] ؛ نوع الفاكهة () ؛ > "شمام" ، "مشمش" ، "قرع الجوز"]
هذا لأنه ، افتراضيًا ، يقارن الفارز الحرف الأول الممثل في Unicode. Unicode هو كود فريدلأي شخصية ، بغض النظر عن النظام الأساسي ، بغض النظر عن البرنامج ، بغض النظر عن اللغة. على سبيل المثال ، عند النظر إلى جدول الرموز ، فإن الحرف "a" له القيمة U + 0061 (سداسي عشري 0x61) ، بينما الحرف "C" له الرمز U + 0043 (0x43) ، والذي يأتي قبل الحرف في Unicode الجدول. "أ".

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

الوظيفة alphaSort (arr) (arr.sort (الوظيفة (a، b) (إرجاع a.localeCompare (b، "en"، ("sensitivity": "base"))؛))؛) ترك الفاكهة = ["قرع الجوز "،" المشمش "،" الشمام "] ؛ alphaSort (فاكهة)>
إذا كنت ترغب في الحصول على مصفوفة مرتبة بترتيب أبجدي عكسي ، فقم فقط بتبديل مواضع a و b في الوظيفة:

الوظيفة alphaSort (arr) (arr.sort (الوظيفة (a، b) (إرجاع b.localeCompare (a، "en"، ("sensitivity": "base"))؛))؛) ترك الفاكهة = ["قرع الجوز "،" المشمش "،" الشمام "] ؛ alphaSort (فاكهة)> ["شمام" ، "قرع الجوز" ، "مشمش"]
تجدر الإشارة هنا إلى أن localeCompare تُستخدم مع الوسيطات ، وعلينا أيضًا أن نتذكر أنها مدعومة بواسطة IE11 + ، بالنسبة للإصدارات الأقدم من IE ، يمكننا استخدامها بدون وسيطات ، وفي حالة الأحرف الصغيرة:

الوظيفة caseSort (arr) (arr.sort (الوظيفة (a، b) (إرجاع a.toLowerCase (). localeCompare (b.toLowerCase ()) ؛)) ؛) ترك الفاكهة = ["قرع الجوز" ، "المشمش" ، "الشمام"]؛ caseSort (فاكهة)> ["مشمش" ، "قرع الجوز" ، "شمام"]

فرز رقمي

دع highScores = ؛ نوع()؛ >
الحقيقة هي أن طريقة sort () تقوم بمقارنة معجمية: مما يعني أنه سيتم تحويل الأرقام إلى سلسلة وسيتم إجراء المقارنات مرة أخرى عن طريق مطابقة الحرف الأول من هذه السلسلة بترتيب أحرف جدول Unicode. لذلك ، نحتاج مرة أخرى إلى تحديد ترتيب الفرز الخاص بنا:

دع highScores = ؛ highScores.sort (الوظيفة (أ ، ب) (إرجاع أ - ب ؛)) ؛ >
مرة أخرى ، لفرز الأرقام بترتيب عكسي ، قم بتبديل مواضع a و b في الوظيفة.

فرز بنية تشبه JSON

لنفترض أن النتائج = [("الاسم": "دانيال" ، "النتيجة": 21768) ، ("الاسم": "مايكل" ​​، "النتيجة": 33579) ، ("الاسم": "أليسون" ، "النتيجة": 38395 )] ؛
في ES6 + ، يمكنك استخدام وظائف الأسهم:

Scores.sort ((a، b) => b.score - a.score)) ؛
بالنسبة إلى المتصفحات القديمة التي لا تحتوي على هذا الدعم:

Scores.sort (الوظيفة (أ ، ب) (إرجاع النتيجة أ - ب الدرجات)) ؛
كما ترى ، فإن الفرز في JavaScript شيء غير واضح إلى حد ما ، وآمل أن تجعل هذه الأمثلة الحياة أسهل بطريقة ما.

العمل مع وظائف الطاقة

في قوة جافا سكريبتيتم تمثيل الوظيفة كـ Math.pow () ، قدم معيار ES7 الجديد عامل أسي جديد - "* *".

الأس

Math.pow (3،2)> 9
هذا الترميز يعني 3 تربيع ، أو 3 × 3 ، مما ينتج عنه 9. يمكن إعطاء مثال آخر ، بالطبع:

Math.pow (5،3) ؛ > 125
أي 5 تكعيب أو 5 × 5 × 5 يساوي 125.

ECMAScript 7 هو الإصدار التالي من JavaScript ، من حيث المبدأ ، يمكننا استخدام عامل الأس الجديد المقترح - * * ، يمكن أن يكون هذا الشكل من الكتابة أكثر وصفًا:

3 ** 2 > 9
على هذه اللحظةدعم هذا المشغل محدود نوعًا ما ، لذلك لا ينصح باستخدامه.

يمكن أن تكون وظيفة الطاقة مفيدة في مجموعة متنوعة من المواقف. مثال بسيط لحساب عدد الثواني في الساعة: Math.pow (60،2).

الجذر التربيعي والتكعيبي

الرياضيات.صقرت (9)> 3
في نفس الوقت ، الجذر التكعيبي لـ a هو الرقم الذي يعطي a عند تكعيبه.

الرياضيات. cbrt (125)> 5
تم إدخال Math.cbrt () في مواصفات JavaScript مؤخرًا ولذلك فهي مدعومة فقط في المتصفحات الحديثة: Chrome 38+ و Firefox و Opera 25+ و Safari 7.1+. ستلاحظ ذلك متصفح الانترنتليس في هذه القائمة ، ومع ذلك يمكنك العثور على polyfill على MDN.

أمثلة

Math.pow (1.25 ، 2) ؛ > 1.5625 رياضيات. cbrt (56.57)> 3.8387991760286138
لاحظ أن هذا يعمل بشكل جيد عند الاستخدام القيم السالبةالحجج:

Math.pow (-5،2)> 25 Math.pow (10، -2)> 0.01
ومع ذلك ، لن ينجح هذا بالنسبة للجذر التربيعي:

الرياضيات. sqrt (-9)> NaN
من التحليل الرياضي ، نعلم أن الرقم التخيلي يُفهم على أنه الجذور التربيعية للأرقام السالبة. وهذا قد يقودنا إلى تقنية أخرى للعدد المركب ، لكن هذه قصة أخرى.

يمكنك استخدام القيم الكسرية في Math.pow () للعثور على الجذور التربيعية والتكعيبية للأرقام. يستخدم الجذر التربيعي أسًا يساوي 0.5:

Math.pow (5 ، 0.5) ؛ // = Math.sqrt (5) = 5 ** (1/2)> 2.23606797749979
ومع ذلك ، نظرًا لتقلبات النقطة العائمة ، لا يمكنك تخمين النتيجة الصحيحة بالضبط:

Math.pow (2.23606797749979.2)> 5.000000000000001
في مثل هذه الحالات ، سيتعين عليك اللجوء إلى قطع الإشارات من الرقم أو التقريب إلى بعض القيمة.

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

الثوابت الرياضية

Math.abs ، parseInt ، parseFloat

Math.abs ()

دع newVal = -57.64 ؛ Math.abs (newVal) ؛ > 57.64
تُرجع الدالة Math.abs (0) صفرًا دائمًا ، ولكن إذا وضعنا علامة الطرح أمام الدالة -Math.abs (NUM) ، فسنحصل دائمًا على قيمة سالبة.

Math.abs (0) ؛ > -0

parseInt ()

بناء الجملة: parseInt (سلسلة ، الجذر) ؛

تقوم الدالة parseInt بتحويل الوسيطة الأولى التي تم تمريرها إليها إلى نوع سلسلة وتفسيرها وإرجاع عدد صحيح أو قيمة NaN. النتيجة (إذا لم يكن NaN) هي عدد صحيح وهي الوسيطة الأولى (سلسلة) تعامل كرقم في نظام الأرقام المحدد (الجذر). على سبيل المثال ، يشير الأساس 10 إلى التحويل من نظام عشري ، و 8 من رقم ثماني ، و 16 من رقم سداسي عشري ، وهكذا. إذا كانت القاعدة أكبر من 10 ، فسيتم استخدام الأحرف للإشارة إلى الأرقام الأكبر من 9. على سبيل المثال ، تستخدم الأرقام السداسية العشرية (الأساس 16) الأحرف من A إلى F.

ضع في اعتبارك مثالًا للعمل مع خصائص CSS ، حيث يمكننا ، نسبيًا ، الحصول على القيمة التالية:

دع إلم = document.body؛ دعونا centerPoint = window.getComputedStyle (elem) .transformOrigin ؛ > "454 بكسل 2087.19 بكسل"
يمكننا فصل القيم بمسافات:

دع المراكز = centerPoint.split ("") ؛ > ["454px"، "2087.19px"]
ومع ذلك ، لا يزال كل عنصر عبارة عن سلسلة ، يمكننا التخلص من ذلك باستخدام وظيفتنا:

دعونا centerX = parseInt (المراكز ، 10) ؛ > 454 let centerY = parseInt (المراكز ، 10) ؛ > 2087
كما ترى ، كالمعامل الثاني نحدد نظام الأرقام الذي سيتم تحويل الرقم إليه ، هذه المعلمة اختيارية ، لكن يوصى باستخدامها إذا كنت لا تعرف السلسلة التي سيتم إدخالها.

parseFloat ()

بناء الجملة: parseFloat (سلسلة نصية)

LetFP = "33.33333٪" ؛ console.log (parseFloat (FP)) ؛ > 33.33333
لاحظ أنه لا توجد وسيطة ثانية في بناء الجملة parseFloat.

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

غالبًا ما تعطي العمليات الحسابية نتائج لا تتناسب مع النطاقات المرغوبة. نتيجة لذلك ، من الضروري تقريب جافا سكريبتتصل إلى قيمة معينة.

لماذا تقريب الأرقام؟

لا تخزن JavaScript الأعداد الصحيحة لأن قيمها يتم تمثيلها كأرقام فاصلة عائمة. لا يمكن تمثيل العديد من الكسور برقم مع عدد محدد من المنازل العشرية ، لذلك يمكن أن ينتج عن JavaScript نتائج مثل ما يلي:

0.1 * 0.2; > 0.020000000000000004

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

تقريب الكسور العشرية

"لاقتطاع" رقم عشري ، استخدم الأسلوبين toFixed () أو toPrecision (). يأخذ كلاهما وسيطة واحدة ، والتي تحدد عدد المنازل العشرية والمعنوية لتضمينها في النتيجة:

• إذا لم يتم تحديد وسيطة لـ toFixed () ، فإن القيمة الافتراضية هي 0 ، أي لا منازل عشرية ؛ الحد الأقصى لقيمة الوسيطة هو 20 ؛
• إذا لم يتم إعطاء وسيطة لـ toPrecision () ، فلن يتغير الرقم.

var randNum = 6.25 ؛ randNum.toFixed () ، > "6" Math.PI.toPrecision (1) ؛ > "3" var randNum = 87.335 ؛ randNum.toFixed (2) ، > "87.33" var randNum = 87.337 ؛ randNum.toPrecision (3) ؛ > "87.3"

ملحوظة

يقوم كل من toFixed () و toPrecision بإرجاع تمثيل سلسلة مستديرة للنتيجة ، وليس رقمًا. هذا يعني أن إضافة تقريب إلى randNum ستؤدي إلى تسلسل سلسلة بدلاً من رقم واحد:

console.log (randNum + rounded) ؛ > "6.256"

إذا كنت تريد تقريب JavaScript إلى جزء من المئات ، فاستخدم parseFloat ():

var randNum = 6.25 ؛ var rounded = parseFloat (randNum.toFixed (1)) ؛ سجل وحدة التحكم (مدور) ؛ > 6.3

toFixed () و toPrecision () هما أيضًا طريقتان مفيدتان لاقتطاع أعداد كبيرة من المنازل العشرية. هذا مفيد عند التعامل مع الأرقام التي تمثل الوحدات النقدية:

var wholeNum = 1 var dollarCents = wholeNum.toFixed (2) ؛ console.log (دولارسنت) ؛ > "1.00"

لاحظ أنه إذا كان الرقم يحتوي على أرقام أكثر من معلمة الدقة ، فستُرجع toPrecision النتيجة بالتنسيق العلمي:

var num = 123.435 num.toPrecision (2) ؛ > "1.2e + 2"

كيفية تجنب الأخطاء عند تقريب الكسور العشرية

في بعض الحالات ، يتم الإصلاح إلى الدقة JavaScript تقريب 5 لأسفل، وليس أكثر:

var numTest = 1.005 ؛ numTest.toFixed (2) ، > 1 ؛

يجب أن تكون نتيجة المثال أعلاه 1.01 ، وليس 1. إذا كنت تريد تجنب هذا الخطأ ، فإنني أوصي باستخدام الأرقام الأسية:

الدالة round (القيمة ، الكسور العشرية) (رقم الإرجاع (Math.round (القيمة + "e" + الكسور العشرية) + "e -" + decimals) ؛)

طلب:

الجولة (1.005،2) ؛ > 1.01

إذا كنت بحاجة إلى حل أكثر قوة من التقريب ، فهو متاح في MDN.

التقريب مع إبسيلون

طريقة بديلة تقريب JavaScript إلى أعشارتم تقديمه في ES6 ( يُعرف أيضًا باسم JavaScript 2015). « آلة إبسيلون'يوفر هامش خطأ معقول عند مقارنة رقمين من أرقام الفاصلة العائمة. بدون التقريب ، يمكن أن تؤدي المقارنات إلى نتائج مشابهة لما يلي:

0.1 + 0.2 === 0.3> خطأ

يمكن استخدام Math.EPSILON في دالة للحصول على مقارنة صحيحة:

دالة epsEqu (x، y) (إرجاع Math.abs (x - y)< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y)); }

تأخذ الوظيفة حجتين: إحداها تحتوي على الحساب ، والثانية هي النتيجة المتوقعة (المقربة). تقوم بإرجاع مقارنة بين هاتين المعلمتين:

epsEqu (0.1 + 0.2، 0.3)> صحيح

تدعم جميع المتصفحات الحديثة وظائف الرياضيات ES6. ولكن إذا كنت بحاجة إلى تقديم الدعم في المتصفحات القديمة ، فأنت بحاجة إلى استخدام polyfill.

اقتطاع عشري

جميع الأساليب المقدمة في وقت سابق تؤدي تقريب JavaScript إلى أعشار. للاقتطاع رقم موجب، عدد إيجابيإلى منزلتين عشريتين ، اضربها في 100 ، اقتطع مرة أخرى ، ثم اقسم النتيجة على 100 ، فأنت بحاجة إلى:

وظيفة مقطوعة (عدد) (إرجاع Math.trunc (العدد * 100) / 100 ؛) مقطوع (3.1416)> 3.14

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

دالة مقطوعة (num ، decimalPlaces) (var numPowerConverter = Math.pow (10، decimalPlaces) ؛ إرجاع ~~ (num * numPowerConverter) / numPowerConverter ؛)

الاستعمال:

var randInt = 35.874993 ؛ مقطوع (راند إنت ، 3) ؛ > 35.874

التقريب لأقرب رقم

لتنفيذ JavaScript جولة إلى عدد صحيح، يتم استخدام Math.round ():

Math.round (4.3)> 4 Math.round (4.5)> 5

لاحظ أن " نصف القيم"، مثل .5 ، يتم تقريبها لأعلى.

التقريب لأسفل لأقرب عدد صحيح

إذا كنت تريد التقريب للأسفل ، فاستخدم طريقة Math.floor ():

الرياضيات.الطابق (42.23) ؛ > 42 Math.floor (36.93) ؛ > 36

التقريب "لأسفل" له اتجاه واحد لجميع الأرقام ، بما في ذلك الأرقام السالبة. يمكن تخيل هذا على أنه ناطحة سحاب بعدد لا حصر له من الطوابق ، بما في ذلك ما دون مستوى الأساس ( تمثل الأرقام السالبة). إذا كنت في مصعد بين الطوابق السفلية 2 و 3 ( والذي يتوافق مع القيمة -2.5) ، سوف يأخذك Math.floor إلى الطابق -3:

Math.floor (-2.5) ؛ > -3

إذا كنت بحاجة إلى تجنب ذلك ، فاستخدم تقريب JavaScript Math مع Math.trunc () ، المدعوم في جميع المتصفحات الحديثة (باستثناء آي إي / إيدج):

Math.trunc (-41.43) ؛ > -41

توفر MDN أيضًا ملفات 3-line polyfill لتوفير الدعم لـ Math.trunc في المتصفحات القديمة و IE / Edge.

التقريب لأقرب رقم صحيح

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

الرياضيات.ceil (42.23) ؛ > 43 Math.ceil (36.93) ؛ > 37 Math.ceil (-36.93) ؛ -36

التقريب لأقرب مضاعف

إذا كنت تريد تقريب قيمة إلى أقرب مضاعف للعدد 5 ، فأنشئ دالة تقسم الرقم على 5 وتقربه لأعلى ، ثم تضرب النتيجة بنفس القيمة:

الدالة roundTo5 (عدد) (إرجاع Math.round (عدد / 5) * 5 ؛)

الاستعمال:

roundTo5 (11) ؛ > 10

إذا كنت بحاجة إلى إجراء تقريب JavaScript إلى منزلتين عشريتين ، فيمكنك تمرير كل من الأصل والتعدد إلى الوظيفة:

دالة roundToMultiple (عدد ، متعددة) (إرجاع Math.round (عدد / مضاعف) * مضاعف ؛)

لاستخدام الوظيفة ، قم بتضمين الرقم المراد تقريبه والتعدد في دعوته:

var initialNumber = 11 ؛ فار متعدد = 10 ؛ roundToMultiple (initialNumber ، متعددة) ؛ > 10 ؛

لتقريب القيم لأعلى أو لأسفل فقط ، استبدل الدالة المستديرة بالسقف أو الأرضية.

ملزم بنطاق

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

الاستعمال:

var lowBound = 1 ؛ varhighBound = 100 ؛ varnumInput = 123 ؛ var clamped = Math.max (lowBound، Math.min (numInput، highBound)) ؛ سجل وحدة التحكم (مثبت) ؛ > 100 ؛

يمكنك إنشاء وظيفة أو امتداد لفئة الرقم.

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

دالة isFinite

تسمح لك الدالة isFinite بالتحقق مما إذا كانت الوسيطة عددًا محدودًا.

كإجابة وظيفة معينةتُرجع خطأ إذا كانت الوسيطة هي Infinity أو -Infinity أو NaN أو سيتم تحويلها إلى إحدى هذه القيم الرقمية الخاصة. خلاف ذلك ، ستعود هذه الوظيفة صحيحًا.

IsFinite (73) ؛ // صحيح isFinite (-1/0) ؛ // false isFinite (إنفينيتي) ؛ // false isFinite (NaN) ؛ // false isFinite ("Text") ؛ // خطأ شنيع

يستثني وظيفة عالميةيحتوي isFinite JavaScript أيضًا على طريقة Number.isFinite. على عكس isFinite ، لا يفرض تحويل الوسيطة إلى رقم.

IsFinite ("73") ؛ // صحيح Number.isFinite ("73") ؛ // خطأ شنيع

وظيفة isNaN

تستخدم وظيفة isNaN لتحديد ما إذا كانت الوسيطة رقمًا أو يمكن تحويلها إلى واحد. إذا كان الأمر كذلك ، فإن دالة isNaN ترجع خطأ. وإلا فإنه يعود صحيحًا.

IsNaN (NaN) ؛ // صحيح isNaN ("25px") ؛ // صحيح ، لأن 20 بكسل ليس رقمًا هو NaN (25.5) ؛ // false isNaN ("25.5") ؛ // false isNaN ("") ؛ // خطأ ، لأن يتم تحويل مسافة أو مسافات متعددة إلى 0 isNaN (خالية) ؛ // خطأ ، لأن يتم تحويل القيمة الخالية إلى 0 isNaN (صواب) ؛ // خطأ ، لأن يتم تحويل true إلى 1 isNaN (خطأ) ؛ // خطأ ، لأن يتم تحويل القيمة الخاطئة إلى 0

إذا كان هذا الإجراء بحاجة إلى أن يتم تنفيذه بدون نوع المصبوب ، فاستخدم طريقة Number.isNaN. تم إدخال هذه الطريقة في اللغة منذ ECMAScript 6.

كيفية تحويل سلسلة صريحة إلى رقم؟

يمكنك صراحة تحويل سلسلة إلى رقم باستخدام الطرق التالية:

1. استخدم عامل أحادي +يوضع قبل القيمة.

+ "7.35" ؛ // 7.35 + "نص" ؛ // NaN

تتجاهل هذه الطريقة المسافات في بداية السطر ونهايته ، وكذلك \ n (تغذية السطر).

+ "7.35" ؛ //7.35 + "7.35 \ n" ؛ //7.35

استخدام من هنامن الضروري الانتباه إلى حقيقة ذلك سطر فارغأو سلسلة تتكون من مسافات و \ n يتم تحويلها إلى الرقم 0. بالإضافة إلى ذلك ، تقوم أيضًا بتحويل نوع البيانات الفارغة والقيمة المنطقية إلى رقم.

باطل؛ // 0 + صحيح ؛ // 1 + خطأ ؛ // 0 + "" ؛ // 0

2. parseInt وظيفة. تم تصميم هذه الوظيفة للتحويل حجة لعدد صحيح. على عكس استخدام ملفات عامل أحادي +, هذه الطريقةيسمح لك بتحويل سلسلة إلى رقم ، حيث ليست كل الأحرف رقمية. يبدأ في تحويل السلسلة ، بدءًا من الحرف الأول. وبمجرد أن تصادف حرفًا ليس حرفًا رقميًا ، تتوقف هذه الوظيفة عن عملها وتعيد الرقم الناتج.

ParseInt ("18 بكسل") ؛ // 18 parseInt ("33.3٪") ؛ // 33

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

ParseInt ("18px" ، 10) ؛ // 18 parseInt ("33.3٪" ، 10) ؛ // 33 parseInt ("101"، 2) ؛ // 5 parseInt ("B5" ، 16) ؛ // 181

بالإضافة إلى دالة parseInt ، تحتوي JavaScript على طريقة Number.parseInt. لا تختلف هذه الطريقة عن دالة parseInt وتم تقديمها إلى JavaScript بمواصفات ECMASCRIPT 2015 (6).

3. وظيفة parseFloat. تشبه الدالة parseFloat الدالة parseInt ، فيما عدا أنها تسمح لك بتحويل الوسيطة إلى رقم كسري.

ParseFloat ("33.3٪") ؛ //33.3

بالإضافة إلى ذلك ، لا تحتوي وظيفة parseFloat ، على عكس parseInt ، على وسيطتين ، وبالتالي فهي تحاول دائمًا التعامل مع السلسلة كرقم بالتدوين العشري.

ParseFloat ("3.14") ؛ parseFloat ("314e-2") ؛ parseFloat ("0.0314E + 2") ؛

بالإضافة إلى وظيفة parseFloat ، تحتوي JavaScript على طريقة Number.parseFloat. لا تختلف هذه الطريقة عن وظيفة parseFloat وتم تقديمها إلى JavaScript بمواصفات ECMASCRIPT 2015 (6).

تحويل الرقم إلى سلسلة

يمكنك تحويل رقم إلى سلسلة باستخدام طريقة toString.

(12.8) .toString () ، //"12.8 "

يتيح لك التابع toString أيضًا تحديد أساس نظام الأرقام ، مع الأخذ في الاعتبار أنه يجب عليك صراحة إرسال الرقم إلى السلسلة:

(255) .toString (16) ، // "ff"

كيفية التحقق مما إذا كان المتغير رقمًا

يمكنك تحديد ما إذا كانت قيمة المتغير رقمًا باستخدام إحدى الطرق التالية:

1. استخدام الدالتين isNaN و isFinite:

// myVar هو متغير إذا (! isNaN (parseFloat (myVar)) && isFinite (parseFloat (myVar))) (// myVar هو رقم أو يمكن إرساله إليه) ؛

كوظيفة:

// function isNumeric (value) (return! isNaN (parseFloat (value)) && isFinite (parseFloat (value))؛) // Usage var myVar = "12px"؛ console.log (isNumeric (myVar)) ؛ //حقيقي

تتيح لك هذه الطريقة تحديد ما إذا كانت القيمة المحددة رقمًا أو يمكن تحويلها إليها. هذا المتغير لا يحسب سلسلة فارغة ، سلسلة من المسافات ، خالية ، إنفينيتي ، - اللانهاية ، صواب وخطأ كرقم.

2. استخدام الدالتين typeof و isFinite و isNaN:

// دالة تتحقق مما إذا كانت القيمة دالة رقمية هي رقم (قيمة) (نوع إرجاع القيمة === "(! LANG: number" && isFinite(value) && !isNaN(value); }; // использование функции isNumber isNumber(18); //true // использование функций для проверки текстовых значений isNumber(parseFloat("")); //false isNumber(parseFloat("Infinity")); //false isNumber(parseFloat("12px")); //true !}

تحدد هذه الوظيفة ما إذا كانت القيمة المحددة من النوع Number وليست إحدى القيم الخاصة Infinity و -Infinity و NaN. إذا كان الأمر كذلك ، فإن هذه الوظيفة ترجع صحيحًا.

3. استخدام طريقة ECMAScript 6 Number.isInteger (القيمة). تتيح لك هذه الطريقة تحديد ما إذا كانت القيمة المحددة عددًا صحيحًا.

Number.isInteger ("20") ؛ // خطأ ، لأن لا تترجم هذه الطريقة السلسلة إلى رقم Number.isInteger (20) ؛ // صحيح ، لأن القيمة المعطاة هي رقم

الأرقام الزوجية والفردية

يمكنك التحقق مما إذا كان الرقم زوجيًا أم فرديًا باستخدام الوظائف التالية:

// دالة للتحقق مما إذا كان الرقم هو دالة زوجية (n) (إرجاع n٪ 2 == 0 ؛) // وظيفة للتحقق مما إذا كان الرقم هو دالة فردية isOdd (n) (إرجاع Math.abs (n٪ 2) == 1 ؛)

ولكن قبل إجراء هذا الفحص ، من المستحسن التأكد من أن القيمة المحددة هي رقم:

القيمة = 20 ؛ إذا (Number.isInteger (القيمة)) (إذا (isEven (القيمة)) (console.log ("Number" + value.toString () + "- even") ؛))

الأعداد الأولية في جافا سكريبت

تأمل في مثال نستمد منه جافا سكريبتالأعداد الأولية من 2 إلى 100.

// الدالة التي تتحقق مما إذا كان الرقم هو دالة أولية هي القيمة الأولية (القيمة) (إذا كانت (isNaN (القيمة) ||! غير محدودة (القيمة) || القيمة٪ 1 || القيمة< 2) return false; var max=Math.floor(Math.sqrt(value)); for (var i = 2; i< = max; i++) { if (value%i==0) { return false; } } return true; } // создать массив, который будет содержать простые числа от 2 до 100 var primaryNumber = ; for (var i = 2; i <= 100; i++) { if(isPrime(i)) primaryNumber.push(i); } // вывести в консоль простые числа от 2 до 100 console.log(primaryNumber);

تقريب رقم في جافا سكريبت

هناك طرق مختلفة لتقريب رقم كسري إلى قيمة عدد صحيح في JavaScript.

1. استخدام طرق Math.floor و Math.ceil و Math.round المصممة خصيصًا لهذا الغرض. تقرب طريقة Math.floor عددًا كسريًا إلى أقرب عدد صحيح ، أي يتجاهل ببساطة الجزء الكسري. تُقرِّب Math.ceil عددًا كسريًا إلى أقرب عدد صحيح. تقوم Math.round بتقريب الرقم لأعلى أو لأسفل بناءً على قيمة الجزء الكسري. إذا كان الجزء الكسري أكبر من أو يساوي 0.5 ، فعندئذٍ لأعلى ، وإلا فسيكون التمرير لأسفل.

Console.log (Math.floor (7.9)) ؛ // 7 console.log (Math.ceil (7.2)) ؛ // 8 console.log (Math.round (7.5)) ؛ // 8

2. استخدام طريقة toFixed (الدقة). تقرب هذه الطريقة الجزء الكسري لرقم إلى الدقة المحددة. يتم إرجاع نتيجة التقريب كسلسلة.

Console.log (7.987.toFixed (2)) ؛ //"7.99 "

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

Console.log (7.987.toFixed (5)) ؛ //"7.98700 "

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

Console.log ((1001) .toPrecision (2)) ؛ //"1.0e+3 "console.log ((1001) .toPrecision (5)) ؛ //"1001.0 "console.log ((12.4) .toPrecision (1)) ؛ // "1e + 1" console.log ((12.4) .toPrecision (2)) ؛ // "12" console.log ((12.4) .toPrecision (3)) ؛ //"12.4 "console.log ((12.4) .toPrecision (5)) ؛ //"12.400 "

4. استخدام عوامل التشغيل المنطقية NOT أو OR.

// عن طريق console.log للنفي المنطقي المزدوج (~ 7.9) ؛ // 7 // باستخدام OR المنطقي مع صفر: console.log (7.9 ^ 0) ؛ // 7

عدد صحيح وجزء من عدد

يمكنك الحصول على الجزء الصحيح من الرقم باستخدام التابعين Math.floor () و parseInt ():

Console.log (Math.floor (7.21)) ؛ // 7 console.log (parseInt (7.21)) ؛ // 7

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

Console.log (7.21٪ 1) ؛ // 0.20999999999999996 // دقيقة إلى منزلين عشريين console.log ((7.21٪ 1) .toFixed (2)) ؛ // "0.21"

بالإضافة إلى ذلك ، يمكن أيضًا الحصول على الجزء الكسري باستخدام الحسابات:

رقم var = 7.21 ؛ var fractionNumber = number - Math.floor (Math.abs (number)) ؛ console.log (fractionNumber) ؛ // 0.20999999999999996

هل الرقم قابل للقسمة

يمكنك تحديد ما إذا كان الرقم قابلاً للقسمة بالتساوي باستخدام عامل النسبة المئوية:

رقم فار = 9 ؛ // إذا كان باقي قسمة الرقم على 3 هو 0 ، فعندئذ نعم ، وإلا لا إذا (الرقم٪ 3 == 0) (console.log ("الرقم" + الرقم + "قابل للقسمة على 3") ؛) وإلا ( وحدة التحكم. السجل ("الرقم" + الرقم + "غير قابل للقسمة على 3") ؛)

تنسيق الأرقام

في JavaScript ، تسمح لك طريقة toLocaleString () بتنسيق إخراج الرقم وفقًا للإعدادات المحلية (إعدادات اللغة لنظام التشغيل).

على سبيل المثال ، لنقم بتنسيق رقم وفقًا للمعايير الإقليمية المثبتة في النظام افتراضيًا:

رقم var = 345.46 ؛ console.log (number.toLocaleString ()) ، // "345،46"

على سبيل المثال ، لنقم بتنسيق رقم وفقًا للمعايير الإقليمية لروسيا (ru):

Console.log ((108.1) .toLocaleString ("ru-RU")) ؛ //"108.1 "

يمكن استخدام هذه الطريقة أيضًا لتنسيق رقم كعملة:

Console.log ((2540.125) .toLocaleString ("ru-RU"، (style: "currency"، currency: "RUB")))؛ //"2،540.13 ₽ "console.log ((89.3) .toLocaleString (" ru-RU "، (style:" currency "، currency:" USD "))) ؛ //"$89.30 "console.log ((2301.99) .toLocaleString (" ru-RU "، (style:" currency "، currency:" EUR "))) ؛ //"²،301.99 "

تمثيل رقم كنسبة مئوية:

Console.log ((0.45) .toLocaleString ("ru-RU"، (style: "percent")))؛ // "45٪"

قسّم الرقم إلى أرقام (خاصية useGrouping):

Console.log ((125452.32) .toLocaleString ("ru-RU"، (useGrouping: true))) ؛ // "125 452.32"

اطبع رقمًا بعدد معين من الأرقام (2) بعد الفاصلة العشرية:

Console.log ((1240.4564) .toLocaleString ("ru-RU"، (minFractionDigits: 2، maxFractionDigits: 2)))؛ //"1240.46 "

مقارنة الأرقام

تُستخدم العوامل التالية لمقارنة الأرقام في JavaScript: == (يساوي) ،! = (لا يساوي) ،> (أكبر من) ،< (меньше), >= (أكبر من أو يساوي) ،<= (меньше или равно).

على سبيل المثال ، دعنا نقارن بين رقمين:

Console.log (2> 3) ؛ // false console.log (5> = 3) ؛ //حقيقي

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

على سبيل المثال ، في JavaScript ، مجموع الأرقام (0.2 + 0.4) لا يساوي 0.6:

Console.log ((0.2 + 0.4) == 0.6) ؛ //خطأ شنيع

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

على سبيل المثال ، الرقم 0.25 10 بوصة النظام الثنائيتحويل بالضبط.

0.125 × 2 = 0.25 | 0 0.25 × 2 = 0.5 | 0 0.5 × 2 = 1 | 1 0.125 10 = 0.001 2

على سبيل المثال ، الرقم 0.2 10 يمكن تحويله إلى نظام 2 بدقة معينة فقط:

0.2 × 2 = 0.4 | 0 0.4 × 2 = 0.8 | 0 0.8 × 2 = 1.6 | 1 0.6 × 2 = 1.2 | 1 0.2 × 2 = 0.4 | 0 0.4 × 2 = 0.8 | 0 0.8 × 2 = 1.6 | 1 0.6 × 2 = 1.2 | 1 0.2 × 2 = 0.4 | 0 0.4 × 2 = 0.8 | 0 0.8 × 2 = 1.6 | 1 0.6 × 2 = 1.2 | 1 ... 0.2 10 = 0.001100110011 ... 2

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

0.6000000000000001==0.6

عند حساب أو عرض الأرقام مع جزء كسري ، يجب عليك دائمًا تحديد الدقة التي يتم بها القيام بذلك.

على سبيل المثال ، قارن الأرقام حتى منزلتين عشريتين باستخدام الأسلوبين toFixed () و toPrecision ():

// طريقة toFixed () console.log ((0.2 + 0.4) .toFixed (2) == (0.6) .toFixed (2)) ؛ // صحيح // toPrecision () method console.log ((0.2 + 0.4) .toPrecision (2) == (0.6) .toPrecision (2)) ؛ //حقيقي

عمليات الرياضيات الأساسية

يحتوي JavaScript على العوامل الرياضية التالية: + (إضافة) ، - (طرح) ، * (مضاعفة) ، / (قسمة) ،٪ (باقي القسمة) ، ++ (زيادة القيمة بمقدار 1) ، - (تقليل القيمة بمقدار 1 ).

6 + 3 // 9 6-3 // 3 6 * 3 // 18 6/3 // 2 6٪ 3 // 0 ، أي 6: 3 = 2 => 6-3 * 2 => بقية (0) 5٪ 2 // 1 ، أي 5: 2 = 2 (.5) => 5-2 * 2 => بقية (1) 7.3٪ 2 //1.3 ، أي 7.3: 2 = 3 (.65) => 7.3-2 * 3 => بقية (1.3) // علامة نتيجة العملية٪ تساوي علامة القيمة الأولى -9٪ 2.5 //-1.5 ، أي 9: 2.5 = 3 (.6) => 9-2.5 * 3 => بقية (1.5) -9٪ -2.5 //-1.5 ، أي 9: 2.5 = 3 (.6) => 9-2.5 * 3 => راحة (1.5) -2٪ ​​5 // - 2 ، أي 2: 5 = 0 (.4) => 2-5 * 0 => بقية (2) x = 3 ؛ سجل وحدة التحكم (x ++) ؛ // يعرض 3 ، ثم يعين y على 4 console.log (x) ؛ // 4 × = 3 ؛ سجل وحدة التحكم (++ x) ؛ // يعين 4 والمخرجات x = 5 ؛ سجل وحدة التحكم (x--) ؛ // المخرجات 5 ، y ثم تعين 4 console.log (x) ؛ // 4 س = 5 ؛ سجل وحدة التحكم (- x) ؛ // يعين على 4 والمخرجات بالإضافة إلى ذلك ، هناك عوامل تشغيل مشتركة في JavaScript: x + = y (x = x + y) ، x- = y (x = x-y) ، x * = y (x = x * y) ، س / = ص (س = س / ص) ، س٪ = ص (س = س٪ ص). س = 3 ؛ ص = 6 ؛ س + = ص ؛ سجل وحدة التحكم (x) ؛ // 9 س = 3 ؛ ص = 6 ؛ س- = ص ؛ سجل وحدة التحكم (x) ؛ // - 3 × = 3 ؛ ص = 6 ؛ س * = ص ؛ سجل وحدة التحكم (x) ؛ // 18 س = 3 ؛ ص = 6 ؛ س / = ص ؛ سجل وحدة التحكم (x) ؛ //0.5 س = 3 ؛ ص = 6 ؛ س٪ = ص ؛ سجل وحدة التحكم (x) ؛ // 3