جافا سكريبت أنواع تجربة القراءة الأساسية والقيم والمتغيرات

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

تنقسم بيانات JavaScript إلى فئتين: النوع البدائي ونوع الكائن

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

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

كائنات JavaScript العادية هي مجموعات غير ضرورية من "القيم المسماة". تحدد JavaScript أيضًا كائنًا خاصًا - صفيف ، يمثل مجموعة من القيم المرقمة. تحدد JavaScript بناء جملة مخصص للصفائف. صنع المصفوفات لها بعض خصائص السلوك الفريدة التي تختلف عن الأشياء العادية.

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

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

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

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

A.Sort () ؛ // فرز (أ) نسخة موجهة نحو الكائن

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

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

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

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

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

1. الأرقام

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

أنا عدد صحيح كمية مباشرة

يتم تمثيل عدد صحيح عشري بتسلسل صفيف في JavaScript

بالإضافة إلى الكمية المباشرة العشرية ، يتعرف JavaScript أيضًا على قيم الآلية الستة عشر (16) باعتبارها Cardinality. نظام سداسي عشري يسمى كمية مباشرة مسبقة بـ "0x" أو "0x" متبوعة بسلسلة من الأرقام السداسية. تتكون القيمة السداسية السداسية من الحروف بين 0-9 و (أ) -f (f). يتم التعبير عن رسائل AF بالأرقام 10-15 أدناه. فيما يلي أمثلة للكميات المباشرة من الأعداد الصحيحة السداسية

نسخة الكود كما يلي:

0xff // 15*16+15 = 255

0xcafe911

على الرغم من أن ECMascript لا يدعم الكميات المباشرة الثمانية ، إلا أن بعض تطبيقات JavaScript يمكن أن تسمح بتمثيل الأعداد الصحيحة في Octal (القاعدة 8). تبدأ الكمية المباشرة الثمانية بالرقم 0 ، تليها سلسلة من الأرقام بين 0 و 7.

نسخة الكود كما يلي:

0377 // 3*64 +7*8 +7 = 255 (عشري)

نظرًا لأن بعض تطبيقات JavaScript تدعم عدد أوكتال بين العدد ، في حين أن البعض لا يفعل ذلك ، فمن الأفضل عدم استخدام عدد صحيح بين الرقم مع 0. في الوضع الصارم لـ ECMASCRIPT6 ، يتم حظر كمية الثماني المباشر بشكل صريح.

الثاني. الكمية المباشرة للنقطة العائمة

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

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

يمكن التعبير عنها في بناء جملة أكثر إيجازًا

نسخة الكود كما يلي:

[أرقام] [. أرقام] [(e | e) [(+|-)] أرقام]

3.14

2345.455

.33333333333333333333333333333333333

6.02e23 //6.02**10 إلى السلطة 23

1.255454e-23 //1.255454*10 إلى السلطة 23

عملية الحساب في III.JavaScript

تستخدم برامج JavaScript مشغلي الحساب المقدمة من مقاطعة اللغة لأداء العمليات العددية. تحتوي هذه المشغلين على + - * / والمشغل المتبقي (الباقي المقسم) ٪

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

نسخة الكود كما يلي:

Math.Pow (2 ، 53) // => 9007199254740992 document.write (Math.Pow (2،53))

Math.Round (.6) //=>1.0 الجولة

Math.ceil (.6) //=>1.0 البحث الصعودي

Math.Floor (.6) //=>0.0 أسفل

Math.ABS (-5) // => 5 أوجد القيمة المطلقة

Math.Max ​​(x ، y ، z) // إرجاع القيمة القصوى

Math.min (x ، y ، z) // إرجاع القيمة الدنيا

Math.Random () // قم بإنشاء رقم عشوائي زائف أكبر من 0 وأقل من 1

Math.PI // PI

Math.e // e: قاعدة اللوغاريتم الطبيعية

Math.Sqrt (3) // 3 جذر تربيعي

Math.Pow (3 ، 1/3) // 3's Cube Root

Math.sin (0) // وظائف المثلثية ، وكذلك Math.cos ، Math.atan ، إلخ.

Math.log (10) //=>2.302585092994046 اللوغاريتم الطبيعي مع قاعدة 10

Math.log (512) /Math.ln2 // سجل 512 مع قاعدة 2

Math.log (100) /Math.ln10 // سجل 100 مع قاعدة 10

Math.EXP (3) // E قوة ثلاثة

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

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

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

نسخة الكود كما يلي:

Infinity // قم بتهيئة متغير قابل للقراءة/الكتابة إلى اللانهاية

number.positive_infinity // نفس القيمة ، اقرأ فقط

1/0 // هذه هي نفس القيمة

number.max_value + 1 // نتيجة الحساب لا تزال لا حصر لها

number.negative_infinity // يدل على اللانهاية السلبية

-infinity

-1/0

-number.max_value -1

NAN // تهيئة متغير قابلة للقراءة/الكتابة إلى NAN

number.nan // نفس القيمة ، ولكن اقرأ فقط

0/0 // نتيجة الحساب لا تزال نان

number.min_value/2 // underflow حدث. النتيجة المحسوبة هي 0

-number.min_value/2 // Zero Zero

-1/اللانهاية // صفر سلبي

-0 // صفر سلبي

