تلخيص وتنظيم بناء الجملة الأساسي لجافا سكريبت

الكاتب：Eve Cole وقت التحديث：2022-08-08 08:55:00

توفر لك هذه المقالة المعرفة ذات الصلة بجافا سكريبت، والتي تقدم بشكل أساسي المشكلات المتعلقة ببناء الجملة الأساسية. دعونا نلقي نظرة عليها معًا، وآمل أن تكون مفيدة للجميع.

مقدمة

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

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

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

تم توحيد لغة JavaScript كلغة بواسطة ECMA (الرابطة الأوروبية لمصنعي أجهزة الكمبيوتر) من خلال ECMAScript.

يضيف يضيف

اسم	السنة	الوصف
1997	ECMAScript 1	الإصدار الأول
1998	ECMAScript 2	تغييرات الإصدار
1999	ECMAScript 3	إضافة تعبير عادي إضافة محاولة/التقاط
	لم يتم إصدار	ECMAScript 4.
ECMAScript 5	لعام 2009	"الوضع الصارم"، ويضيف الوضع الصارم دعم JSON.
2011	ECMAScript	5.1
فئات	ووحدات	نمطية.
يضيف	ECMAScript 7	عامل تشغيل أسي (**). إضافة

استخدام

Array.prototype.includes

يجب أن تكون البرامج النصية في HTML موجودة بين علامتي <script> و</script>. يمكن وضع البرامج النصية في قسمي <body> و<head> في صفحة HTML.

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

المثال 1: وظيفة البرنامج النصي في الرأس

<!DOCTYPE html>
<html لانج="ar">
<الرأس>
    <ميتا محارف = "UTF-8">
    <title>النص البرمجي في علامة الرأس</title>
    <النص البرمجي>
        الدالة myFunction() {
            document.getElementById("demo").innerHTML = "هذه هي وظيفتي";
        }
    </script>
</الرأس>
<الجسم>
<h1>وظيفتي</h1>
<p id="demo">فقرة</p>
<button type="button" onclick="myFunction()">هذه دالة</button>
</الجسم>
</html>

المثال 2: وظيفة البرنامج النصي في النص

<!DOCTYPE html>
<html لانج="ar">
<الرأس>
    <ميتا محارف = "UTF-8">
    <title>النص في النص</title>
</الرأس>
<الجسم>
<h1>وظيفتي</h1>
<p id="demo">وظيفتي</p>
<button type="button" onclick="myFunction()">انقر</button>
<النص البرمجي>
    الدالة myFunction() {
        document.getElementById("demo").innerHTML = "هذه هي وظيفتي"
    }
</script>
</الجسم>
</html>

يمكن أيضًا وضع JavaScript خارجيًا للاتصال. لاحظ أن الامتداد الخارجي هو .js.

مثال 3: استدعاء خارجي JavaScriptExternal

call.js

function myFunction() {
    document.getElementById('demo').innerHTML = "هذه هي وظيفتي"
}

استدعاء البرنامج النصي الخارجي

<!DOCTYPE html>
<html لانج="ar">
<الرأس>
    <ميتا محارف = "UTF-8">
    <title>استدعاء البرنامج النصي الخارجي</title>
</الرأس>
<الجسم>
<p id="demo">فقرة من النص</p>
<button type="button" onclick="myFunction()">جربه</button>
<script src="external script.js"></script>
</الجسم>
</html>

يمكن

إخراج

بيانات جافا سكريبت بطرق مختلفة:

استخدم window.alert() ليظهر مربع تحذير.
استخدم طريقة document.write() لكتابة المحتوى في مستند HTML.
استخدم InternalHTML للكتابة إلى عناصر HTML.
استخدم console.log() للكتابة إلى وحدة تحكم المتصفح.

المثال 1: إخراج النافذة المنبثقة aler()

<!DOCTYPE html>
<html لانج="ar">
<الرأس>
    <ميتا محارف = "UTF-8">
    <title>إخراج التنبيه</title>
</الرأس>
<الجسم>
<h1>مخرجات التنبيه</h1>
<النص البرمجي>
    نافذة التنبيه (5 + 6)
</script>
</الجسم>
</html>

المثال 2: إخراج document.write()

<!DOCTYPE html>
<html لانج="ar">
<الرأس>
    <ميتا محارف = "UTF-8">
    <title>مخرجات document.write</title>
</الرأس>
<الجسم>
<h1>مخرجات document.write</h1>
<النص البرمجي>
    document.write(Date());
    document.write("مرحبا، الويب!");
</script>
</الجسم>
</html>

مثال 3: الكتابة إلى مستند HTML

<!DOCTYPE html>
<html لانج="ar">
<الرأس>
    <ميتا محارف = "UTF-8">
    <title>الكتابة إلى مستند HTML</title>
</الرأس>
<الجسم>
<h1>الكتابة إلى مستند HTML</h1>
<النص البرمجي>
    الدالة myFunction() {
        document.write("مخرجات الوظيفة");
    }
</script>
<button onclick="myFunction()">انقر هنا</button>
</الجسم>
</html>

المثال 4: استخدم console.log() للكتابة إلى وحدة تحكم المتصفح

<!DOCTYPE html>
<html لانج="ar">
<الرأس>
    <ميتا محارف = "UTF-8">
    <title>استخدم console.log() للكتابة إلى وحدة تحكم المتصفح</title>
</الرأس>
<الجسم>
<h1>يكتب console.log() إلى وحدة تحكم المتصفح</h1>
<النص البرمجي>
    أ = 5؛
    ب = 6؛
    ج = أ + ب؛
    console.log(ج)
</script>
</الجسم>
</html>

مقدمة بناء الجملة

JavaScript هي لغة برمجة نصية، وهي لغة برمجة خفيفة الوزن ولكنها قوية.

في لغات البرمجة، تسمى القيم الثابتة بشكل عام بالحرفيات

الرقم الحرفي: يمكن أن يكون عدداً صحيحاً أو عشرياً، أو تدويناً علمياً (e). مثل 3.14، 5.88، إلخ.
سلسلة حرفية: " يمكنك استخدام علامات الاقتباس المفردة أو المزدوجة. مثل "Hello"، و"Web"، وما إلى ذلك.
التعبير الحرفي: قيمة ثابتة للحساب. 3 + 2.2، 3.14 * 2، إلخ.
Array (Array ): حرفي: تعريف مصفوفة مثل [1،2،3،4،5،6]
. "".
الوظيفة الحرفية: تعريف دالة. على سبيل المثال، function myFunction(a, b) { return a * b;}.

لاحظ أنه في JavaScript، يجب إنهاء العبارة بـ ";" .متغيرات JavaScrip

في

لغات البرمجة، تُستخدم المتغيرات لتخزين قيم البيانات. تستخدم JavaScript الكلمة الأساسية var لتحديد المتغيرات، وتستخدم علامة المساواة لتعيين قيم للمتغيرات. يمكن أن تعمل المتغيرات على بعضها البعض:

