ஜாவாஸ்கிரிப்ட் நிரல் என்பது அறிவுறுத்தல்களின் (அறிக்கைகள்) வரிசையாகும். சில நேரங்களில் அறிவுறுத்தல்கள் ஜாவாஸ்கிரிப்ட் கட்டளைகள் என்றும் அழைக்கப்படுகின்றன.

நிரலை இயக்க, அது தொடங்கப்பட வேண்டும். நிரல் கிளையன்ட் ஸ்கிரிப்டாக இருந்தால், அது உலாவியால் தானாகவே தொடங்கப்படும், ஆனால் அது பக்கக் குறியீட்டில் இருந்தால் மட்டுமே. உலாவி நிரலை இயக்குகிறது, பொதுவாக வலைப்பக்கத்தை ஏற்றும் போது.

வழிமுறைகளை எழுதும் போது, ​​அவை அரைப்புள்ளியால் பிரிக்கப்பட வேண்டும். ஜாவாஸ்கிரிப்ட் என்றால் ஒரு அறிக்கையின் முடிவில் அரைப்புள்ளியைத் தவிர்க்க உங்களை அனுமதிக்கிறது அடுத்த அறிவுறுத்தல்உடன் தொடங்கும் புதிய கோடு.

அடுத்த அறிக்கை புதிய வரியில் எழுதப்பட்டால், JavaScript இல் அரைப்புள்ளியுடன் அறிக்கைகளை முடிக்க வேண்டிய அவசியமில்லை, ஆனால் அது மிகவும் பரிந்துரைக்கப்படுகிறது. ஒவ்வொரு அறிவுறுத்தலையும் ஒரு தனி வரியில் வைப்பது நல்லது.

ஜாவாஸ்கிரிப்ட் வழிமுறைகள் பின்வருவனவற்றை உள்ளடக்குகின்றன: மதிப்புகள், ஆபரேட்டர்கள், வெளிப்பாடுகள், முக்கிய வார்த்தைகள் மற்றும் கருத்துகள்.

எடுத்துக்காட்டாக, இந்த அறிவுறுத்தல் உலாவியை "வணக்கம், உலகம்!" என்று எழுதச் சொல்கிறது. உள்ளே HTML உறுப்புஐடி = "முக்கிய" உடன்:

Document.getElementById("main").textContent = "வணக்கம், உலகம்!";

ஜாவாஸ்கிரிப்ட் அர்த்தங்கள்

ஜாவாஸ்கிரிப்ட் தொடரியல் பின்வரும் வகை மதிப்புகளை வரையறுக்கிறது: நிலையான மதிப்புகள் (எழுத்துகள்), நிலையான மதிப்புகள் மற்றும் மாறி மதிப்புகள்.

ஜாவாஸ்கிரிப்டில் வெவ்வேறு மதிப்புகளைப் பிரதிநிதித்துவப்படுத்துவதற்கான சொற்களின் எடுத்துக்காட்டுகள்:

17 // முழு எண் 23.8 // பின்ன எண் "HTML" , மொழி: "ரு" ) // பொருள் இலக்கியம் (ab|bc) // வழக்கமான வெளிப்பாடு இலக்கியம்

நிரலாக்க மொழிகளில், தரவு மதிப்புகளை சேமிக்க மாறிலிகள் மற்றும் மாறிகள் பயன்படுத்தப்படுகின்றன.

மாறிலிகளை அறிவிக்க இது பயன்படுத்தப்படுகிறது முக்கிய வார்த்தை const, மாறிகள் - var மற்றும் let.

கான்ஸ்ட் MAX_LENGTH = 17; // நிலையான var பிரிவு = "HTML"; // மாறி விடு arr = ["HTML","CSS"]; // மாறி

ES-2015 (ES6) பதிப்பிலிருந்து தோன்றிய மாறிகளை அறிவிப்பதற்கான புதிய வழி let. Let ஐப் பயன்படுத்தி அறிவிக்கப்பட்ட ஒரு மாறி வெவ்வேறு ஸ்கோப்பை (பிளாக் ஸ்கோப்) கொண்டிருப்பதில் var இலிருந்து Let வேறுபடுகிறது, மேலும் அது உருவாக்கப்பட்ட பிறகு மட்டுமே அதை அணுக முடியும்.

ஜாவாஸ்கிரிப்ட் ஆபரேட்டர்கள்

ஜாவாஸ்கிரிப்ட்டில் பல்வேறு ஆபரேட்டர்கள் உள்ளன. அவர்கள் செய்ய வேண்டிய செயல்பாட்டைக் குறிப்பிடுகின்றனர்.