هناك القليل من القيم غير الرقمية في JavaScript ، والتي لا تساوي البشر والقيم ، بما في ذلك أنفسهم. بمعنى آخر ، من المستحيل الحكم على ما إذا كان x نان بواسطة x == nan. بدلاً من ذلك ، يجب استخدام x! = x للحكم على أنه إذا وفقط عندما يكون x نان ، فإن نتيجة التعبير صحيحة. وظيفة isnan () تشبه هذا. إذا كانت المعلمة نان أو قيمة غير رقمية (مثل السلسلة وكائن) ، فإنها تُرجع صحيحًا. هناك وظيفة مماثلة في javaScript والتي isfinite () ، والتي ترجع صحيحا عندما لا تكون المعلمات nan أو infinty أو -infinity.

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

نسخة الكود كما يلي:

var Zero = 0 ؛

var negz = -0 ؛

صفر === negz // => القيم الصفرية الإيجابية والسلبية الحقيقية متساوية

1/صفر === 1/negz // اللانهاية الإيجابية الخاطئة واللانهائيات السلبية مختلفة

iiii.binary thurbirit therping point و Errouring Error

هناك عدد لا يحصى من الأرقام الحقيقية ، ولكن لا يمكن أن تمثل JavaScript أرقامًا محدودة فقط من خلال شكل أرقام نقاط عائمة (على وجه الدقة ، هناك 18 437 736 874 454 810 627) ، أي عندما يتم استخدام الأرقام الحقيقية في JavaScript ، فإنه غالبًا ما يكون مجرد تمثيل تقريبي للقيمة الحقيقية.

يعتمد JavaScript IEEE-754 تدوين رقم النقطة العائمة (المستخدمة من قبل جميع لغات البرمجة الحديثة تقريبًا). هذا تمثيل ثنائي يمكن أن يمثل بدقة الكسور ، مثل 1/2 1/8 و 1/1024. لسوء الحظ ، فإن الكسور التي نستخدمها غالبًا ، خاصة في الحسابات المالية ، تستند إلى الكسور العشرية 1/10 ، 1/100 ، إلخ. لا يمكن أن يمثل الترميز الثنائي رقمًا بسيطًا مثل 0.1.

الأرقام في JavaScript لها دقة كافية. ويمكن أن تكون قريبة من 0.1. ولكن في الواقع ، فإن عدم القدرة على التعبير بدقة عن الأرقام يجلب بعض المشاكل.

نسخة الكود كما يلي:

var x = .3 - .2 ؛

var y = .2 - .1 ؛

التنبيه (x == y) // => خطأ لا تساوي القيمتين

x == .1 // => false .3 -.2 لا يساوي .1

y == .1 // => true .2-.1 يساوي 1

بسبب خطأ التقريب ، فإن الفرق التقريبي بين 0.3 و 0.2 لا يساوي في الواقع الفرق التقريبي بين 0.2 و 0.1 (في بيئات المحاكاة الحقيقية ، 0.3-0.2 = 0.099 999 999 999 999 999 98). هذه المشكلة ليست موجودة فقط في JavaScript ، فمن المهم للغاية فهم هذا: ستحدث هذه المشكلة في أي لغة برمجة تستخدم أرقام نقاط عائمة ثنائية. من المهم أيضًا ملاحظة أن قيم x و y في الكود أعلاه قريبة جدًا من بعضها البعض والقيم الصحيحة النهائية. يمكن أن تكون نتيجة الحساب هذه مختصة لمعظم مهام الحساب. تحدث هذه المشكلة فقط عند مقارنة ما إذا كانت القيمتين متساوية.

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

iiiii.date والوقت

يتضمن جوهر لغة JavaScript مُنشئ Date () ، والذي أنشأ في الأصل كائنات من التاريخ والوقت. توفر طرق كائنات التاريخ هذه واجهة برمجة تطبيقات بسيطة لحساب التاريخ. لا يمكن أن تكون كائنات التاريخ نوع بيانات أساسي مثل الأرقام.

نسخة الكود كما يلي:

var Zhen = تاريخ جديد (2011 ، 0 ، 1) ؛ // 1 يناير 2011

var لاحقًا = تاريخ جديد (2011 ، 0 ، 1 ، 17 ، 10 ، 30) ؛ // في نفس اليوم

var الآن = تاريخ جديد () ؛ // التاريخ والوقت الحاليين

var elapsed = الآن - Zhen ؛ // طرح التاريخ. احسب عدد ميلي ثانية من الفاصل الزمني

في وقت لاحق. // => 2011

في وقت لاحق. getMonth () ؛ // => 0 شهرا تم حسابها من 0

في وقت لاحق. getDate () ؛ // => 1 عدد الأيام التي يتم حسابها من 1

في وقت لاحق. getDay () ؛ // => 5 احصل على يوم الأسبوع. 0 يمثل الأحد ، 5 يمثل الأحد

في وقت لاحق. gethours () // => التوقيت المحلي

في وقت لاحق.

2. النص

السلسلة عبارة عن تسلسل غير قابل للتغيير ومرتب من القيم 16 بت ، وعادة ما يأتي كل حرف من مجموعة أحرف Unicode. يمثل JavaScript النص من خلال أنواع السلسلة. طول السلسلة هو عدد القيم 16 بت التي يحتوي عليها. يبدأ فهرس سلسلة JavaScript (وصفيفها) من 0. طول السلسلة الفارغة هو 0 ، ولا يوجد "نوع حرف" يمثل حرفًا واحدًا في JavaScript. لتمثيل قيمة 16 بت ، ما عليك سوى تعيينها إلى متغير سلسلة. طول هذه السلسلة هو 1.

مجموعة الأحرف والرمز الداخلي وسلسلة JavaScript