var y = false // القيمة المنطقية var length = 16; // الرقم var point = x * 10; // حساب الرقم var lastName = "Johnson"; // String var Cars = ["Saab", "Volvo", "BMW"]; "John"، lastName:"Doe"}; // قاموس الكائنات

وظيفة JavaScript

من أجل الإشارة بشكل متكرر إلى نفس الوظيفة وتقليل سهولة كتابة التعليمات البرمجية وصيانتها، توفر JavaScript وظائف وظيفية، مسترشدة بالوظيفة الرئيسية:

function myFunc (a) ، ب) {
    return a + b; // إرجاع نتيجة a+b}

ميزات JavaScript

بالمقارنة مع اللغات الأخرى، تحتوي JavaScript على الميزات التالية:

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

جديدة default إذا

كلمات جافا سكريبت الأساسية (بالترتيب الأبجدي)
مجردة	آخر	مثيل	للتعداد
المنطقي	الفائق	int	التبديل
كسر	واجهة	التصدير	بايت
متزامن	يمتد	السماح	لهذه
الحالة	كاذبة	طويلة	رمي
الصيد	النهائي	رميات	أصلية
شار	أخيرًا	فئة	عابرة
تعويم	فارغة	صحيح	const
للحزمة	حاول	متابعة	الوظيفة
نوع	خاص	من	مصحح
الأخطاء	انتقل إلى	محمي	var
كانت	تطبيقات	حذف	الفراغ
العام	تُرجع	volatile	،
فقم	باستيراد	قصير	بينما
تضاعف	بشكل	ثابت	باستخدام

تعليق JavaScript (مثل Java)

// هذا هو الكود: تعليق جملة واحدة، عادةً ما يكون مفتاح ctrl + L في المحرر.

/* هذا هو الكود*/: تعليقات متعددة الأسطر، عادةً ما تكون مفاتيح ctrl + Shift + L في المحرر.

عبارات

JavaScript هي أوامر يتم إصدارها للمتصفح، لإخبار المتصفح بما يجب عليه فعله. تقوم عبارة JavaScript التالية بإخراج النص "Hello World!" إلى عنصر HTML بالمعرف = "demo":

document.getElementById("demo").innerHTML = "Hello World!";

على عكس Python، فإن كتل تعليمات JavaScript كلها موجودة في In الأقواس المتعرجة، وهذا يشبه إلى حد كبير جافا.

معرف جافا

يتم تنفيذ كتلة بيان تحدد يتم استخدام مفتاح يعلن

معرف جافا سكريبت المشترك
بيان	وصف
الفاصل	يستخدم للخروج من الحلقة.
الالتقاط	عند حدوث خطأ أثناء تنفيذ كتلة عبارة المحاولة.
يستمر	في تخطي التكرار في الحلقة.
do ... while	ينفذ كتلة البيان ويستمر في تنفيذ كتلة البيان عندما يكون البيان الشرطي صحيحًا.
for	يمكنه تنفيذ كتلة التعليمات البرمجية لعدد محدد من المرات عندما تكون العبارة الشرطية صحيحة.
for ... in	يُستخدم لاجتياز خصائص مصفوفة أو كائن (حلقة عبر خصائص مصفوفة أو كائن).
الوظيفة	وظيفة
إذا... وإلا	لتنفيذ إجراءات مختلفة بناءً على شروط مختلفة.
وظيفة الخروج	والعودة
لتنفيذ	إجراءات مختلفة بناءً على ظروف مختلفة.
رمي	يلقي (يولد) خطأ.
تحاول	تنفيذ معالجة الأخطاء ويتم استخدامها مع الصيد.
var	عن متغير.
بينما	عندما تكون العبارة الشرطية صحيحة، قم بتنفيذ كتلة العبارة.

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

var a = 10;
var b=10;

على غرار Python، تعد JavaScript أيضًا لغة برمجة نصية ويتم تفسيرها.

تعريف

الكائن

: كل شيء هو كائن، وهو مثال مجرد للخصائص بين الأشياء التي لها نفس الخصائص. مثل شياو مينغ بين البشر.

في JavaScript، الكائن عبارة عن حاوية لمتغيرات السمات، تشبه القاموس في Python أو خريطة التجزئة في Java، والتي تحدد سمات الكائن.

فار الناس = {
    الاسم الأول: "مايك"،
    الاسم الأخير: "سميث"،
    العمر: "18"،
    العنوان: "بكين"،
    الوظيفة : "طالبة"
};

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

للوصول إلى خصائص الكائن

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

<!DOCTYPE html>
<html لانج="ar">
<الرأس>
    <ميتا محارف = "UTF-8">
    <title>هذا هو الموقع</title>
</الرأس>
<الجسم>
<h1>الوصول إلى سمات الفئة</h1>
<!--يجب أن تأتي العبارة التالية قبل البرنامج النصي-->
<p id="demo"></p>
<النص البرمجي>
    فار الناس = {
        الاسم الأول: "مايك"،
        الاسم الأخير: "سميث"،
        العمر: "18"،
        العنوان: "بكين"،
        الوظيفة : "طالبة"
    };
    document.getElementById("demo").innerHTML =
        People["firstName"] + "."+people.lastName;
</script>
</الجسم>
</html>

هناك طريقتان للوصول، يمكنك استخدام اسم الكائن.خاصية أو اسم الكائن.["خاصية"].

الوظيفة

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

المعلمات وقيم الإرجاع

عند استدعاء دالة، يمكنك تمرير قيم لها، تسمى المعلمات، وليس هناك حد لعدد المعلمات.

الدالة myFunction ( var1 ، var2 )
{
شفرة
}

عند استدعاء المعلمات، يجب تمريرها بما يتوافق تمامًا مع ترتيبها، كما هو موضح أدناه:

<!DOCTYPE html>
<html لانج="ar">
<الرأس>
    <ميتا محارف = "UTF-8">
    <title>هذا موقع جافا سكريبت</title>
</الرأس>
<الجسم>
<h1>مشكلة في تمرير معلمة الدالة</h1>
<p>انقر فوق الزر أدناه للاتصال</p>
<button onclick="myFunc('Mike','18','Beijing')">انقر هنا</button>
<النص البرمجي>
    وظيفة myFunc(الاسم، العمر، العنوان) {
        تنبيه("اسمي " + الاسم + "، والعمر هو" + العمر + "، وبيتي في " + العنوان)؛
    }
</script>
</الجسم>
</html>

يُسمح لوظائف JavaScript بالحصول على قيم إرجاع، والكلمة الرئيسية للإرجاع هي return. عندما تقوم الدالة بإرجاع قيمة، ستتوقف الوظيفة عن التنفيذ، ولن يتم تنفيذ العبارات التالية للإرجاع.

مثال: حساب حاصل ضرب رقمين وإرجاع النتيجة

<!DOCTYPE html>
<html لانج="ar">
<الرأس>
    <ميتا محارف = "UTF-8">
    <title>موقع جافا سكريبت</title>
</الرأس>
<الجسم>
<h1>احسب قيمة رقمين وارجعها</h1>
<p id="demo"></p>
<النص البرمجي>
    وظيفة myFunc(أ، ب) {
        العودة أ * ب؛
    }

    document.getElementById("demo").innerHTML = myFunc(3, 4);
</script>
</الجسم>
</html>

المتغيرات

تنقسم متغيرات جافا سكريبت إلى نوعين:

المتغيرات العامة: المتغيرات المعلنة خارج الوظيفة هي متغيرات عامة ، ويمكن لجميع البرامج النصية والوظائف الموجودة على صفحة الويب الوصول إليها.
المتغيرات المحلية: المتغير المعلن داخل دالة JavaScript (باستخدام var) هو متغير محلي، لذلك لا يمكن الوصول إليه إلا داخل الوظيفة.

عندما نقوم بتعيين قيمة لمتغير جافا سكريبت غير معلن، سيتم التعامل مع المتغير تلقائيًا كخاصية للنافذة. على سبيل المثال، العبارة التالية:

name = "Mike"؛

ستعلن عن اسم سمة النافذة. المتغيرات العامة التي تم إنشاؤها عن طريق تعيين قيم للمتغيرات غير المعلنة في الوضع غير الصارم هي سمات قابلة للتكوين للكائن العام ويمكن حذفها. على سبيل المثال:

var var1 = 1; // لا يمكن تكوين الخصائص العامة var2 = 2; // بدون إعلان var، يمكن تكوين الخصائص العامة console.log(this.var1);
console.log(window.var1);

حذف var1؛ // خطأ لا يمكن حذف console.log(var1);

حذف فار2؛ 
console.log(حذف var2);
console.log(var2); // تم حذف متغير الخطأ

وصف

الحدث

غير المحدد:

أحداث HTML هي الأشياء التي تحدث في عناصر HTML. عند استخدام JavaScript في صفحات HTML، يمكن لـ JavaScript تشغيل هذه الأحداث.

يمكن أن تكون أحداث HTML عبارة عن إجراءات للمتصفح أو إجراءات للمستخدم. فيما يلي أمثلة لأحداث HTM:

انتهاء تحميل صفحة HTML
يتغير حقل إدخال HTML
يتم النقر فوق زر HTML

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

علامات الاقتباس المفردة: < some-HTML-element some-event = ' JavaScript code ' >
علامات الاقتباس المزدوجة: < some-HTML-element some-event = " JavaScript code " >

<!DOCTYPE html>
<html لانج="ar">
<الرأس>
    <ميتا محارف = "UTF-8">
    <title>حدث جافا سكريبت</title>
</الرأس>
<الجسم>
<h1>طريقتان للتعامل مع أحداث JavaScript</h1>
<p id="demoOne"></p>
<button onclick="getElementById('demoOne').innerHTML=Date()">انقر لعرض الوقت 1</button>
<p id="demoTwo"></p>
<button onclick="this.innerHTML=Date()">انقر لعرض الوقت 2</button>
</الجسم>
</html>

عادةً ما تكون JavaScript عبارة عن تعليمات برمجية متعددة الأسطر، ويتم استدعاء الكود الأقل شيوعًا من خلال سمات الحدث.

<!DOCTYPE html>
<html لانج="ar">
<الرأس>
    <ميتا محارف = "UTF-8">
    <title>حدث جافا سكريبت</title>
</الرأس>
<الجسم>
<h1>استدعاء سمة حدث JavaScript</h1>
<p>انقر لتنفيذ وظيفة <em>myFunc()</em></p>
<button onclick="myFunc()">انقر هنا</button>
<p معرف = "واحد"></p>
<النص البرمجي>
    الدالة myFunc() {
        document.getElementById("one").innerHTML = Date();
    }
</script>
</الجسم>
</html>

عند

أحداث HTML الشائعة
وصف	الحدث
التغيير يتغير	عنصر HTML
عند النقر	ينقر المستخدم على عنصر HTML
عند تمرير	الماوس يحرك المستخدم الماوس على عنصر HTML
عند خروج	الماوس يحرك المستخدم الماوس بعيدًا عن عنصر HTML
عند الضغط على المفتاح	يضغط المستخدم على مفتاح لوحة المفاتيح
عند التحميل	أكمل المتصفح الصفحة وسيستمر تعلم المزيد من الأحداث بعد التحميل

دور الحدث

يمكن استخدام الأحداث للتعامل مع التحقق من صحة النموذج وإدخال المستخدم وسلوك المستخدم وإجراءات المتصفح:

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

يمكن استخدام طرق متعددة لتنفيذ كود الحدث:

يمكن
لسمة
حدث HTML تنفيذ كود JavaScript مباشرة.
يمكنك منع وقوع الأحداث

سلسلة

: مجموعة من الأحرف.

var a = "abc";
var b = "Hello";

على غرار Python، يمكن الوصول إلى كل حرف في السلسلة باستخدام فهرس:

var c = b[1]; // e

length

يمكن لهذه الخاصية حساب طول السلسلة.

<!DOCTYPE html>
<أتش تي أم أل>
<الرأس>
    <ميتا محارف = "utf-8">
    <title>طول السلسلة</title>
</الرأس>
<الجسم>
<النص البرمجي>
    var txtOne = "مرحبًا بالعالم!";
    document.write("<p>" + txtOne.length + "</p>");
    var txtTwo = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    document.write("<p>" + txtTwo.length + "</p>");
</script>
</الجسم>
</html>

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

شرطة السطر r النقل مسافة للخلف

الأحرف الخاصة الشائعة في جافا سكريبت
إخراج	رمز
'	اقتباس مفرد
"	اقتباس مزدوج
\	مائلة عكسية
n	تغذية
	إرجاع
ttab	(حرف علامة التبويب)
b	حرف
	fformfeed

سلسلة أحرف ككائن

، عادةً ما تكون سلاسل JavaScript عبارة عن قيم أولية و يمكن إنشاؤها باستخدام الأحرف: var firstName = "Mike"، ولكن يمكننا أيضًا استخدام الكلمة الأساسية الجديدة لتعريف سلسلة ككائن: var firstName = new String("Mike")، والتي تشبه

Java الشائعة يُرجع مُنشئ خاصية السلسلة، للسلسلة

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

سلسلة الكائن، ويُرجع تقوم يقوم يقوم ملف تُرجع يستخدم يعثر إلى أحرف كبيرة

الشائعة،
ووصف	الطريقة
charAt()	يُرجع الحرف في موضع الفهرس المحدد،
charCodeAt()	تحديد
قيمة Unicode للحرف في موضع الفهرس
بربط سلسلتين أو أكثر وإرجاع السلسلة المتصلة	.
fromCharCode ()	بتحويل Unicode إلى سلسلة.
IndexOf ()	بإرجاع الموضع الذي يظهر فيه الحرف المحدد لأول مرة
السلسلة
lastIndexOf ()	موضع التواجد الأخير للحرف المحدد في السلسلة،
localeCompare ()	ترتيبًا محليًا محددًا لمقارنة سلسلتين،
match ()	على تطابق لواحد أو أكثر من التعبيرات العادية،
ويستبدل ()	بـ التعبير العادي مطابقة
بحث السلسلة الفرعية ()	يسترد القيمة التي تطابق
شريحة التعبير العادي ()	يستخرج جزءًا من السلسلة ويعيد الجزء المستخرج في سلسلة جديدة
Split ()	يقسم السلسلة إلى مصفوفة من السلاسل الفرعية
substr ()	استخراج المحدد عدد الأحرف في السلسلة من
سلسلة فرعية رقم فهرس البداية ()	استخرج الأحرف بين رقمين الفهرس المحددين في السلسلة
toLocaleLowerCase ()	تحويل السلسلة إلى أحرف صغيرة وفقًا للغة المضيف، لا يوجد سوى عدد قليل من اللغات (مثل التركية) لديها تعيين حالة محلي خاص
إلىLocaleUpperCase()	لتحويل السلاسل إلى أحرف كبيرة وفقًا للغة المضيف. عدد قليل فقط من اللغات (مثل التركية) لديها تعيين حالة محلي خاص
إلىLowerCase()	لتحويل السلاسل
تحويل إلى أحرف صغيرة
toString()	إرجاع قيمة كائن السلسلة
toUpperCase()	تحويل السلسلة إلى أحرف كبيرة
Trim()	إزالة الفراغات البادئة والزائدة لقيمة السلسلة
valueOf()	إرجاع القيمة الأصلية لكائن سلسلة

== و === الفرق

1. بالنسبة للأنواع الأساسية مثل السلسلة والرقم، هناك فرق

بين == و === أ) المقارنة بين الأنواع المختلفة، == يقارن "القيم بعد التحويل إلى نفس النوع" لمعرفة ما إذا كانت "القيم" " متساويان، === إذا كان النوعان مختلفين، ستكون النتيجة غير متساوية.
ب) للمقارنة من نفس النوع، فإن مقارنة "القيمة" المباشرة ستؤدي إلى نفس النتيجة.