ஆபரேட்டர் செயல்படும் இயக்கங்களின் எண்ணிக்கையைப் பொறுத்து, அவை பைனரி மற்றும் யூனரி என பிரிக்கப்படுகின்றன. ஆனால் ஜாவாஸ்கிரிப்ட் ஒரு நிபந்தனை ஆபரேட்டரையும் கொண்டுள்ளது, இதில் 3 ஓபராண்டுகள் உள்ளன. இந்த ஆபரேட்டர் டெர்னரி என்று அழைக்கப்படுகிறது.

எடுத்துக்காட்டாக, அசைன்மென்ட் ஆபரேட்டர் (= அடையாளம்):

// operand1 = operand2; coorX = 100; // உதாரணமாக coordX மாறிக்கு 100 எண்ணை ஒதுக்கவும்

இந்த ஆபரேட்டர், operand1 ஐ operand2 இன் அதே மதிப்பிற்கு ஒதுக்க (அமைக்க) பயன்படுத்தப்படுகிறது.

அசைன்மென்ட் ஆபரேட்டர் பைனரி என்பதால் இது இரண்டு செயல்பாடுகளில் செயல்படுகிறது.

எடுத்துக்காட்டாக, அதிகரிப்பு ஆபரேட்டர் (++ அடையாளம்) அதிகரிக்க பயன்படுத்தப்படுகிறது எண் மதிப்பு 1 மணிக்கு செயல்படும்:

வர் எண் = 5; ++எண்; // 6

அதிகரிப்பு ஆபரேட்டர் ஏனெனில் unary இது ஒரு செயல்பாட்டில் செயல்படுகிறது.

ஜாவாஸ்கிரிப்ட் வெளிப்பாடுகள்

ஒரு வெளிப்பாடு என்பது மதிப்புகள், மாறிகள் மற்றும் ஆபரேட்டர்களின் கலவையாகும், அவை மாறிக்கு மதிப்பை ஒதுக்குகின்றன அல்லது அதை ஒதுக்காமல் மதிப்பை வழங்குகின்றன.

எடுத்துக்காட்டாக, num = 955.47 என்ற வெளிப்பாடு, மதிப்பு 7 ஐ மாறி எண்ணுக்கு ஒதுக்க = operator ஐப் பயன்படுத்துகிறது.

எடுத்துக்காட்டாக, "ஹலோ, " + "Timofey" என்ற வெளிப்பாடு, "Hello, " மற்றும் "Timofey" ஆகிய சரங்களை ஒதுக்காமல் சேர்க்க + ஆபரேட்டரைப் பயன்படுத்துகிறது.

ஜாவாஸ்கிரிப்ட் முக்கிய வார்த்தைகள்

ஜாவாஸ்கிரிப்ட் வழிமுறைகள் பெரும்பாலும் ஒரு முக்கிய சொல்லுடன் தொடங்குகின்றன. இது (திறவுச்சொல்) என்ன ஜாவாஸ்கிரிப்ட் செயலைச் செய்ய வேண்டும் என்பதைத் தீர்மானிக்கும் நோக்கம் கொண்டது.

எடுத்துக்காட்டாக, var முக்கிய சொல் உலாவியை மாறிகளை உருவாக்கச் சொல்கிறது:

Var coordX = 5, coordY = 130;

சில முக்கிய வார்த்தைகளின் பட்டியல்: ப்ரேக், கன்டினி, டூ ... ப்ரேக், ஃபங், ஃபங்ஷன், இஃப் ... வேறு, ரிட்டர்ன், ஸ்விட்ச், டிரை... கேட்ச், வர்.

JavaScript இல் கருத்துகள்

எல்லா ஜாவாஸ்கிரிப்ட் அறிக்கைகளும் இயங்கக்கூடியவை அல்ல.

இரட்டைக் குறைப்புகளுக்குப் பிறகு // அல்லது /* மற்றும் */ இடையே உள்ள குறியீடு கருத்துக்களாகக் கருதப்படுகிறது.

கருத்துகள் புறக்கணிக்கப்பட்டு செயல்படுத்தப்படவில்லை:

Var திசை = "மேல்"; // ஒரு வரி கருத்து // var வேகம் = 10; இந்த அறிவுறுத்தல் செயல்படுத்தப்படாது /* id="myBtn" */ செயல்பாடு showBtn() (document.getElementById("myBtn").classList.add("show"); ) கொண்ட உறுப்புடன் ஷோ வகுப்பைச் சேர்க்கும் செயல்பாடு

// - என்பது ஒரு வரி கருத்து, அதாவது. // மற்றும் வரியின் முடிவில் உள்ள எந்த உரையும் JavaScript ஆல் புறக்கணிக்கப்படும் (செயல்படுத்தப்படாது).

/* */ என்பது பல வரி கருத்து, /* மற்றும் */ இடையே உள்ள எந்த உரையும் JavaScript ஆல் புறக்கணிக்கப்படும்.

ஜாவாஸ்கிரிப்ட் அறிவுறுத்தல் தொகுதி