يستخدم JavaScript مجموعة أحرف Unicode التي ترميزها UTF-16 ، وسلسلة JavaScript هي تسلسل يتكون من مجموعة من القيم 16 بت غير مرتبة. يتم تمثيل أحرف Unicode الأكثر استخدامًا برموز داخلية 16 بت وتمثل حرفًا واحدًا في السلسلة. تتبع أحرف Unicode التي لا يمكن تمثيلها كـ 16 بت قواعد ترميز UTF-16-باستخدام قيمتين 16 بت لتشكيل تسلسل (يُعرف أيضًا باسم "أزواج الوكيل"). هذا يعني أن سلسلة JavaScript ذات الطول 2 (قيمتان 16 بت) قد تمثل حرف Unicode.

نسخة الكود كما يلي:

var p = "π" ؛ // π ممثل برمز داخلي 16 بت 0x03C0

var e = "e" ؛ يتم تمثيل // e برمز داخلي 17 بت 0x1d452

P.Length // => 1 P يحتوي على قيمة 16 بت

يحتوي E.Length // => 2 E المشفر بواسطة UTF-16 على قيمتين: "/UD835/UDC52"

تعمل جميع أساليب تشغيل السلسلة المحددة بواسطة JavaScript على قيم 16 بت ، وليس الأحرف ، ولا تعالج عنصر الوكيل بشكل منفصل. وبالمثل ، لن تقوم JavaScript بتوحيد معالجة السلسلة. ليس هناك ما يضمن أن السلاسل هي تنسيق UTF-16 القانوني

أقوم بسلسلة الكمية المباشرة

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

نسخة الكود كما يلي:

"" // سلسلة فارغة ، 0 أحرف

"الاختبار"

"3.14"

'name = "myform"' '

"ألا تفضل كتاب أورليلي؟"

في ECMASCRIPT3 ، يجب كتابة الكمية المباشرة للسلسلة في سطر واحد ، بينما في ECMASCRIPT5 ، يمكن تقسيم الكمية المباشرة للسلسلة إلى عدة أسطر ، ويجب أن ينتهي كل سطر باستخدام backslash (/). لا الحرف الملاذ أو الطرف الذي ينتهي الخط هو محتويات الكمية المباشرة للسلسلة. إذا كنت تريد أن تكون معًا ، فيمكنك استخدام /n للهروب من الشخصيات.

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

II هرب الشخصيات

في سلاسل JavaScript ، يكون للاضطرابات الخلفية (/) غرض خاص. إن إضافة شخصية إلى التراجع الخلفي لن تمثل معناها الحرفي. على سبيل المثال ، /n هو شخصية الهروب ، والتي تمثل سطر جديد.

نسخة الكود كما يلي:

/o // أحرف nul

/ب // حرف Backspace

/t // حرف علامة التبويب الأفقية

/n // line newline character

/v // حرف علامة التبويب العمودية

/f // تجديد الصفحة

/r // carriage return حرف

/"// اقتباسات مزدوجة

// backslash

/xxx latin-1 الحرف المحدد بواسطة سداسي عشري ثنائي البت

/xxxxxx unicode حرف محدد بواسطة xxxxxx بأربعة بت

استخدام سلسلة III

واحدة من الميزات المدمجة في JavaScript هي سلسلة متسلسل. استخدم المشغل + للسلاسل لتمثيل سلسلة متسلسل. على سبيل المثال

نسخة الكود كما يلي:

var msg = "Hello" + "World" ؛ // قم بإنشاء سلسلة Hello World

لتحديد طول السلسلة - عدد القيم 16 بت التي يحتوي عليها ، يمكنك استخدام سمة الطول ، مثل طول السلسلة.

S.Length

بالإضافة إلى سمة الطول ، توفر السلاسل أيضًا العديد من الطرق التي يمكن استدعاؤها.

نسخة الكود كما يلي:

var s = "Hello ، World" ؛

S.Charat (0) ؛ // "H" الشخصية الأولى

S.Charat (S.Length - 1) // "D" الحرف الأخير

S.SubString (1 ، 4) // "ELL" 2-4 أحرف

S.Slice (1 ، 4) // ELL كما هو مذكور أعلاه

S.Slice (-3) // تظهر الأحرف الثلاثة الأخيرة