2. بالنسبة للأنواع المتقدمة مثل Array وObject، لا يوجد فرق بين == و===

في مقارنة "عنوان المؤشر".

3. هناك فرق بين الأنواع الأساسية والأنواع المتقدمة

أ) بالنسبة لـ ==، قم بتحويل ملف النوع المتقدم إلى النوع الأساسي وإجراء مقارنة "القيمة"
ب) نظرًا لاختلاف الأنواع، تكون النتيجة === خاطئة

4. != هي عدم تشغيل ==، !== هي عدم تشغيل = ==

فار رقم=1;

فار str = "1"؛

اختبار فار = 1 ؛

test == num //true نفس النوع ونفس القيمة test === num //true نفس النوع ونفس القيمة test!== num //false test له نفس نوع num، وقيمته هي نفسها أيضًا يجب أن يكون عدم التشغيل كاذبًا 

num == str //true قم بتحويل str إلى رقم وتحقق مما إذا كان متساويًا. 

num != str //false == رقم غير عملي === str // النوع false مختلف، ويُرجع خطأ مباشرةً

num !== str //true الأنواع المختلفة من num وstr تعني أنهما

غير

متساويين
،	ومن	الطبيعي	أن	تكون
عدم	التشغيل

صحيحة

x =y+2	7	5
- الطرح	x	=y-2	3	5
*	الضرب	x=y*2	10	5
/	القسمة	x=y/2	2.5	5
%	الوحدة (الباقي)	x=y%2	1	5
++	الزيادة	x =++y	6	6
++	الزيادة	x=y++	5	6
--decrement	=	--y	4	4
--decrement	=	x=y--	5	4