JavaScript வழிமுறைகளை ஒரு பிளாக் (சுருள் பிரேஸ்கள் (...)) பயன்படுத்தி குழுவாக்கலாம்.

பொதுவாக செயல்பாடுகள், கட்டுப்பாட்டு கட்டமைப்புகள் (அதற்கு, போது) போன்றவற்றில் பயன்படுத்தப்படுகிறது.

செயல்பாடு myFunction() ( document.getElementById("id__1").textContent = "உரை 1..."; document.getElementById("id__2").textContent = "உரை 2..."; )

வழக்கு உணர்திறன்

ஜாவாஸ்கிரிப்ட் ஒரு கேஸ்-சென்சிட்டிவ் மொழி. இதன் பொருள் முக்கிய வார்த்தைகள், மாறிகள், செயல்பாட்டு பெயர்கள் மற்றும் பிற மொழி அடையாளங்காட்டிகள் ஒரே பெரிய மற்றும் சிறிய எழுத்துக்களைக் கொண்டிருக்க வேண்டும். எடுத்துக்காட்டாக, விழிப்பூட்டல் முறை விழிப்பூட்டல் என மட்டுமே தட்டச்சு செய்யப்பட வேண்டும், மேலும் எச்சரிக்கை , எச்சரிக்கை போன்றவை அல்ல.

ஜாவாஸ்கிரிப்டில் வைட்ஸ்பேஸ்

JavaScript பல இடைவெளிகளை புறக்கணிக்கிறது. உங்கள் ஸ்கிரிப்டை மேலும் படிக்கக்கூடியதாக மாற்ற, அதில் இடைவெளிகளைச் சேர்க்கலாம்.

பின்வரும் வரிகள் சமமானவை:

Var str = "உரை"; var str="உரை";

கோட் வரி நீளம்

ஜாவாஸ்கிரிப்ட் அறிவுறுத்தல் நீளமாக இருந்தால், அதை உடைப்பது நல்லது. பெரும்பாலான சந்தர்ப்பங்களில், சில ஆபரேட்டருக்குப் பிறகு ஒரு அறிவுறுத்தலை மீறுவது நல்லது.

உதாரணத்திற்கு:

Document.getElementById("aside__nav_header").innerHTML = "கூடுதல் வழிசெலுத்தல் (பிரிவு மூலம்)";

• ஒரு வார்த்தையைக் கொண்ட பெயர் சிறிய எழுத்துக்களில் எழுதப்பட வேண்டும் (உதாரணமாக: கட்டுரை);
• பல சொற்களைக் கொண்ட ஒரு பெயர் சிறிய எழுத்துக்களில் ஒன்றாக எழுதப்பட வேண்டும், சொற்களின் சந்திப்பில் உள்ள எழுத்துக்களைத் தவிர, அவை பெரிய எழுத்துக்களில் எழுதப்பட வேண்டும் (எடுத்துக்காட்டாக: கட்டுரைத் தலைப்பு);
• பெயரில் உள்ள வார்த்தைகளின் எண்ணிக்கை 3க்கு மிகாமல் இருக்க வேண்டும் (உதாரணமாக: articleDatePublishedon)
• மாறிகள் (செயல்பாடுகளைச் சேமிப்பதற்காக அல்ல) மற்றும் பொருள் பண்புகள் பெயர்ச்சொற்களாக இருக்க வேண்டும் (எடுத்துக்காட்டாக: உரை கருத்து);
• வரிசைகள் மற்றும் மதிப்புகளின் தொகுப்புகள் பெயர்ச்சொற்களால் குறிப்பிடப்பட வேண்டும் பன்மை(எடுத்துக்காட்டாக: lastComments);
• பொருள்களின் செயல்பாடுகள் மற்றும் முறைகள் வினைச்சொற்களுடன் பெயரிடப்பட வேண்டும் (எடுத்துக்காட்டாக: getLastArticles);
• வகுப்புப் பெயர்கள் பெரிய எழுத்தில் தொடங்க வேண்டும் (எடுத்துக்காட்டாக: கருத்துகள்).

ஜாவாஸ்கிரிப்டைப் பயன்படுத்தி செயல்படுத்தலாம் ஜாவாஸ்கிரிப்ட் ஆபரேட்டர்கள், இதில் வைக்கப்பட்டுள்ளன HTML குறிச்சொற்கள்ஸ்கிரிப்ட் ... / ஸ்கிரிப்ட் ஒரு வலைப்பக்கத்தில்.

உங்கள் ஜாவாஸ்கிரிப்ட் உள்ள ஸ்கிரிப்ட் குறிச்சொற்களை உங்கள் வலைப்பக்கத்தில் எங்கு வேண்டுமானாலும் வைக்கலாம், ஆனால் பொதுவாக அதை ஹெட் டேக்குகளில் சேமிக்க பரிந்துரைக்கப்படுகிறது.