S.Indexof (L ") // 2 حرف L الموقف الأول

S.LastIndexof ("L") // 10 آخر مرة تظهر فيها الحرف L

S.Indexof ("L" ، 3) // بعد الموضع 3 ، الموضع الأول حيث تظهر حرف L

S.Split ("،") // => ["Hello" ، "World"] يتم فصلها إلى فرعية

S.Replace ("H" ، "H") // => "Hllo ، World" استبدال حرف النص الكامل

S.ToupperCase () // => "مرحبًا ، العالم"

في JavaScript ، يتم إصلاح السلاسل وغير المتغيرة. طرق مثل استبدال () و touppercase () إرجاع سلاسل جديدة ، والحروف الأصلية نفسها لم تتغير.

في ECMASCRIPT ، يمكن التعامل مع الأحرف كصفائف للقراءة فقط. بالإضافة إلى استخدام طريقة Charat () ، يمكن أيضًا استخدام قوسين مربع للوصول إلى الأحرف الفردية في سلسلة. (قيمة 16 بت)

نسخة الكود كما يلي:

s = "مرحبا ، العالم"

S [0] // => "H"

S [S.Length-1] // => "D"

دعمت Foxfire فهرسة السلسلة لهذه الطريقة منذ وقت طويل ، وتبعت معظم المتصفحات الحديثة (باستثناء IE) خطى Mozailla وأكملت هذه الميزة قبل تشكيل ECMASCRIPT.

iiii مطابقة نمط

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

كائن regexp ليس نوع بيانات أساسي في اللغة. مثل التاريخ ، إنه مجرد كائن خاص به واجهة برمجة تطبيقات عملية. التعبيرات العادية لها بناء جملة معقدة وواجهة برمجة التطبيقات الغنية. سيتم تقديمه بالتفصيل في الفصل 10. REGEXP أداة قوية ومعالجة نصية شائعة الاستخدام ، وهنا مجرد نظرة عامة.

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

نسخة الكود كما يلي:

/^html///// سلاسل المباراة بدءًا

/[1-9] [0-9]*/// تطابق رقم غير صفري ، يليه أي رقم

// bjavaScript/b/i/// تطابق كلمة javaScript وتجاهل الحالة العلوية والسفلية

يحدد كائن REGEXP العديد من الطرق المفيدة ، كما أن السلاسل لديها أساليب يمكنها قبول معلمات regexp. على سبيل المثال:

نسخة الكود كما يلي:

var text = "testing: 1،2،3" ؛ // مثال نص

VAR PANTIDE = // D+/G // تطابق جميع الحالات التي تحتوي على رقم واحد أو أكثر

pattern.test (text) // => true: المباراة ناجحة

text.search (نمط) // => 9: الموضع الذي كانت فيه المباراة الأولى ناجحة

text.match (نمط) // => ["1" ، "2" ، "3"] جميع المباريات تشكل صفيفًا

text.repeat (نمط ، "#") ؛ // => "الاختبار:#،#،#"

text.split (// d+/) ؛ // => ["" ، "1" ، "2" ، "3"]: استخدم الأحرف غير الرقمية لاعتراض السلاسل

3. قيمة منطقية

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

عادة ما تكون نتائج بيانات المقارنة في جافا سكريبت قيمًا منطقية. على سبيل المثال

أ == 4

يتم استخدام هذا الرمز لاكتشاف ما إذا كانت قيمة المتغير تساوي 4. إذا كانت متساوية ، تكون القيمة صحيحة ، إذا كانت القيمة غير متساوية ، خاطئة

عادةً ما تستخدم القيم المنطقية في عبارات التحكم في JavaScript ، مثل IF/else Dites in JavaScript. إذا كانت القيمة المنطقية صحيحة ، فقم بتنفيذ الجزء الأول من المنطق ، وإذا كانت قطعة رمز أخرى خاطئة ، على سبيل المثال

نسخة الكود كما يلي:

إذا (A == 4)

ب = ب + 1 ؛

آخر

a = a + 1 ؛

يمكن تحويل أي قيمة javaScript إلى قيم منطقية ، ويتم تحويل القيم التالية إلى خطأ

نسخة الكود كما يلي:

غير محدد

باطل

0

-0

نان

"" // سلسلة فارغة

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

دعونا نلقي نظرة على مثال. إضافة المتغير O هو كائن أو خالية ، يمكنك استخدام عبارة if لاكتشاف ما إذا كانت O هي قيمة غير فنية.

إذا (O! == NULL) ...

يقارن المشغل غير المتكافئ "! ==" o و null ويعطي النتيجة صحيحة أو خاطئة. يمكنك أولاً تجاهل بيان المقارنة هنا. NULL هو قيمة خاطئة والكائن هو قيمة حقيقية.

إذا (س) ...

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

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

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

نسخة الكود كما يلي:

if ((x == 0 && y == 0) ||! (z == 0)) {

// x و y كلاهما صفر أو Z غير صفريين

}

4. نول وغير محدد

NULL هي كلمة رئيسية في لغة JavaScript. إنه يمثل قيمة خاصة "قيمة فارغة". بالنسبة لـ NULL ، فإنه يؤدي تشغيل typeof () ويعيد الكائن. وهذا يعني ، يمكن اعتبار NULL قيمة كائنات خاصة ، وهذا يعني "عدم الكائن". ولكن في الواقع ، عادة ما يعتبر NULL العضو الوحيد في نوعه المجاني. يمكن أن تمثل أن الأرقام والسلاسل والكائنات "لا قيمة لها". تحتوي معظم لغات البرمجة على فارغة مثل JavaScript ، ويمكنك أن تكون على دراية بـ NULL أو NIL.

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

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

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

5. الكائنات العالمية

تناقش الأقسام السابقة أنواع العناصر والقيم الأصلية لـ JavaScript. أنواع الكائنات - الكائنات والصفائف والوظائف / ولكن هناك فئة مهمة جدًا من الكائنات التي يجب ألا تكون واضحة الآن: الكائنات العالمية

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

الخصائص العالمية مثل infinty غير المحددة و NAN

الوظائف العالمية مثل ISNAN () و Parseint () و eval ()

منشئي مثل Date () و regexp () و string () و Object () و Array ()

الأشياء العالمية ، مثل Math و JSON

السمة الأولية لكائن عالمي ليست كلمة محفوظة ، ولكن يجب معاملتها ككلمة محجوزة.

في المستوى العلوي من رمز الرمز - JavaScript ليس ضمن أي وظيفة ، يمكنك الرجوع إلى الكائن العالمي من خلال الكلمة الرئيسية JavaScript.

var global = هذا ؛ // تحديد متغير عالمي يشير إلى كائن عالمي.

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

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

6. كائن التغليف

كائن JavaScript هو قيمة مركبة: إنها مجموعة من السمات أو القيم المسماة. تتم الرجوع إلى قيمة السمة من خلال ". عندما تكون قيمة السمة وظيفة ، فهي طريقة وتستخدم OM () لنقل الطرق في الكائن O.

نرى أن السلاسل لها أيضًا خصائص وطرق.

نسخة الكود كما يلي:

var s = "Hello World" ؛

var word = S.SubString (S.Indexof ("")+1 ، S.Length) ؛ // استخدم سمات السلسلة.

document.write (Word) // "Ello World"

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

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

انظر إلى الكود التالي وفكر في عملية التنفيذ الخاصة بهم

نسخة الكود كما يلي:

var s = "test" ؛

S.Len = 4 ؛ // تعيين خاصية لذلك

var t = s.len // ابحث عن هذه الخاصية

عند تشغيل هذا الرمز ، تكون قيمة T غير محددة. يقوم السطر الثاني من الكود بإنشاء كائن سلسلة مؤقتة ويمنح Len قيمة 4. ثم يتم تدمير الكائن. يستخدم السطر الثالث السلسلة الأصلية (غير المعدلة) لإنشاء كائن سلسلة جديد ويحاول قراءة سمات LEN.

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

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

نسخة الكود كما يلي:

var s = "اختبار" ،

ن = 1 ،

ب = صحيح ؛

var s = سلسلة (s) الجديدة ؛

var n = number number (n) ؛

var b = new Boolean (b) ؛

يقوم JavaScript بتحويل الغلاف إلى القيمة الأصلية عند الضرورة ، وبالتالي فإن الكائن SNB في الكود السابق في كثير من الأحيان - ولكن ليس دائمًا - يمثل نفس قيمة SNB ، "==" يعامل المشغل القيمة الأصلية وكائن التفاف الخاص به على قدم المساواة.

لكن المشغل الكامل "===" يعاملهم على أنه عدم المساواة ، ويمكن رؤية الفرق بين القيمة الأصلية والكائن الذي يلفه من خلال مشغل typeof.

7. القيم الأصلية غير القابلة للتغيير ومراجع الكائنات القابلة للتغيير.

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

نسخة الكود كما يلي:

var s = "Hello World" ؛

S.ToupperCase () ؛ // إرجاع "Hello World" ولا يغير قيمة s

S // => لم تتغير السلسلة الأصلية "Hello World"

原始值的比较是值的比较，只有在他们的值相当时它们在才相等。这对数字、布尔值、null和undefined来说听起来有点难，并没有其他办法来比较他们。同样，对于字符串来说则不那么明显；如果比较两个单独的字符串，当且仅当他们的长度相等且每个索引的字符都相等时，javascript的才认为相等。

نسخة الكود كما يلي:

var o = {x:1} //定义一个对象

ox = 2 //通过修改对象的属性来改变对象

oy = 3 //再次更改这个对象，给它增加一个新属性

var a =[1,2,3] //数组也是可以修改的

a[0]=0; //更改数组中的一个元素

a[3]=4; 给数组增加一个新元素

对象的比较并非值的比较：即使两个对象包含同样的属性及相同的值，他们也是不相等的，各个索引元素完全相等的两个数组也不相等

نسخة الكود كما يلي:

var o ={x:1}, p={x:1}//两个具有相同属性的两个对象

o === p ;//=>false 两个单独的对象永不相等( o == p ; =>false)

var a =[],b=[]; //两个单独的空数组

a === b ; //=>false两个单独的数组永不相等

我们通常将对象称为引用类型(reference type),以此来和javascript的基本类型区分开来。依照术语的叫法，对象都是引用(reference),对象的比较均是引用的比较；当且当它们应用同一个基对象时，它们才相等。

نسخة الكود كما يلي:

var a = []; //定义一个引用空数组的变量a

var b = a; //变量b引用同一个数组

b[0] = 1;

a[0] //=>1 变量a也会修改

a === b //=>true a和b引用同一个数组，因此他们相等。

就像你刚才看到的如上代码，将对象（或数组）赋值给一个变量，仅仅是赋值的引用值：对象本身并没有复制一次。

如果你想得到一个对象或数组的副本，则必须显式复制对象的每个属性或数组的每个元素。下面的这个例子则是通过循环来完成对数组的复制。

نسخة الكود كما يلي:

var a = ['a', 'b', 'c']; //待复制的数组

var b = []; //复制到目标的空数组

for (var i = 0; i < a.length; i++) { //遍历a[]中的每个元素

b[i] = a[i]; //将元素复制到b中。

}

同样的，如果我们想比较两个单独或者数组，则必须比较他们的属性或元素。下面这段代码定义了一个比较练个数组的函数。

نسخة الكود كما يلي:

function equalArrays(a, b) {

if (a.length != b.length) return false; //两个长度不相同的数组不相等

for (var i = 0; i < a.length; i++) //循环遍历所有元素

if (a[i] !== b[i]) return false; //如果有任意元素不等，则数组不相等

العودة صحيح. // Otherwise they are equal

}

8.类型转化

javascript中的取值型非常灵活，我们已经从布尔值看到了这一点：当javascript期望使用一个布尔值时候，你可以提供任意类型值。javascript将根据需要自行转换类型。一些值（真值）为true，其它值（假值）转化为false.这在其它类型中同样适用。如果javascript期望使用一个字符串，它把给定的值转换为字符串。如果javascript期望使用一个数组，它把给定的值转换为数字（如果转化结果无意义的话将返回NaN）,一些例子如下：

نسخة الكود كما يلي:

10 + "object" //=> "10object";

"7" * "4" // =>28 两个字符串均转化为数字

var n = 1 - "x" // =>NaN字符串x无法转换为数字

n + " objects" // =>"NaN objects":NaN转换为字符串"NaN"

下表说明了在javascript中如何进行类型转化。粗体突出了那些让你倍感意外的类型转化。空单元格表示不必要也没有执行的转换。

上表提到的原始值到原始值的转换行对简单，我们已经在第本文第三小节讨论过转换为布尔值的情况了。所有原始值转换为字符串的情形也已经明确定义。转换为数字的情形比较微妙。那些以数字表示的字符串可以直接转化为数字，也允许在开始和结尾处带有空格。但在开始和结尾处的任意非空字符都不会被当成数字量的一部分，进而造成字符串为数字的结果为NaN。有一些数字转换看起来让人奇怪：true转换为1，false、空字符串""转换为0.

原始值到对象的转换也非常简单，原始值通过调用String()，Number()或Boolean()构造函数，转化为它们各自的包装对象。见本文第6节。

null和undefined属于例外，当将它们用在期望是一个对象的地方都会造成一个类型错误(TypeError)异常。而不会执行正常的转换。

对象到原始值的转换多少有些复杂，本小节第三小节有专门描述。

أنا. Conversion and Equality

由于javascript可以做灵活的类型转换，因此其“==”相等运算符也随相等的含义灵活多变。例如：如下这些比较结果均是true；

null == undefined //这两值被认为相等

"0" == 0 //在比较之前，字符串转换成数字。

0 = false //在这之前布尔值转换成数字。

"0" ==false //在比较之前字符串和布尔值都转换成数字

在第四章9节第一小节相信讲解了“==”等于运算符在判断两个值是否相等时做了那些类型转换，并同样介绍了“===”恒等运算符在判断相等时并未做任何的类型转换。

需要特别注意的是：一个值转换为另一个值并不意味着两个值相等。比如在期望使用布尔值的地方使用了undefined，将会转换为false，但这不表明undefined==false。javascript运算符和语句期望使用多样化的数据类型，并可以互相转换。if语句将undefined转化为false,但“==”运算符从不试图将其转化为布尔值。

الثاني. Explicit type conversion

尽管javascript可以做做很多类型转换，但有时仍需要做显式转换，或者为了使代码变得清晰易读而做显式转换。

做显式转换最重简单的方法就是使用Boolean()、Number()、String()或Object函数。我们在本文第6节已经介绍过了. 当不通过new运算符调运这些函数时，他们会作为类型转换函数并按照上边表格所描述的规则做类型转换。

نسخة الكود كما يلي:

Number("3") //=>3

String(false) //=>"false"或使用false.toString()

Boolean([]) //=>true

Object(3) // =>new Number(3)

需要注意的是，除了null或undefined之外的任何值都具有toString()方法，在这个方法的执行结果通常和String()方法返回的结果一致。同样需要注意的话，如果试图把null或undefined转化为对象。则会抛出一个类型错误typeerro。Object()函数在这种情况下不会抛出异常：它仅简单返回一个新创建的空对象。

javascript中的某些运算符会做隐式的类型转换，有时用于类型转换。如果“+”运算符的一个操作数是字符串，它将会把令一个操作数转换为字符串。一元“+”运算符将其操作数转换为数字。同样，一元“！”运算符将其操作数转换为布尔值取反，在代码中常会看到这种类型转换的惯用法。

نسخة الكود كما يلي:

x + "" // 等于字符串String(x)

+x //等价于Number(x),也可以写成x-0

!!x //等价于Boolean(x)

在计算机中数字的解析和格式化代码是非常普通的工作。javascript中提供了专门的函数和方法用来更加精确的数字到字符串（number-to-string）和字符串到数字(string-to-number)的抓换。

Nmuber类定义的toString()方法可以接收表示基数（二进制，八进制，十六进制等）的可选参数，如果不指定该参数，转化规则将是十进制。同样也可以将数字转换为其它进制数。（范围在2-36之间）

نسخة الكود كما يلي:

var n = 17;

b_string = n.toString(2); //转化为10001

o_string = "0" + n.toString(8); //转化为八进制021

hex_string = "0x" + n.toString(16); //转化为16进制0x11

javascript为控制输出中小数点位置和有效数字位数，或者决定是否需要指定指数计数法。Number类为这种数字到字符串定义了三个方法。

toFixed()根据小数点后指定位数，将数字转换为字符串，它从不使用指数计数法。toExponential()使用指数计数法，将数字转换为指数形式的字符串，其中小数点前只有一位，小数点后的位置则由参数指定（也就是说有效数字位数要比指定的位数多一位）。toPrecision()根据指定的有效数字位数，将数字转换为字符串。如果有效数字的位数小于数字整数部分的位数，则转换成指数形式。我们注意到，三个方法都会适当的进行四舍五入或填充0,

نسخة الكود كما يلي:

var n = 123456.789;

n.toFixed(0); //"123457"

n.toFixed(2); //"123456.79"

n.toFixed(5); //"123456.78900"

n.toExponential(1); //"1.2e+5"

n.toExponential(3); //"1.235e+5"

n.toPrecision(4); // "1.235e+5"

n.toPrecision(7); //"123456.8"

n.toPrecision(10); //"123456.7890"

如果通过Number()转换函数传入一个字符串，它会试图将其转化为一个整数或浮点数直接量，这个方法只能基于十进制进行转换，并且不能出现非法的尾随字符。parseInt()和parseFloat()函数（它们是全局函数，不属于人和类的方法），更加灵活。parseInt()只解析整数。而parseFloat()则可以解析整数和浮点数。如果字符串前边是0x或0X,parseInt()将其解析为16进制数。两个方法都会跳过任意量的前导空格，尽可能解析更多数值字符。并忽略后边的内容。如果第一个是非法的数字直接量，则返回NaN

نسخة الكود كما يلي:

parseInt("3many nice") //=>3;

parseFloat("3.14meters") //=>3.14

parseInt("-12.34") //=>-12

parseInt("0xff") //=>255

parseInt("-0XFF") //=>-255

parseFloat(".1") // =>0.1

parseInt("0.1") //=> 0

parseInt(".1") //=>NaN 不能以.开始

parseInt("$112") //=>NaN 不能以$开头

parseInt()可以接收第二个可选参数。这个参数指定数字转换的基数。合法的取值范围是2-36

نسخة الكود كما يلي:

parseInt("11", 2) //=>3(1*2+1)

parseInt("ff", 16) //=> 255(15*16 +15)

parseInt("zz", 36) //=>1295(35*36+35)

parseInt("077", 8) // 63(7*8 +7)

parseInt("077", 10) //77(7*10+7)

iii.对象转化为原始值。

对象到布尔值的转换非常简单：所有的对象（包括数组和函数）都转换为true。对于包装对象亦是如此，new Boolean(false)是一个对象而不是原始值，它将转换为true。 对象到字符串（object-to-String）和对象到数字(object-to-number)的转换是通过调用带转换对象的一个方法来完成的。一个麻烦的事实是，javascript对象有两个不同的方法来执行转换，并且接下来要讨论并且接下来要讨论的场景更加复杂。值得注意的是，这里提到的字符串和数字的转换规则只适用于本地对象（native fangf object）.宿主对象(例如：由web浏览器定义的对象)，根据各自的算法可以转换成字符串和数字。

所有的对象继承了两个转换方法。第一个是toString(), 它的作用是返回一个反映这个对象的字符串。默认的toString()方法并不会返回一个有趣的值。

({x:1,y:2}).toString() //=>"[object object]"

很多类定义了更多特定版本的toString()方法.

例如：数组类(Array class)的toString()方法将每个数组元素转换为一个字符串，并在元素之间添加逗号后并合成结果字符串。

函数类(Function class)的toString()方法返回这个函数的实现定义的表示方式。实际上，这里的实现方式是通常是将用户定义函数转换为javascript源代码字符串。

日期类(Date class)定义toString()方法返回一个可读的（可被javascript-parsable解析的）日期和事件字符串

RegExp class定义的toString()方法将RegExp对象转换为正则表达式直接量字符串。

نسخة الكود كما يلي:

[1, 2, 3].toString(); //=> "1,2,3"

(function(x) {f(x);}).toString(); // =>"function(x){/nf(x); /n}"

//d+/g.toString(); //=> ///d+/g

new Date(2015, 0, 1).toString() //=>Thu Jan 01 2015 00:00:00 GMT+0800 (中国标准时间)

另外一个函数是valueOf(),这个方法的任务并未详细定义：如果存在任意原始值，它就默认将对象转换为表示它的原始值。对象是复合值，而且大多数对象无法真正表示一个原始值，数组、函数和正则表达式简单地继承了这个默认方法，调用这些类型的实例的的valueOf()方法简单地返回对象本身。日期类定义的valueOf()方法返回它的一个内部表示：1970年1月1日以来的毫秒数。

نسخة الكود كما يلي:

var d = new Date(2015, 0, 1); //=>Thu Jan 01 2015 00:00:00 GMT+0800 (中国标准时间)

d.valueOf() //=>1420041600000

通过是用我们刚才讲解过的toString()和valueOf()方法，就可以做到对象到字符串和对象到数字的转换了。但在某些场景中，javascript执行了完全不同的对象到原始值的转换。这些特殊的场景在本节的最后会讲到。

javascript对象到字符串的转换经过了如下这些步奏

如果对象具有toString()方法，则调用这个方法。如果它返回一个原始值，javascript将这个值转换为字符串（如果本身不是字符串的话），并返回这个字符串结果。

如果对象没toString()方法，或者这个方法并不返回一个原始值，那么javascript会调用valueOf()方法。如果存在这个方法，则javascript调用它。如果返回值是原始值，javascript将责怪值转换为字符串。

9.变量声明。

在javascript程序中，使用一个变量之前应该先声明，变量是通过var来声明的，如下所示：

var i;

var sum;

也可以通过一个var关键字声明多个变量

var i,sun;

而且还可以将变量的初始值和变量声明和写在一起；

var message = "hello";

var i=0 ,j=0,k=0;

If the variable is specified in the var declaration statement, even though the variable is declared, its initial value is undefined before storing it a value. We noticed that the var statement can also be used in the for and fo/in loops, which can more concisely declare the loop variables used in the loop body syntax. على سبيل المثال:

نسخة الكود كما يلي:

for (var i = 0; i < 10; i++) log(i);

for (var i = 0, j = 10; i < 10, j = 100; i++, j--) console.log(i * j)

for (var p in o) console.log(p);

If the variable is specified in the var declaration statement, even though the variable is declared, its initial value is undefined before storing it a value. We noticed that the var statement can also be used in the for and fo/in loops, which can more concisely declare the loop variables used in the loop body syntax. على سبيل المثال:

نسخة الكود كما يلي:

var i=10;

i="ten";

10.变量作用域

一个变量的左右域（scope）是程序源代码中定义这个变量的区域，全局变量拥有全局作用域，在javascript代码中的任何地方都是定义。然而在函数内部声明变量只在函数体内有定义。他们是局部变量，作用是局部性的。函数参数也是局部变量，它们只在函数体内有定义。

在函数体内，局部变量的优先级高于同名的全局变量。如果在函数内声明一个局部变量或者函数参数中带有的变量和全局变量重名，那么全局变量就被局部变量所遮盖。

نسخة الكود كما يلي:

var scope = "global"; //声明一个全局变量

function checkscope() {

var scope = "local"; //声明一个同名的局部变量

return scope;

}

checkscope(); //=>"local"

尽管在全局作用域编写代码时可以不写var语句，但声明局部变量时则必须使用var语句。

نسخة الكود كما يلي:

scope = "global"; //声明一个全局变量,甚至不使用var来声明

function checkscope2() {

scope = "local"; //修改了全局变量

myscope = "local"; //这里显示式得声明了一个新的全局变量

return [scope, myscope]; //

}

checkscope2(); //=> ["local","local"]:产生了副作用

scope // =>"local"全局变量修改了

myscope //=> "local"全局命名空间搞乱了。

函数定义是可以嵌套的。由于每个函数都有它直接的作用域，因此会出现几个局部作用域嵌套的情况。

نسخة الكود كما يلي:

var scope = "global scope"; //全局变量

function checkscope() {

var scope = "local scope"; //局部变量

function nested() {

var scope = "sested scope"; //嵌套作用域内的局部变量

return scope;

}

return nested();

}

checkscope() //=>"嵌套作用域" sested scope

أنا. Function scope and declaration in advance

在一些类似c语言的编程语言中，花括号内的每一段代码都具有各自的左右域，而且变量在声明他们的代码之外是不可见的我们称之为块级作用域(block scope),而javascript中没有块级作用域，javascript取而代之的使用了函数作用域(function scope);变量在声明它们的函数体以及这个函数体嵌套的任意函数体内都是有意义的。

如下代码，在不同的位置定义了ijk，他们都在同一个作用域内，这三个变量在函数体内均有定义的。

نسخة الكود كما يلي:

function test(o) {

var i = 0 ؛ //i is defined throughout the function body

if (typeif o == "object") {

var j = 0; //j在函数体内是有定义的，不仅仅是在这个代码段内

for (var k = 0; k < 10; k++) { //k在函数体内是有定义的，不仅仅是在循环内

console.log(k); //输出数字0-9

}

console.log(k); //k已经定义，输出10

}

console.log(j); //j已经定义了，但可能没有初始化。

}

javascript的函数作用域是指在函数内声明的所有变量在函数体内始终是可见的。有意思的是，这意味这变量在声明之前甚至已经可用。javascript的这个特性被非正式的称为声明提前（hoisting），即javascript函数里声明的所有变量(但不涉及赋值)都被提前至函数整体的顶部。如下代码：

نسخة الكود كما يلي:

var scope = "global";

function f() {

console.log(scope); //输出"undefined",而不是"global"

var scope = "local"; //变量在这里赋初始值，但变量本身在函数体内任何地方都是有定义的

console.log(scope); //输出"local"

你可能误以为函数的第一行会输出"global",因为代码还没有执行到var语句声明局部变量的地方。其实不然，由于函数作用域的特性模具部变量在整个函数体内始终有定义的，也就是说，在函数体内局部变量覆盖了同名全局变量。尽管如此，只有在程序执行到var语句的时候，局部变量才能正真的被赋值。

因此，上述的过程等价于：将函数内的变量声明"提前"至函数顶部，同时变量初始化留在原来的位置：

نسخة الكود كما يلي:

function f() {

var scope; //在函数的顶部声明了局部变量

console.log(scope); //变量存在，但其值是"undefined"

scope = "local"; //在这里将其初始化，并赋值

console.log(scope); //这里它具有了我们所期望的值

}

在具有块级作用域的编程语言中，在狭小的作用域里让变量声明和使用变量的代码尽可能靠近彼此，通常来说，这是一个非常不错的编程习惯。由于在javascript中没有块级作用域，因此一些程序员特意将变量声明放在函数体顶部，而不是将声明放在靠近使用变量之处。这种做法使得他们的源代码非常清晰地反映了真实的变量作用域。

ii作为属性的变量

当声明一个javascript全局变量时面试及上是定义了全局对象的一个属性。见本文第三节。

当使用var声明一个变量时，创建的这个属性是不可配置的。见第六章第7节。也就是说这个变量无法通过delete运算符删除。可能你已经注意到了，如果你没有使用严格模式并给一个未声明的变量赋值的话。javascript会自动创建一个全局变量。以这种方式创建变量是全局对象正常的可配置属性。可以删除它们。

نسخة الكود كما يلي:

var truevar = 1; //声明一耳光不可删除的全局变量

fakevar = 2; //创建全局对象的一个可删除的属性

this.fakevar2 = 3; //同上

delete truevar // =>false 变量并没有删除

delete fakevar //=>true 变量被删除

delete this.fakevar2 //=>true 变量被删除

javascript全局变量是全局对象的属性，这是在ECMAScript规范中强制规定的。对于局部变量则没有此规定，但我们可以想象得到，局部变量当做跟函数调用相关的某个对象的属性。ECMAScript3规范称对象为“调用对象”（call object）,ECMAScript5规定范称为“声明上下文对象”（declarative environment record）。javascript可以允许使用this关键字引用全局对象，却没有方法可以引用局部变量中存放的对象。这种存放局部变量的对象的特有性质，是一种对我们不可见的内部实现。然而，这些局部变量对象存在的观念是非常重要的。

iii作用域链

javascript是基于词法作用域的语言：通过阅读包含变量定义在内的舒航源码就能知道变量的作用域。

全局变量在程序中始终是都是有定义的。局部变量在声明它的函数体内以及其所嵌套的函数内始终是有定义的。