أمثلة

عوامل التشغيل الشائعة لجافا سكريبت (x=10, y=5
)	تعادل	العمليات	النتيجة
=	x =y		x=5
+=	x+=y	x=x+y	x=15
-=	x-=y	x=xy	x=5
*=	x*=y	x=x*y	x=50
/=	x/=y	x= x/y	x=2
%=	x%=y	x=x%y	x=0

عوامل المقارنة الشائعة لجافا سكريبت (x=5)
قيمة إرجاع	مقارنة	وصف	المشغل
==	تساوي	x==8	false
==	تساوي	x==5	true
= = =	متساوون تمامًا (كلا القيمة والنوع متساويان)	x====5"	false
= = =	متساوون تمامًا (كلا القيمة والنوع متساويان)	x===5	صحيح
!=	لا يساوي	x!=8	صحيح
!==	غير متساويين تمامًا (أحد القيمة والنوع غير متساويين) متساويان، أو كلاهما غير متساويين)	x!=="5"	true
!==		x!==5	false
>	أكبر من	x>8	false
<	أقل من	x<8	صحيح
>=	أكبر من أو يساوي	x>=8	false
<=	أقل من أو يساوي	x<= 8	صحيح
<=	أقل من أو يساوي	x<=8	صحيح

عوامل التشغيل المنطقية الشائعة لـ JavaScript (x=6, y=3)
أمثلة	وصف	عوامل التشغيل
&&	و	(x < 10 && y > 1) هي صحيح
\|\|	أو	(x== 5 \|\| y==5) خطأ
!	(	x==y) صحيح

تحتوي JavaScript أيضًا على عوامل شرطية تقوم بتعيين قيم للمتغيرات بناءً على شروط معينة. على سبيل المثال:

variname=(condition)?value1:value2

الحكم الشرطي

في جافا سكريبت، يمكننا استخدام العبارات الشرطية التالية:

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

عبارة if

ستنفذ التعليمات البرمجية فقط عندما يكون الشرط صحيحًا. على سبيل المثال:

<!DOCTYPE html>
<html lang="zh-CN">
<الرأس>
    <meta http-equiv="content-Type" charset="UTF-8">
    <meta http-equiv="x-ua-compatible" content="IE=edge">
    <title>موقع جافا سكريبت</title>
</الرأس>
<الجسم>
<h1>هذه عبارة if</h1>
<button onclick="myFunc()">انقر هنا</button>
<p معرف = "واحد"></p>
<النص البرمجي>
    الدالة myFunc() {
        فار س = "";
        var time = new Date().getHours();
        إذا (الوقت <20) {
            x = "مرحبًا، قبل الساعة 20:00";
        }
        document.getElementById("one").innerHTML = x;
    }
</script>
</الجسم>
</html>

عبارة if...else

استخدم عبارة if...else لتنفيذ التعليمات البرمجية عندما يكون الشرط صحيحًا وتعليمات برمجية أخرى عندما يكون الشرط خاطئًا.