இந்த குறிச்சொற்களுக்கு இடையில் உள்ள அனைத்து உரைகளையும் ஸ்கிரிப்டாக விளக்குவதற்கு ஸ்கிரிப்ட் டேக் உலாவி நிரலை எச்சரிக்கிறது. உங்கள் ஜாவாஸ்கிரிப்ட்டின் எளிய தொடரியல் இப்படி இருக்கும்.

ஜாவாஸ்கிரிப்ட் குறியீடு

ஸ்கிரிப்ட் டேக் இரண்டு முக்கியமான பண்புக்கூறுகளைக் கொண்டுள்ளது -

• மொழி - இந்த பண்பு நீங்கள் எந்த ஸ்கிரிப்டிங் மொழியைப் பயன்படுத்துகிறீர்கள் என்பதைக் குறிக்கிறது. பொதுவாக அதன் மதிப்பு ஜாவாஸ்கிரிப்டாக இருக்கும். HTML இன் சமீபத்திய பதிப்புகள் (மற்றும் XHTML, அதன் வாரிசு) இந்தப் பண்புக்கூறைப் பயன்படுத்துவதை நிறுத்திவிட்டாலும்.
• வகை. இப்போது பயன்படுத்தப்படும் ஸ்கிரிப்டிங் மொழியைக் குறிக்க இந்தப் பண்புக்கூறு பரிந்துரைக்கப்படுகிறது மற்றும் அதன் மதிப்பு "உரை/ஜாவாஸ்கிரிப்ட்" என அமைக்கப்பட வேண்டும்.

எனவே உங்கள் ஜாவாஸ்கிரிப்ட் பிரிவு இப்படி இருக்கும்:

ஜாவாஸ்கிரிப்ட் குறியீடு

உங்களின் முதல் ஜாவாஸ்கிரிப்ட் ஸ்கிரிப்ட்

"ஹலோ வேர்ல்ட்" பிரிண்ட் அவுட்டின் உதாரணத்தை எடுத்துக் கொள்வோம். சேர்த்தோம் கூடுதல் கருத்துஎங்கள் ஜாவாஸ்கிரிப்ட் குறியீட்டைச் சுற்றியுள்ள HTML. இது JavaScript ஐ ஆதரிக்காத உலாவியில் இருந்து எங்கள் குறியீட்டைச் சேமிப்பதாகும். கருத்து "// ->" என்று முடிவடைகிறது. இங்கே "//" என்பது ஜாவாஸ்கிரிப்டில் உள்ள கருத்தைக் குறிக்கிறது, எனவே ஜாவாஸ்கிரிப்ட் குறியீட்டின் ஒரு பகுதியாக உலாவி HTML கருத்தைப் படிப்பதைத் தடுக்க இதைச் சேர்க்கிறோம். நாம் ஆவணம்.write செயல்பாட்டை அழைக்கிறோம், இது எங்கள் HTML ஆவணத்திற்கு ஒரு சரத்தை எழுதுகிறது.

இந்தச் செயல்பாட்டை உரை, HTML அல்லது இரண்டையும் எழுதப் பயன்படுத்தலாம். பின்வரும் குறியீட்டைப் பாருங்கள்.

இந்த குறியீடு பின்வரும் முடிவைக் கொடுக்கும்:

வணக்கம் உலகம்!

இடைவெளிகள் மற்றும் வரி முறிவுகள்

JavaScript நிரல்களில் தோன்றும் இடைவெளிகள், தாவல்கள் மற்றும் புதிய வரிகளை JavaScript புறக்கணிக்கிறது. உங்கள் திட்டத்தில் இடைவெளிகள், தாவல்கள் மற்றும் புதிய வரிகளை நீங்கள் தாராளமாகப் பயன்படுத்தலாம், மேலும் உங்கள் நிரல்களை நேர்த்தியாகவும் சீரானதாகவும் வடிவமைத்து உள்தள்ளலாம், உங்கள் குறியீட்டைப் படிக்கவும் புரிந்துகொள்ளவும் எளிதாக்குகிறது.

ஜாவாஸ்கிரிப்டில் அரைப்புள்ளிகள்

IN எளிய வழிமுறைகள்ஜாவாஸ்கிரிப்டில் இது வழக்கமாக சி, சி++ மற்றும் ஜாவாவைப் போல அரைப்புள்ளியால் பின்பற்றப்படும். இருப்பினும், ஜாவாஸ்கிரிப்ட், உங்கள் ஒவ்வொரு அறிக்கையையும் தனித்தனி வரியில் வைத்தால், இந்த அரைப்புள்ளியைத் தவிர்க்க உங்களை அனுமதிக்கிறது. எடுத்துக்காட்டாக, பின்வரும் குறியீட்டை அரைப்புள்ளிகள் இல்லாமல் எழுதலாம்.