<!DOCTYPE html>
<html lang="zh-CN">
<الرأس>
    <meta http-equiv="content-Type" charset="UTF-8">
    <meta http-equiv="x-ua-compatible" content="IE=edge">
    <title>موقع جافا سكريبت</title>
</الرأس>
<الجسم>
<h1>هذه عبارة if...else</h1>
<button onclick="myFunc()">انقر هنا</button>
<p معرف = "واحد"></p>
<النص البرمجي>
    الدالة myFunc() {
        فار س = "";
        var time = new Date().getHours();
        إذا (الوقت <20) {
            x = "مرحبًا، قبل الساعة 20:00";
        }آخر {
            x = "مرحبًا، بعد الساعة 20:00";
        }
        document.getElementById("one").innerHTML = x;
    }
</script>
</الجسم>
</html>

عبارات if..else المتعددة

<!DOCTYPE html>
<html lang="zh-CN">
<الرأس>
    <meta http-equiv="content-Type" charset="UTF-8">
    <meta http-equiv="x-ua-compatible" content="IE=edge">
    <title>موقع جافا سكريبت</title>
</الرأس>
<الجسم>
<h1>عبارات if...else المتعددة</h1>
<button onclick="myFunc()">انقر هنا</button>
<p معرف = "واحد"></p>
<النص البرمجي>
    الدالة myFunc() {
        فار س = "";
        var time = new Date().getHours();
        إذا (الوقت <12) {
            س = "صباح الخير";
        } وإلا إذا (الوقت < 14) {
            س = "مساء الخير";
        }
        آخر {
            س = "مساء الخير";
        }
        document.getElementById("one").innerHTML = x;
    }
</script>
</الجسم>
</html>

بيان التبديل

استخدم بيان التبديل لتحديد واحدة من كتل التعليمات البرمجية المتعددة التي سيتم تنفيذها. على سبيل المثال:

<!DOCTYPE html>
<html lang="zh-CN">
<الرأس>
    <meta http-equiv="content-Type" charset="UTF-8">
    <meta http-equiv="x-ua-compatible" content="IE=edge">
    <title>موقع جافا سكريبت</title>
</الرأس>
<الجسم>
<h1>بيان التبديل</h1>
<button onclick="myFunc()">انقر هنا</button>
<p معرف = "واحد"></p>
<النص البرمجي>
    الدالة myFunc() {
        فار س = "";
        var time = new Date().getMonth();
        التبديل (الوقت) {
            الحالة 0:
                س = "يناير";
                استراحة؛
            الحالة 1:
                س = "فبراير";
                استراحة؛
            الحالة 2:
                س = "مارس";
                استراحة؛
            الحالة 3:
                س = "أبريل";
                استراحة؛
            الحالة 4:
                س = "مايو";
                استراحة؛
            الحالة 5:
                س = "جين";
                استراحة؛
            الحالة 6:
                س = "يوليو";
                استراحة؛
            الحالة 7:
                س = "أغسطس";
                استراحة؛
            الحالة 8:
                س = "سبتمبر";
                استراحة؛
            الحالة 9:
                س = "أكتوبر";
                استراحة؛
            الحالة 10:
                س = "نوفمبر";
                استراحة؛
            الحالة 11:
                س = "ديسمبر";
                استراحة؛
            تقصير:
                س = "خطأ";
        }
        document.getElementById("one").innerHTML = x;
    }
</script>
</الجسم>
</html>

تدعم

Loop

JavaScript أنواعًا مختلفة من الحلقات:

for - يكرر كتلة التعليمات البرمجية لعدد معين من المرات
for/in - يكرر خصائص الكائن
while - يكرر كتلة التعليمات البرمجية المحددة عندما يكون الشرط المحدد صحيحًا
do/while - أيضًا عند التحديد عندما يكون الشرط صحيحًا، قم بتكرار مقطع التعليمات البرمجية المحدد

للحلقة

<!DOCTYPE html>
<أتش تي أم أل>
<الرأس>
    <ميتا محارف = "utf-8">
    <title>حلقة جافا سكريبت</title>
</الرأس>
<الجسم>
<h1>انقر فوق الزر لتكرار الكود 5 مرات. </h1>
<button onclick="myFunc()">انقر هنا</button>
<p id="demo"></p>
<النص البرمجي>
    الدالة myFunc() {
        فار س = "";
        لـ (var i = 0; i < 5; i++) {
            x = x + "الرقم هو" + i + "<br>";
        }
        document.getElementById("demo").innerHTML = x;
    }
</script>
</الجسم>
</html>

fo /in حلقة

<!DOCTYPE html>
<html lang="zh-CN">
<الرأس>
    <meta http-equiv="content-Type" charset="UTF-8">
    <meta http-equiv="x-ua-compatible" content="IE=edge">
    <العنوان>العنوان</العنوان>
</الرأس>
<الجسم>
<p>انقر فوق الزر أدناه لاجتياز السمات الشخصية للكائن</p>
<button onclick="myFunc()">انقر هنا</button>
<p معرف = "واحد"></p>
<النص البرمجي>
    الدالة myFunc() {
        دع س؛
        دع النص = ""؛
        شخص ثابت = {
            الاسم الأول: "بيل"،
            الاسم الأخير: "البوابات"،
            العمر: 56
        };
        لـ (x شخصيًا) {
            text = text + "" + person[x];
        }
        document.getElementById("one").innerHTML = text;
    }
</script>
</الجسم>
</html>

أثناء تكرار الحلقة

<!DOCTYPE html>
<html lang="zh-CN">
<الرأس>
    <meta http-equiv="content-Type" charset="UTF-8">
    <meta http-equiv="x-ua-compatible" content="IE=edge">
    <العنوان>العنوان</العنوان>
</الرأس>
<الجسم>
<p>انقر فوق الزر وسيتم طباعة الإخراج إذا كان i أقل من 5</p>
<button onclick="myFunc()">انقر هنا</button>
<p id="one">اعرض هنا</p>
<النص البرمجي>
    الدالة myFunc() {
        دع x = ""، i = 0؛
        بينما (ط < 5) {
            x = x + "هذا الرقم هو" + i + "<br>";
            أنا++;
        }
        document.getElementById("one").innerHTML = x
    }
</script>
</الجسم>
</html>

افعل/أثناء تكرار

<!DOCTYPE html>
<html lang="zh-CN">
<الرأس>
    <meta http-equiv="content-Type" charset="UTF-8">
    <meta http-equiv="x-ua-compatible" content="IE=edge">
    <العنوان>العنوان</العنوان>
</الرأس>
<الجسم>
<p>انقر فوق الزر لطباعة رقم أقل من 5</p>
<button onclick="myFunc()">انقر هنا</button>
<p معرف = "واحد"></p>
<النص البرمجي>
    الدالة myFunc() {
        دع س = ""؛
        دعني = 0؛
        يفعل {
            x = x + "الرقم هو" + i + "<br>";
            أنا++;
        }
        بينما (ط < 5)؛
        document.getElementById("one").innerHTML=x;
    }