ஆனால் இப்படி ஒரு வரியில் வடிவமைக்கும்போது, ​​அரைப்புள்ளிகளைப் பயன்படுத்த வேண்டும் -

குறிப்பு. நல்ல பயிற்சிநிரலாக்கமானது அரைப்புள்ளிகளைப் பயன்படுத்துவதாகும்.

வழக்கு உணர்திறன்

ஜாவாஸ்கிரிப்ட் ஒரு கேஸ்-சென்சிட்டிவ் மொழி. இதன் பொருள் முக்கிய வார்த்தைகள், மாறிகள், செயல்பாட்டு பெயர்கள் மற்றும் பிற அடையாளங்காட்டிகள் எப்போதும் நிலையான பெரிய எழுத்துடன் உள்ளிடப்பட வேண்டும்.

எனவே நேரம் மற்றும் TIME அடையாளங்காட்டிகள் JavaScriptக்கு வெவ்வேறு அர்த்தங்களைத் தெரிவிக்கும்.

குறிப்பு. ஜாவாஸ்கிரிப்ட்டில் மாறி மற்றும் செயல்பாட்டு பெயர்களை எழுதும்போது கவனமாக இருக்க வேண்டும்.

எழுதக் கற்றுக் கொள்ளும்போது, ​​ஒரு நபர் எழுத்துப்பிழை, இலக்கணம் மற்றும் எழுத்துப்பிழை ஆகியவற்றின் அடிப்படைகளைக் கற்றுக்கொள்ள வேண்டும். உதாரணமாக, ஒரு வாக்கியம் தொடங்குகிறது என்பது அனைவருக்கும் தெரியும் பெரிய எழுத்துமற்றும் ஒரு காலகட்டத்துடன் முடிவடைகிறது, உரை பத்திகளாக பிரிக்கப்பட்டுள்ளது, முதலியன.

நிரலாக்க மொழிகள் இதே வழியில் செயல்படுகின்றன: ஒரு நிரல் வேலை செய்ய, சில விதிகள் பின்பற்றப்பட வேண்டும். நிரலாக்க மொழிகளின் கட்டமைப்பை வரையறுக்கும் விதிகளின் தொகுப்பு தொடரியல் என்று அழைக்கப்படுகிறது. பல நிரலாக்க மொழிகள் ஒரே கருத்துகளில் கட்டமைக்கப்பட்டுள்ளன, ஆனால் வெவ்வேறு தொடரியல் பயன்படுத்துகின்றன.

இந்த டுடோரியல் ஜாவாஸ்கிரிப்டில் தொடரியல் மற்றும் குறியீடு கட்டமைப்பின் அடிப்படைகளை உங்களுக்கு அறிமுகப்படுத்தும்.

செயல்பாடு மற்றும் வாசிப்புத்திறன்

செயல்பாடு மற்றும் வாசிப்புத்திறன் ஆகியவை ஜாவாஸ்கிரிப்ட் தொடரியல் மிகவும் முக்கியமான அம்சங்களாகும், அவை தனித்தனியாக கவனம் செலுத்த வேண்டும்.

ஜாவாஸ்கிரிப்ட் குறியீட்டிற்கு சில தொடரியல் விதிகள் கட்டாயமாகும். அவர்கள் சந்திக்கவில்லை என்றால், கன்சோல் ஒரு பிழையை ஏற்படுத்தும் மற்றும் ஸ்கிரிப்ட் இயங்குவதை நிறுத்தும்.

"ஹலோ, வேர்ல்ட்!" திட்டத்தில் இந்த பிழையைக் கவனியுங்கள்.

// உடைந்த ஜாவாஸ்கிரிப்ட் நிரலின் எடுத்துக்காட்டு
console.log("வணக்கம், உலகம்!"

இறுதியில், "ஹலோ, வேர்ல்ட்!" என்ற வரிக்கு பதிலாக ஒரு மூடும் அடைப்புக்குறி உள்ளது. நிரல் பிழையை வழங்கும்:

வாதப் பட்டியலுக்குப் பிறகு பிடிக்கப்படாத தொடரியல் பிழை: காணவில்லை).

ஸ்கிரிப்ட் தொடர்ந்து இயங்க அனுமதிக்க, நீங்கள் மூடும் அடைப்புக்குறியைச் சேர்க்க வேண்டும். ஜாவாஸ்கிரிப்ட் தொடரியல் பிழையானது நிரலின் செயல்பாட்டைப் பாதிக்கும்.