</script>
</الجسم>
</html>

مقارنة بين حلقة for و while حلقة

<!DOCTYPE html>
<html lang="zh-CN">
<الرأس>
    <meta http-equiv="content-Type" charset="UTF-8">
    <meta http-equiv="x-ua-compatible" content="IE=edge">
    <العنوان>العنوان</العنوان>
</الرأس>
<الجسم>

<p>هذا هو funcOne</p>
<button onclick="funcOne()">انقر فوق funcOne</button>
<p id="one">funcOne هنا</p>

<p>هذه هي funcTwo</p>
<button onclick="funcTwo()">انقر فوق funcTwo</button>
<p id="two">funcTwo هنا</p>

<النص البرمجي>
    وظيفة فونكون () {
        الأرقام = [1، 2، 3، 4، 5، 6، 7، 8، 9]؛
        دعني = 0؛
        دع addRes = 0؛
        بينما (الأرقام[i]) {
            addRes += number[i];
            أنا++;
        }
        document.getElementById("one").innerHTML = addRes + "<br>";

    }

    وظيفة funcTwo() {
        الأرقام = [1، 2، 3، 4، 5، 6، 7، 8، 9]؛
        دعني = 0؛
        دع مولريس = 1؛
        لـ (؛ الأرقام [i]؛) {
            mulRes *= أرقام[i];
            أنا++;
        }
        document.getElementById("two").innerHTML = mulRes + "<br>";
    }
</script>

</الجسم>
</html>

يتم استخدام عبارات

Break وContinue

لكسر الحلقات. يتم استخدام المتابعة لتخطي التكرار في الحلقة.

<!DOCTYPE html>
<html lang="zh-CN">
<الرأس>
    <meta http-equiv="content-Type" charset="UTF-8">
    <meta http-equiv="x-ua-compatible" content="IE=edge">
    <العنوان>العنوان</العنوان>
</الرأس>
<الجسم>
<p>هذه هي عبارات المتابعة والكسر</p>
<button onclick="funcOne()">انقر فوق funcOne</button>
<p id="one">هذا هو funcOne</p>
<ر>
<ر>
<ر>
<ر>
<ر>
<ر>
<button onclick="funcTwo()">انقر فوق funcTwo</button>
<p id="two">هذه هي funcTwo</p>
<النص البرمجي>
    وظيفة فونكون () {
        دع س = ""؛
        دعني = 0؛
        لـ (i = 0; i < 10; i++) {
            إذا (ط < 5) {
                استراحة؛
            }
            x = x + "الرقم هو" + i + "<br>";
        }
        document.getElementById("one").innerHTML = x;
    }

    وظيفة funcTwo() {
        دع س = ""؛
        دعني = 0؛
        لـ (i = 0; i < 10; i++) {
            إذا (ط === 8) {
                يكمل؛
            }
            x = x + "الرقم هو" + i + "<br>";
        }
        document.getElementById("two").innerHTML = x;
    }
</script>

</الجسم>
</html>

typeof، null وغير محدد

يستخدم عامل التشغيل typeof للكشف عن نوع بيانات المتغير.

<!DOCTYPE html>
<html lang="zh-CN">
<الرأس>
    <meta http-equiv="content-Type" charset="UTF-8">
    <meta http-equiv="x-ua-compatible" content="IE=edge">
    <العنوان>العنوان</العنوان>
</الرأس>
<الجسم>
<p معرف = "واحد"></p>
<النص البرمجي>
    document.getElementById("one").innerHTML =
        نوع "جون" + "<br>" +
        النوع 3.14 + "<br>" +
        نوع خطأ + "<br>" +
        النوع [1، 2، 3، 4] + "<br>" +
        النوع {الاسم: 'جون'، العمر: 34}؛

</script>

</الجسم>
</html>

في JavaScript، المصفوفة هي نوع خاص من الكائنات. ولذلك فإن typeof [1,2,3,4] يُرجع كائنًا.

null تعني فارغًا، أي "لا شيء". عند استخدام الكشف عن typeof، يتم إرجاع الكائن. يمكن مسح الكائنات باستخدام غير محدد.

<!DOCTYPE html>
<html lang="zh-CN">
<الرأس>
    <meta http-equiv="content-Type" charset="UTF-8">
    <meta http-equiv="x-ua-compatible" content="IE=edge">
    <العنوان>العنوان</العنوان>
</الرأس>
<الجسم>
<p>واحد:</p>
<p معرف = "واحد"></p>
<p>ثانيا:</p>
<p معرف = "اثنين"></p>

<النص البرمجي>
    var person = {firstName: "Bill"، lastName: "Gates"، age: 50};
    var person = null;
    document.getElementById("one").innerHTML = typeof person;
    شخص = غير محدد
    document.getElementById("two").innerHTML = typeof person;
</script>

</الجسم>
</html>

خاصية المُنشئ

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

<!DOCTYPE html>
<html lang="zh-CN">
<الرأس>
    <meta http-equiv="content-Type" charset="UTF-8">
    <meta http-equiv="x-ua-compatible" content="IE=edge">
    <العنوان>العنوان</العنوان>
</الرأس>
<الجسم>

<p>ترجع سمة المنشئ متغيرًا أو مُنشئًا</p>
<p id="one">HRER</p>
<النص البرمجي>
    document.getElementById("one").innerHTML =
        "مرحبا".المنشئ + "<br>" +
        3.14.constructor + "<br>" +
        false.constructor + "<br>" +
        [1، 2، 3].المنشئ + "<br>" +
        {الاسم: "مرحبًا"، العمر: 18}.المنشئ + "<br>" +
        تاريخ جديد ().constructor + "<br>" +
        وظيفة () {
        }.constructor;
</script>

</الجسم>
</html>

تحويل النوع

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

يتم تحويلها تلقائيًا بواسطة جافا سكريبت نفسها
باستخدام وظائف جافا سكريبت

<!DOCTYPE html>
<html lang="zh-CN">
<الرأس>
    <meta http-equiv="content-Type" charset="UTF-8">
    <meta http-equiv="x-ua-compatible" content="IE=edge">
    <العنوان>العنوان</العنوان>
</الرأس>
<الجسم>

<p>يمكن لطريقة String() تحويل الأرقام إلى سلاسل</p>
<p id="one">هنا</p>
<p>يمكن للأسلوب toString() تحويل الأرقام إلى سلاسل</p>
<p id="two">هنا</p>
<النص البرمجي>
    دع س = 123؛
    document.getElementById("one").innerHTML =
        سلسلة (س) + "<br>" +
        سلسلة (123) + "<br>" +
        سلسلة (100 + 23)؛
    document.getElementById("two").innerHTML =
        x.toString() + "<br>" +
        (123).toString() + "<br>" +
        (100 + 123.2).toString();
</script>

</الجسم>
</html>

يمكن استخدام

المعامل الأحادي+

المعامل+ لتحويل المتغيرات إلى أرقام:

<!DOCTYPE html>
<html lang="zh-CN">
<الرأس>
    <meta http-equiv="content-Type" charset="UTF-8">
    <meta http-equiv="x-ua-compatible" content="IE=edge">
    <العنوان>العنوان</العنوان>
</الرأس>
<الجسم>

<P>يُرجع عامل التشغيل typeof المتغير أو نوع التعبير</P>
<button onclick="myFuncOne()">انقر هنا</button>
<p id="one">هنا</p>
<button onclick="myFuncTwo()">انقر هنا مرتين</button>
<p id="two">هنا</p>
<النص البرمجي>
    الدالة myFuncOne() {
        دع ص = "5"؛
        دع x = +y;
        document.getElementById("one").innerHTML =
            typeof y + "<br>" + x + "<br>" + typeof x;
    }

    الدالة myFuncTwo() {
        دع = "مرحبا"؛
        دع ب = +أ؛
        document.getElementById("two").innerHTML =
            typeof a + "<br>" + b + "<br>" + typeof b;
    }

</script>
</الجسم>
</html>

صحيح

نوع جافا سكريبت تحويل
القيمة البدائية	تحويل إلى رقم	تحويل إلى سلسلة	تحويل إلى قيمة منطقية
خطأ	0	"خطأ"	خطأ
1	"	صحيح"	صحيح
0	0	"0"	خطأ
1	1	"1"	صحيح
"0"	0	"0"	صحيح
"000"	0	"000"	صحيح
"1"	1	"1"	صحيح
NaN	NaN	"NaN"	false
إنفينيتي إنفينيتي	"	إنفينيتي"	صحيح
-إنفينيتي	-إنفينيتي	"-إنفينيتي"	صحيح
""	0	""	خطأ
"20"	20	" 20 "	صحيح
"رنوب"	NaN	"رنوب"	صحيح
[ ]	0	""	صحيح
[20]	20	"20"	صحيح
[10,20]	NaN	"10,20"	صحيح
["رونوب"]	NaN	"رونوب"	صحيح
["رونوب " "Google"]	NaN	"Runoob,Google"	true
function(){}	NaN	"function(){}"	true
{ }	NaN	"[object Object]"	true
null	0	"null"	false
غير محدد	NaN	"غير محدد	"

تعبير عادي

خاطئ

التعبير العادي (الإنجليزية: التعبير العادي، غالبًا ما يتم اختصاره كـ regex أو regexp أو RE في الكود) يستخدم سلسلة واحدة لوصف ومطابقة سلسلة من أنماط البحث عن السلسلة التي تتوافق مع قاعدة بناء جملة معينة.

يتم استخدام

search()

لاسترداد سلسلة فرعية محددة في سلسلة، أو استرداد سلسلة فرعية تطابق تعبيرًا عاديًا، وإرجاع موضع البداية للسلسلة الفرعية.

<!DOCTYPE html>
<html lang="zh-CN">
<الرأس>
    <meta http-equiv="content-Type" charset="UTF-8">
    <meta http-equiv="x-ua-compatible" content="IE=edge">
    <العنوان>العنوان</العنوان>
</الرأس>
<الجسم>

<p>استرجاع السلسلة ومطابقة الموضع</p>

<button onclick="myFuncOne()">انقر هنا</button>
<p id="one">هنا</p>

<button onclick="myFuncTwo()">انقر هنا مرتين</button>
<p id="two">هنا</p>

<النص البرمجي>
    الدالة myFuncOne() {
        Let str = "Hello,World!";
        document.getElementById("one").innerHTML = str.search(/World/i);
    }

    الدالة myFuncTwo() {
        Let str = "مرحبًا بك في الصين!";
        document.getElementById("two").innerHTML = str.search("الصين");
    }
</script>

</الجسم>

يتم استخدام

</html>

استبدال ()

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

<!DOCTYPE html>
<html lang="zh-CN">
<الرأس>
    <meta http-equiv = "content-type" charset = "utf-8">
    <meta http-equiv = "x-ua- متوافق" content = "ie = edge">
    <العنوان>العنوان</العنوان>
</الرأس>
<الجسم>

<p> التعبير العادي استبدال () استبدال </p>

<button onClick = "myfuncone ()"> انقر فوق واحد </button>
<p id = "One"> Hello ، Java </p>

<button onClick = "myfunctwo ()"> انقر فوق اثنين </button>
<p id = "two"> مرحبًا ، Java </p>

<النص البرمجي>
    وظيفة myfuncone () {
        دع str = document.getElementById ("واحد"). innerhtml ؛
        document.getElementById ("واحد"). innerhtml = str.replace (/java/i ، "python") ؛
    }

    وظيفة myfunctwo () {
        دع str = document.getElementById ("اثنين"). innerhtml ؛
        document.getElementById ("two"). innerhtml = str.replace ("java" ، "javascipt") ؛
    }
</script>

</الجسم>
</html>

نمط التعبير العادي

يقوم

المعدل التعبير المعدل
الوصف	أقوم
بتنفيذ	مطابقة غير حساسة للحالة.
G	بإجراء مباراة عالمية (يجد جميع المباريات بدلاً من التوقف بعد العثور على المباراة الأولى).
M	يؤدي المطابقة متعددة الخطوط.

التعبير المنتظم

حرف خاص
وصف	تعبير
[ABC]	يجد أي حرف بين الأقواس المربعة.
[0-9]	يجد أي رقم من 0 إلى 9.
(x \| y)	يجد أي خيارات مفصولة \|.

التعبير العادي الكمي
الكمي	الوصف
N+	يطابق أي سلسلة تحتوي على واحد على الأقل n .
N*	يطابق أي سلسلة تحتوي على صفر أو أكثر.
ن	؟

يتم استخدام

Test ()

لاكتشاف ما إذا كانت السلسلة تتطابق مع نمط معين.

<!DOCTYPE html>
<html lang = "zh-cn">
<الرأس>
    <meta http-equiv = "content-type" charset = "utf-8">
    <meta http-equiv = "x-ua- متوافق" content = "ie = edge">
    <العنوان>العنوان</العنوان>
</الرأس>
<الجسم>

<النص البرمجي>
    دع OBJ = جديد regexp ("E") ؛
    دع boolone = obj.test ("مرحبًا ، هذا javaScript") ؛
    دع booltwo = obj.test ("هذا هو javaScript") ؛
    document.write (boolone + "<br>" + booltwo) ؛
</script>

</الجسم>
</html>

يتم استخدام

Exec ()

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

<!DOCTYPE html>
<html lang = "zh-cn">
<الرأس>
    <meta http-equiv = "content-type" charset = "utf-8">
    <meta http-equiv = "x-ua- متوافق" content = "ie = edge">
    <العنوان>العنوان</العنوان>
</الرأس>
<الجسم>