ஜாவாஸ்கிரிப்ட் தொடரியல் மற்றும் வடிவமைப்பின் சில அம்சங்கள் வெவ்வேறு கண்ணோட்டங்களில் இருந்து வருகின்றன. எளிமையாகச் சொன்னால், ஸ்டைலிஸ்டிக் விதிகள் மற்றும் மாறுபாடுகள் விருப்பமானவை மற்றும் குறியீட்டை இயக்கும்போது பிழைகளை ஏற்படுத்தாது. இருப்பினும், பல பொதுவான மரபுகள் உள்ளன, அவை புராஜெக்ட் மற்றும் கோட் டெவலப்பர்கள் நடை மற்றும் தொடரியல் புதுப்பிப்புகளை அறிந்திருக்க வேண்டும். பொதுவான மரபுகளைப் பின்பற்றுவது உங்கள் குறியீட்டின் வாசிப்புத் திறனை மேம்படுத்தும்.

ஒரு மாறிக்கு மதிப்பை ஒதுக்க பின்வரும் மூன்று விருப்பங்களைக் கவனியுங்கள்:

const வாழ்த்து="வணக்கம்"; // மாறி மற்றும் சரத்திற்கு இடையில் இடைவெளி இல்லை
const வாழ்த்து = "வணக்கம்"; //ஒதுக்கீட்டிற்குப் பிறகு அதிகப்படியான இடைவெளி
const வாழ்த்து = "வணக்கம்"; // மாறி மற்றும் சரம் இடையே ஒற்றை இடைவெளி

மேலே உள்ள மூன்று வரிகளும் ஒரே மாதிரியாக வேலை செய்யும். ஆனால் மூன்றாவது விருப்பம் (வாழ்த்து = "ஹலோ") குறியீட்டை எழுதுவதற்கு மிகவும் பொதுவாகப் பயன்படுத்தப்படும் மற்றும் படிக்கக்கூடிய வழியாகும், குறிப்பாக ஒரு பெரிய நிரலின் சூழலில் பார்க்கும்போது.

அனைத்து நிரல் குறியீட்டின் ஒருமைப்பாடு மற்றும் நிலைத்தன்மையை கண்காணிப்பது மிகவும் முக்கியம்.

ஜாவாஸ்கிரிப்ட் குறியீட்டின் தொடரியல் மற்றும் கட்டமைப்பைப் பற்றி அறிந்துகொள்ள சில எடுத்துக்காட்டுகளை கீழே பார்ப்போம்.

வெண்வெளி எழுத்துக்கள்

ஜாவாஸ்கிரிப்ட் வைட்ஸ்பேஸ் எழுத்துக்கள் இடைவெளிகள், தாவல்கள் மற்றும் வரி ஊட்டங்கள் (இந்தச் செயல் Enter விசையால் செய்யப்படுகிறது). முன்பு காட்டப்பட்டபடி, ஒரு கோட்டிற்கு வெளியே அதிகப்படியான வெள்ளை இடைவெளி, ஆபரேட்டர்களுக்கு இடையே உள்ள வெள்ளை இடைவெளி மற்றும் பிற எழுத்துக்கள் ஜாவாஸ்கிரிப்ட் மொழிபெயர்ப்பாளரால் புறக்கணிக்கப்படுகின்றன. இதன் பொருள் பின்வரும் மூன்று மாறி ஒதுக்கீட்டு எடுத்துக்காட்டுகள் ஒரே முடிவைக் கொண்டிருக்கும்:

const userLocation = "நியூயார்க் நகரம், " + "NY";
const userLocation="நியூயார்க் நகரம், "+"NY";
const userLocation = "நியூயார்க் நகரம், " + "NY";

அந்த மதிப்பிற்கான அசைன்மென்ட் பாணியைப் பொருட்படுத்தாமல், "நியூயார்க் சிட்டி, என்ஒய்" என்ற மதிப்பை பயனர் இருப்பிட மாறி கொண்டிருக்கும். ஜாவாஸ்கிரிப்டைப் பொறுத்தவரை இது ஒரு பொருட்டல்ல இடைவெளி எழுத்துக்கள்பயன்படுத்தப்படுகின்றன.

நிரல்களை எழுதுவதில் முயற்சித்த மற்றும் உண்மையான விதி ஒன்று உள்ளது: நீங்கள் இடைவெளியைப் பயன்படுத்தும் போது, ​​கணிதம் அல்லது இலக்கணத்தில் நீங்கள் பயன்படுத்தும் அதே விதிகளைப் பின்பற்றவும். உதாரணமாக, வரி:

இதை விட படிக்க எளிதானது:

இந்த விதிக்கு ஒரு முக்கியமான விதிவிலக்கு பல மாறிகளின் ஒதுக்கீடு ஆகும். பின்வரும் எடுத்துக்காட்டில் = நிலையைக் கவனியுங்கள்:

const companyName = "MyCompany";
const companyHeadquarters = "நியூயார்க் நகரம்";
const companyHandle = "mycompany";

அனைத்து அசைன்மென்ட் ஆபரேட்டர்களும் (=) இடைவெளிகளைப் பயன்படுத்தி ஒற்றை வரியில் சீரமைக்கப்படுகின்றனர். இந்த வகை கட்டமைப்பு அனைத்து குறியீடு அடிப்படைகளாலும் பயன்படுத்தப்படுவதில்லை, ஆனால் வாசிப்புத்திறனை மேம்படுத்தலாம்.

ஜாவாஸ்கிரிப்டில் கூடுதல் வரி முறிவுகளும் புறக்கணிக்கப்படுகின்றன. ஒரு விதியாக, கூடுதல் வெற்று கோடுகள்கருத்துக்கு மேலேயும் குறியீடு தொகுதிக்குப் பிறகும் செருகப்படுகின்றன.

வட்ட அடைப்புக்குறிகள்

என்றால், மாறுதல் மற்றும் அடைப்புக்குறிக்கு முன்னும் பின்னும் போன்ற முக்கிய வார்த்தைகள் பொதுவாக இடைவெளிகளைக் கொண்டிருக்கும். பின்வரும் உதாரணத்தைக் கவனியுங்கள்:

// if ஸ்டேட்மெண்ட் தொடரியல் உதாரணம்
என்றால் () ( )
// கணித சமன்பாட்டை சரிபார்த்து, கன்சோலில் ஒரு சரத்தை அச்சிடவும்
என்றால் (4< 5) {
console.log("4 என்பது 5 ஐ விட குறைவாக உள்ளது.");
}
// லூப் தொடரியல் ஒரு உதாரணம்
க்கான () ( )
// 10 முறை மீண்டும் செய்யவும், ஒவ்வொரு மறு செய்கை எண்ணையும் கன்சோலில் அச்சிடவும்
க்கு (நான் = 0; i 0) (
சதுரம்(எண்);
}

கவனமாக இருங்கள் ஏனெனில் சுருள் பிரேஸ்களில் இணைக்கப்பட்ட அனைத்து குறியீடுகளுக்கும் அரைப்புள்ளி தேவையில்லை. பொருள்கள் சுருள் பிரேஸ்களில் இணைக்கப்பட்டுள்ளன மற்றும் அரைப்புள்ளியுடன் முடிவடைய வேண்டும்.

// ஒரு எடுத்துக்காட்டு பொருள்
const objectName = ();
// முக்கோணப் பொருளை துவக்கவும்
நிலை முக்கோணம் = (
வகை: "வலது",
கோணம்: 90,
பக்கங்கள்: 3,
};

சுருள் பிரேஸ்களுடன் முடிவடைவதைத் தவிர ஒவ்வொரு ஜாவாஸ்கிரிப்ட் அறிக்கை மற்றும் வெளிப்பாடுகளுக்குப் பிறகு அரைப்புள்ளிகளை வைப்பது பொதுவான நடைமுறையாகும்.

குறியீடு கட்டமைப்பு

தொழில்நுட்ப ரீதியாக, ஜாவாஸ்கிரிப்ட் நிரலில் உள்ள அனைத்து குறியீடுகளையும் ஒரே வரியில் வைக்கலாம். ஆனால் அத்தகைய குறியீடு படித்து பராமரிப்பது மிகவும் கடினம். எனவே நிரல் வரிகளாக பிரிக்கப்பட்டுள்ளது.

எடுத்துக்காட்டாக, if/else அறிக்கையை ஒரு வரியில் எழுதலாம் அல்லது பிரிக்கலாம்:

// ஒரு வரியில் எழுதப்பட்ட நிபந்தனை அறிக்கை
என்றால் (x === 1) ( /* உண்மை என்றால் குறியீட்டை இயக்கவும் */ ) இல்லையெனில் ( /* தவறாக இருந்தால் குறியீட்டை இயக்கவும் */ )
// உள்தள்ளலுடன் நிபந்தனை அறிக்கை
என்றால் (x === 1) (
// உண்மை என்றால் குறியீட்டை இயக்கவும்
) வேறு (
// தவறாக இருந்தால் குறியீட்டை இயக்கவும்
}

தயவுசெய்து கவனிக்கவும்: ஒரு தொகுதியில் சேர்க்கப்பட்டுள்ள எந்த குறியீடும் உள்தள்ளப்பட்டுள்ளது. நீங்கள் இரண்டு இடைவெளிகள், நான்கு இடைவெளிகள் அல்லது தாவல்களைப் பயன்படுத்தி உள்தள்ளலாம். உள்தள்ளல் முறையின் தேர்வு தனிப்பட்ட விருப்பம் அல்லது உங்கள் நிறுவனத்தின் பரிந்துரைகளை மட்டுமே சார்ந்துள்ளது.

முதல் வரியின் முடிவில் திறந்த அடைப்புக்குறி என்பது ஜாவாஸ்கிரிப்ட் அறிக்கைகள் மற்றும் பொருள்களை கட்டமைப்பதற்கான பொதுவான வழியாகும். சில நேரங்களில் அடைப்புக்குறிகள் தனி வரிகளில் வைக்கப்படுகின்றன:

// புதிய வரிகளில் பிரேஸ்கள் கொண்ட நிபந்தனை அறிக்கை
என்றால் (x === 1)
{
// உண்மை என்றால் குறியீட்டை இயக்கவும்
}
வேறு
{
// தவறாக இருந்தால் குறியீட்டை இயக்கவும்
}

இந்த அமைப்பு மற்ற மொழிகளைப் போலவே ஜாவாஸ்கிரிப்ட்டில் அரிதாகவே பயன்படுத்தப்படுகிறது.

உள்ளமைக்கப்பட்ட அறிக்கைகள் பிரிக்கப்பட வேண்டும்:

// ஒரு செயல்பாட்டை துவக்கவும்
செயல்பாடு isEqualToOne(x) (
// x என்பது ஒன்றுக்கு சமமா என்று பார்க்கவும்
என்றால் (x === 1) (
//வெற்றி, உண்மை என்று திரும்பவும்
உண்மை திரும்ப;
) வேறு (
தவறான திரும்ப;
}
}

சரியான உள்தள்ளல் குறியீட்டைப் படிக்கக்கூடியதாக ஆக்குகிறது. இந்த விதிக்கு ஒரே விதிவிலக்கு என்னவென்றால், சுருக்கப்பட்ட நூலகங்கள் கோப்பு அளவைக் குறைக்க அனைத்து தேவையற்ற சின்னங்களையும் நீக்குகின்றன.

அடையாளங்காட்டிகள்

ஜாவாஸ்கிரிப்டில் உள்ள மாறிகள், செயல்பாடுகள் அல்லது பண்புகளின் பெயர்கள் அடையாளங்காட்டிகள் என்று அழைக்கப்படுகின்றன. அடையாளங்காட்டிகள் எழுத்துக்கள் மற்றும் எண்களைக் கொண்டிருக்கும், ஆனால் அவை $ மற்றும் _ க்கு அப்பால் எழுத்துக்களைக் கொண்டிருக்க முடியாது மற்றும் எண்ணுடன் தொடங்க முடியாது.

வழக்கு உணர்திறன்

பெயர்கள் கேஸ் சென்சிடிவ். அதாவது, myVariable மற்றும் myvariable இரண்டு வெவ்வேறு மாறிகளாகக் கருதப்படும்.

var myVariable = 1;
var myvariable = 2;

பொது மரபுப்படி, பெயர்கள் ஒட்டகத்தில் எழுதப்படுகின்றன: முதல் வார்த்தை ஒரு சிறிய எழுத்துடன் எழுதப்பட்டுள்ளது, ஆனால் ஒவ்வொரு அடுத்த வார்த்தையும் ஒரு பெரிய எழுத்துடன் தொடங்குகிறது. உலகளாவிய மாறிகள் அல்லது மாறிலிகள் பெரிய எழுத்தில் எழுதப்பட்டு அடிக்கோடிட்டுப் பிரிக்கப்படுகின்றன.

கான்ஸ்ட் INSURANCE_RATE = 0.4;

இந்த விதிக்கு விதிவிலக்கு வர்க்கப் பெயர்கள் ஆகும், அங்கு ஒவ்வொரு வார்த்தையும் பொதுவாக ஒரு பெரிய எழுத்துடன் (PascalCase) தொடங்கும்.

// ஒரு வகுப்பை துவக்கவும்
வகுப்பு எடுத்துக்காட்டு வகுப்பு (
கட்டமைப்பாளர் ()
}

குறியீட்டைப் படிக்கக்கூடிய தன்மையை உறுதிப்படுத்த, எல்லா நிரல் கோப்புகளிலும் அடையாளங்காட்டிகளை நீங்கள் தொடர்ந்து பயன்படுத்த வேண்டும்.

ஒதுக்கப்பட்ட முக்கிய வார்த்தைகள்

அடையாளங்காட்டிகளில் ஒதுக்கப்பட்ட முக்கிய வார்த்தைகள் எதுவும் இருக்கக்கூடாது. முக்கிய வார்த்தைகள் உள்ளமைக்கப்பட்ட செயல்பாட்டைக் கொண்ட ஜாவாஸ்கிரிப்ட் சொற்கள். இவற்றில் var, if, for and this ஆகியவை அடங்கும்.

எடுத்துக்காட்டாக, var என்ற மாறிக்கு மதிப்பை ஒதுக்க முடியாது.

var var = "சில மதிப்பு";

ஜாவாஸ்கிரிப்ட் var முக்கிய சொல்லை அறிந்திருக்கிறது, எனவே அது பிழையை ஏற்படுத்தும்:

தொடரியல் பிழை: எதிர்பாராத டோக்கன் (1:4)