<النص البرمجي>
    دع OBJ = جديد regexp (/e/) ؛
    Resone = obj.exec ("مرحبًا ، هذا javaScript") ؛
    RESTWO = OBJ.EXEC ("هذا هو JavaScript") ؛
    /*لا يعني فارغة*/
    document.write (Resone + "<br>" + restwo) ؛
</script>

</الجسم>
</html>

نوع خطأ

استثناء الخطأ

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

TRANER ... catch

the try trate يتيح لنا تحديد كتلة رمز يتم اختبارها للأخطاء أثناء التنفيذ ، ويسمح لنا عبارة CATCL بتحديد كتلة رمز يتم تنفيذها عند حدوث خطأ في كتلة رمز المحاولة.

<!DOCTYPE html>
<html lang = "zh-cn">
<الرأس>
    <meta http-equiv = "content-type" charset = "utf-8">
    <meta http-equiv = "x-ua- متوافق" content = "ie = edge">
    <العنوان>العنوان</العنوان>
</الرأس>
<الجسم>

<type type = "button" value = "عرض رسالة" onClick = "myfunc ()">
<النص البرمجي>
    دع txt = "" ؛

    وظيفة myfunc () {
        يحاول {
            ALERT111 ("مرحبًا ، عالم!")
        }
        catch (err) {
            txt = "هناك خطأ هنا  n  n" ؛
            txt + = "خطأ الوصف:" + err.message + " n  n" ؛
            txt += "انقر فوق" موافق "للمتابعة  n  n" ؛
            تنبيه (txt)
        }
    }
</script>

</الجسم>
</html>

يتيح لنا

Throw

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

<!DOCTYPE html>
<html lang = "zh-cn">
<الرأس>
    <meta http-equiv = "content-type" charset = "utf-8">
    <meta http-equiv = "x-ua- متوافق" content = "ie = edge">
    <العنوان>العنوان</العنوان>
</الرأس>
<الجسم>

<p> الرجاء إدخال رقم بين 5-10 </p>
<label for = "one"> </billy> <input id = "one" type = "text">
<button type = "button" onClick = "myfunc ()"> انقر فوق </button>
<p id = "message"> هنا </p>

<النص البرمجي>
    وظيفة myfunc () {
        دع الرسالة
        دع x ؛
        message = document.getElementById ("Message") ؛
        message.innerhtml = "" ؛
        x = document.getElementById ("واحد"). القيمة ؛
        يحاول {
            إذا (x === "")
                رمي "القيمة فارغة" ؛
            إذا (isnan (x))
                رمي "ليس رقمًا" ؛
            x = الرقم (x) ؛
            إذا (x <5)
                رمي "صغير جدا" ؛
            إذا (x> 10)
                رمي "كبير جدا" ؛
        } التقاط (خطأ) {
            message.innerhtml = "خطأ" + خطأ ؛
        }
    }
</script>

</الجسم>
</html>

استدعاء الدالة

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

استدعاء 1: استدعاء كدالة

واحدة

وظيفة myfunc (a ، b) {
    إرجاع A * B ؛
}

myfunc

1 ، 2)

    إرجاع A * B ؛
}

window.myfunc (1 ، 2

<html lang = "zh-cn">
<الرأس>
    <meta http-equiv = "content-type" charset = "utf-8">
    <meta http-equiv = "x-ua- متوافق" content = "ie = edge">
    <العنوان>العنوان</العنوان>
</الرأس>
<الجسم>

<p> وظائف تسمى أساليب </p>
<p id = "one"> هنا </p>

<النص البرمجي>
    دع myobject = {
        FirstName: "Bill" ،
        اسم العائلة: "البوابات" ،
        fullname: function () {
            إرجاع this.firstName + "" + this.lastname ؛
        }
    };
    document.getElementById ("واحد"). innerhtml = myobject.fullname () ؛
</script>

</الجسم>
</html>

اتصل على 3: استخدم المُنشئ للاتصال بالوظيفة

<! doctype html>
<html lang = "zh-cn">
<الرأس>
    <meta http-equiv = "content-type" charset = "utf-8">
    <meta http-equiv = "x-ua- متوافق" content = "ie = edge">
    <العنوان>العنوان</العنوان>
</الرأس>
<الجسم>

<p> في هذا المثال ، myfunc () هو مُنشئ الدالة </p>
<p id = "one"> </p>
<النص البرمجي>
    وظيفة myfunc (argone ، argtwo) {
        this.name = Argone ؛
        this.number = argtwo ؛
    }

    دع x = جديد myfunc ("Hello" ، 123) ؛
    document.getElementById ("واحد"). innerhtml = x.name ؛
</script>

</الجسم>
</html>

اتصل على 4: اتصل بالوظيفة كطريقة دالة

<! doctype html>
<html lang = "zh-cn">
<الرأس>
    <meta http-equiv = "content-type" charset = "utf-8">
    <meta http-equiv = "x-ua- متوافق" content = "ie = edge">
    <العنوان>العنوان</العنوان>
</الرأس>
<الجسم>

<p> وظائف الاتصال كطرق الوظائف </p>
<p id = "one"> هنا </p>

<النص البرمجي>
    دع OBJ ، صفيف ؛

    وظيفة myfunc (a ، b) {
        إرجاع A * B ؛
    }

    صفيف = [5 ، 6] ؛
    obj = myfunc.apply (obj ، array) ؛
    document.getElementById ("واحد"). innerhtml = obj ؛
</script>

</الجسم>
</html>

إغلاق

الوظائف المدمجة

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

<! doctype html>
<html lang = "zh-cn">
<الرأس>
    <meta http-equiv = "content-type" charset = "utf-8">
    <meta http-equiv = "x-ua- متوافق" content = "ie = edge">
    <العنوان>العنوان</العنوان>
</الرأس>
<الجسم>

<p> وظائف مضمنة </p>
<p id = "one"> هنا </p>

<النص البرمجي>
    document.getElementById ("واحد"). innerhtml = add () ؛

    إضافة وظيفة () {
        دع العداد = 0 ؛

        وظيفة Plus () {
            عداد += 1 ؛
        }

        زائد()؛
        عداد العودة
    }
</script>

</الجسم>
</html>

يسمى التركيز الذاتي لوظيفة

الإغلاق

bibao

<! doctype html>
<html lang = "zh-cn">
<الرأس>
    <meta http-equiv = "content-type" charset = "utf-8">
    <meta http-equiv = "x-ua- متوافق" content = "ie = edge">
    <العنوان>العنوان</العنوان>
</الرأس>
<الجسم>

<p> العداد المحلي </p>
<button type = "button" onClick = "myfunc ()"> counter </utton>
<p id = "one"> هنا </p>

<النص البرمجي>
    دع إضافة = (دالة () {
        دع العداد = 0 ؛
        وظيفة الإرجاع () {
            عداد الإرجاع += 1 ؛
        }
    })();

    وظيفة myfunc () {
        document.getElementById ("واحد"). innerhtml = add () ؛
    }
</script>
</الجسم>
</html>