ஜாவாஸ்கிரிப்ட். தரவு வகைகள் மற்றும் ஆபரேட்டர்கள். ஜாவாஸ்கிரிப்ட் தரவு வகைகள் மாறி வகையை அமைக்கின்றன
ஒரு மாறி என்பது பெயரிடப்பட்ட நினைவக இருப்பிடம், இதில் நீங்கள் இருவரும் சில தகவல்களைச் சேமித்து அதிலிருந்து மீட்டெடுக்கலாம்.
மாறிகளை அறிவிப்பது (உருவாக்குவது) var முக்கிய சொல்லைப் பயன்படுத்தி செய்யப்படுகிறது.
// செய்தி - மாறி பெயர் var செய்தி;
நீங்கள் ஒரு மாறியை உருவாக்கினால், அதற்கு உடனடியாக மதிப்பை ஒதுக்கலாம்.
ஒரு மாறிக்கு மதிப்பை ஒதுக்குவது “=” ஆபரேட்டரைப் பயன்படுத்தி செய்யப்படுகிறது.
// எடுத்துக்காட்டாக, ஒரு மாறி மின்னஞ்சலை உருவாக்கி அதற்கு சரத்தை ஒதுக்கவும் " [மின்னஞ்சல் பாதுகாக்கப்பட்டது]"var மின்னஞ்சல் =" [மின்னஞ்சல் பாதுகாக்கப்பட்டது]"; // மின்னஞ்சல் மாறியை ஒரு புதிய மதிப்பு மின்னஞ்சலுக்கு அமைக்கவும் = " [மின்னஞ்சல் பாதுகாக்கப்பட்டது]";
ஒரு மாறியின் மதிப்பைப் பெற, அதை பெயரால் குறிப்பிடவும்.
// எடுத்துக்காட்டாக, உலாவி கன்சோலுக்கு மின்னஞ்சல் மாறியின் மதிப்பை வெளியிடவும்: console.log(email);
ஒரு var முக்கிய சொல்லைப் பயன்படுத்தி ஒன்றுக்கு மேற்பட்ட மாறிகளை அறிவிக்க, நீங்கள் கமாவைப் பயன்படுத்த வேண்டும்.
Var விலை = 78.55, அளவு = 10, செய்தி;
ஜாவாஸ்கிரிப்ட் என்பது மாறும் அல்லது பலவீனமாக தட்டச்சு செய்யப்பட்ட மொழி. இதன் பொருள் ஒரு மாறி அறிவிக்கப்படும் போது, அது ஏற்றுக்கொள்ளக்கூடிய தரவு வகையைக் குறிப்பிடத் தேவையில்லை. எனவே, நீங்கள் முதலில் ஒரு தரவு வகையின் மதிப்பை ஒரு மாறியில் வைக்கலாம், பின்னர் மற்றொன்று.
Var வெளியீடு = "வெற்றி"; // மாறி ஒரு சரம் தரவு வகை வெளியீடு = 28; // அதே மாறி, ஆனால் ஏற்கனவே "எண்" தரவு வகை வெளியீடு = உண்மை; // அதே மாறி, ஆனால் ஏற்கனவே பூலியன் மதிப்பைச் சேமித்து வருகிறது
ஒரு மாறியின் மதிப்பை வரம்பற்ற முறை மாற்றலாம்.
// வயது மாறி var வயதில் உருவாக்கப்பட்டது; // மாறி வயது மதிப்பு 67 வயது = 67 ஒதுக்கப்படுகிறது; // மாறி வயது "ஓய்வு வயது" வயது = "ஓய்வு வயது" என அமைக்கப்பட்டுள்ளது; // மாறி வயது 55 வயது = 55 என அமைக்கப்பட்டுள்ளது;
கிளையன்ட் அப்ளிகேஷன்களை உருவாக்கும் போது ஒரு நல்ல நடைமுறை, கொடுக்கப்பட்ட மாறியில் ஒரே ஒரு தரவு வகையை மட்டுமே பயன்படுத்த வேண்டும், அதாவது. வெவ்வேறு தரவு வகைகளின் மதிப்புகளை மாறிக்கு எழுத வேண்டாம். ஒரு மாறியில் எந்த வகையான தரவு எதிர்பார்க்கப்பட வேண்டும் என்பதைப் புரிந்து கொள்ள, ஒரு மாறியை உருவாக்கும் போது, உடனடியாக அதை ஒரு குறிப்பிட்ட மதிப்புடன் துவக்க பரிந்துரைக்கப்படுகிறது.
மாறி பெயர் எழுத்துக்கள், எண்கள் மற்றும் $ மற்றும் _ குறியீடுகளால் ஆனது. இந்த வழக்கில், மாறியின் முதல் எழுத்து ஒரு எண்ணாக இருக்கக்கூடாது. கூடுதலாக, நீங்கள் ஒதுக்கப்பட்ட சொற்களை மாறி பெயர்களாகப் பயன்படுத்த முடியாது.
// இரண்டு மாறிகளை உருவாக்குகிறது, முதல் மாறிக்கு தொலைபேசி என்று பெயரிடப்பட்டது, இரண்டாவது மெசேஜ்; var தொலைபேசி, செய்தி;
மாறி பெயரில் உள்ள எழுத்துக்களின் வழக்கு முக்கியமானது. அதாவது, எடுத்துக்காட்டாக, மாறி தொலைபேசி மற்றும் தொலைபேசி இரண்டு வெவ்வேறு மாறிகள்.
கண்டிப்பான பயன்முறை பயன்படுத்தப்படாவிட்டால், நீங்கள் var முக்கிய வார்த்தை இல்லாமல் ஆரம்ப மதிப்புடன் ஒரு மாறியை உருவாக்கலாம்.
விலை = 250.00; // ஒரு மாறியை உருவாக்கி அதை 250.00 சதவீதம் = "20%" என்ற எண்ணுடன் துவக்கியது; // ஒரு மாறியை உருவாக்கி அதை “20%” என்ற சரத்துடன் துவக்கியது
ஆனால் இந்த வழியில் மாறிகளை உருவாக்குவது பரிந்துரைக்கப்படவில்லை.
தரவு வகைகள்ஜாவாஸ்கிரிப்ட்டில், தரவு வகைகளை பழமையான மற்றும் பொருள் என பிரிக்கலாம்.
பழமையான தரவு வகைகளைக் கொண்ட மாறிகள் அவற்றின் மதிப்பை வெளிப்படையாகச் சேமிக்கின்றன.
ஜாவாஸ்கிரிப்ட்டில் 5 பழமையான தரவு வகைகள் உள்ளன:
- எண்;
- லேசான கயிறு;
- பூலியன் வகை (பூலியன்);
- ஏதுமில்லை;
- வரையறுக்கப்படாத.
ஒரு மாறிக்கு மற்றொன்றின் மதிப்பு ஒதுக்கப்பட்டால், அது ஒரு பழமையான தரவு வகையைக் கொண்டிருக்கும், அது அந்த மதிப்பின் சொந்த நகலைப் பெறும்.
Var x = 77, y = x; x = 55; ஒய்; //77
ஒரு பொருளைக் கொண்ட மாறிகள் உண்மையில் பொருளையே சேமித்து வைப்பதில்லை, ஆனால் அதைக் குறிக்கும்.
ஒரு மாறிக்கு மற்றொரு பொருளின் மதிப்பு ஒதுக்கப்பட்டால் (அதற்கான இணைப்பு), அது அதற்கான இணைப்பையும் பெறும். இந்த செயல்பாட்டின் விளைவாக, இந்த இரண்டு மாறிகள் ஒரே பொருளின் குறிப்பைக் கொண்டிருக்கும்.
// உதாரணம் 1 (தரவு வகை "பொருள்" உடன்) var coord1 = (x: 77, y: 100), coord2 = coord1; coord1.x = 55; // பொருளின் x சொத்தை புதிய மதிப்பு coord2.xக்கு அமைக்கவும்; // 55, ஏனெனில் coord1 மற்றும் coord2 ஆகியவை ஒரே பொருளின் குறிப்பைக் கொண்டிருக்கின்றன // உதாரணம் 2 (வரிசை தரவு வகையுடன்) var coord1 = , coord2 = coord1; coord1 = 55; // குறியீட்டு 0 உடன் உறுப்பை ஒரு புதிய மதிப்பு coord2 க்கு அமைக்கவும்; // 55, ஏனெனில் coord1 மற்றும் coord2 ஆகியவை ஒரே பொருளின் குறிப்பைக் கொண்டுள்ளன // உதாரணம் 3 (தரவு வகை "தேதி" உடன்) var date1 = புதிய தேதி(2018,00,01), date2 = date1; date2 = date2.setDate(date2.getDate()+7); // தேதியை 7 நாட்கள் அதிகரிக்கவும் தேதி1; // 01/07/2018, ஏனெனில் தேதி1 மற்றும் தேதி2 ஆகியவை ஒரே பொருளின் குறிப்பைக் கொண்டுள்ளன
எண்ஜாவாஸ்கிரிப்டில் உள்ள எண் தரவு வகை பொதுவானது. இது முழு எண்கள் மற்றும் பின்னங்கள் இரண்டையும் குறிக்கப் பயன்படுகிறது.
Var int = 5; // முழு எண் var மிதவை = 5.98; // ஒரு பகுதி எண்
ஜாவாஸ்கிரிப்டில் எண்களைக் குறிக்கும் வடிவம் IEEE 754-2008 தரநிலையின்படி உள்ளது.
ஜாவாஸ்கிரிப்டில் உள்ள முழு எண்களை மட்டும் குறிப்பிட முடியாது தசம அமைப்புஎண் அமைப்பு, ஆனால் அடைப்புக்குறிக்குள் குறிப்பிடப்பட்டுள்ள முன்னொட்டுகளைப் பயன்படுத்தி ஆக்டல் (0) அல்லது ஹெக்ஸாடெசிமல் எண் அமைப்பு (0x) இல்:
Var int = 010; // 8 int = 055; // 45 int = 0xFF; //255 int = 0xB8; // 184
அதிவேக வடிவத்தில் எண்களை எழுதுவது சாத்தியம்:
வர் எண் = 2e3; // 2*10^3 (2000) எண் = 2e-3 என்ற எண்ணின் அதிவேகக் குறியீடு; // 2*10^-3 (0.002) எண் = 3.2e3 இன் அதிவேகக் குறியீடு; // 3200 எண் = 1.5e-2; // 0.015
எண்களுக்கு கூடுதலாக, எண் தரவு வகை சிறப்பு எண் மதிப்புகளையும் கொண்டுள்ளது:
- முடிவிலி (நேர்மறை முடிவிலி);
- -முடிவிலி (எதிர்மறை முடிவிலி);
- NaN (ஒரு எண் அல்ல).
சிறப்பு மதிப்பு முடிவிலி என்பது மிகப் பெரிய நேர்மறை எண்ணைக் குறிக்கிறது, அதாவது. ஜாவாஸ்கிரிப்ட்டில் குறிப்பிட முடியாத எண், ஏனெனில் அது மிகப் பெரியது.
சிறப்பு அர்த்தங்கள் -முடிவிலி என்பது, மாறாக, மிகப் பெரிய எதிர்மறை எண், அதாவது. ஜாவாஸ்கிரிப்ட் மூலம் பிரதிநிதித்துவப்படுத்த முடியாத எண், ஏனெனில் அது மிகப் பெரியது.
அவற்றின் கணக்கீட்டின் விளைவாக சிறப்பு எண் மதிப்புகளை வழங்கும் வெளிப்பாடுகளின் எடுத்துக்காட்டு:
5/0; // முடிவிலி -5/0; // -Infinity Math.pow(10,399); // முடிவிலி (10 முதல் 399 வரை) Math.pow(10,399); // -முடிவிலி (-10 to the power of 399)
ஜாவாஸ்கிரிப்ட் கணக்கிட முடியாத கணித செயல்பாடுகளைச் செய்வதன் விளைவாக NaN மதிப்பு திரும்பப் பெறப்படுகிறது.
5 - "ஹாய்"; // NaN (எண் 5 இலிருந்து ஒரு வரியைக் கழிக்கவும்) 1000 / "20px"; // NaN (எண் சரத்தால் வகுக்கப்பட்டது) உண்மை * "1rem"; // NaN (பூலியன் மதிப்பு உண்மை சரத்தால் பெருக்கப்படுகிறது)
மிகவும் சுவாரஸ்யமான விஷயம் என்னவென்றால், ஜாவாஸ்கிரிப்டில் உள்ள NaN இன் மதிப்பு அது உட்பட எதற்கும் சமமாக இல்லை.
NaN == NaN; // தவறான NaN === NaN; //பொய்
பூலியன் தரவு வகைபூலியன் என்பது ஒரு பழமையான தரவு வகை, இதில் இரண்டு மதிப்புகள் மட்டுமே உள்ளன: உண்மை மற்றும் தவறு.
வர் அ = உண்மை; var b = தவறான;
லேசான கயிறுசரம் என்பது ஜாவாஸ்கிரிப்ட்டில் உரையைக் குறிக்கப் பயன்படுத்தப்படும் தரவு வகை.
ஜாவாஸ்கிரிப்ட் சரம் 0 அல்லது மேலும்பாத்திரங்கள்.
ஜாவாஸ்கிரிப்ட் எப்போதும் யூனிகோடை அதன் சர வடிவமாகப் பயன்படுத்துகிறது.
ஒரு சரத்தை உருவாக்குவது (சரம் எழுத்து) ஒற்றை அல்லது உரையை இணைப்பதன் மூலம் செய்யப்படுகிறது இரட்டை மேற்கோள்கள்.
"ஜாவாஸ்கிரிப்ட்"; "ECMAScript";
ஜாவாஸ்கிரிப்டில், ஒற்றை மற்றும் இரட்டை மேற்கோள்களுக்கு இடையில் எந்த வித்தியாசமும் இல்லை.
ஆனால், சில சந்தர்ப்பங்களில், இரட்டை மேற்கோள்களை விட ஒற்றை மேற்கோள்களைப் பயன்படுத்துவது அர்த்தமுள்ளதாக இருக்கிறது.
எடுத்துக்காட்டாக, ஒரு சரத்தில் இரட்டை மேற்கோள்கள் இருந்தால், அதை ஒற்றை மேற்கோள்களில் இணைப்பது மிகவும் வசதியானது. இது இரட்டை மேற்கோள்களில் இருந்து தப்பிக்கும் தேவையை நீக்கும்.
""ECMAScript""; // தப்பிக்காமல் (ஒற்றை மேற்கோள்களைப் பயன்படுத்தி) "\"ECMAScript\""; // தப்பியோடும்
ஜாவாஸ்கிரிப்டில் உள்ள ஒரு சரத்தில் சிறப்பு எழுத்துகள் இருக்கலாம். எடுத்துக்காட்டாக, \n (வரி ஊட்டம்), \t (தாவல்), \r (வண்டி திரும்புதல்) போன்றவை.
"இது ஒரு வாக்கியம்.\nஇதுவும் ஒரு வாக்கியம், ஆனால் இது ஒரு புதிய வரியிலிருந்து தொடங்கும்.";
சரங்கள் மூலம் நீங்கள் கூட்டல் (ஒன்றியம்) அல்லது, வேறுவிதமாகக் கூறினால், இணைப்பின் செயல்பாட்டைச் செய்யலாம். இதற்கு "+" ஆபரேட்டர் பயன்படுத்தப்படுகிறது. இந்த செயல்பாட்டின் பொருள் இரண்டாவது வரியை முதல் வரியின் முடிவில் இணைப்பதாகும்.
"நான் விரும்புகிறேன்" + "ஜாவாஸ்கிரிப்ட்"; // எனக்கு ஜாவாஸ்கிரிப்ட் பிடிக்கும்
மதிப்பு "வரையறுக்கப்படவில்லை"undefined என்பது ஒரு சிறப்பு பழமையான தரவு வகை ஆகும், இது வரையறுக்கப்படாத மதிப்புக்கு சமமான ஒற்றை மதிப்பைக் கொண்டுள்ளது.
இந்த தரவு வகை அறிவிக்கப்பட்ட மாறியைக் கொண்டுள்ளது, அது இன்னும் மதிப்பு ஒதுக்கப்படவில்லை.
வர் எண்; // வரையறுக்கப்படவில்லை
ஒரு பொருளின் இல்லாத சொத்தை அணுகும்போது வரையறுக்கப்படாத மதிப்பும் வழங்கப்படும்.
Var obj = (); // வெற்று பொருள் obj.prop; // வரையறுக்கப்படவில்லை
"பூஜ்ய" மதிப்புnull என்பது ஒரு சிறப்பு பழமையான தரவு வகையாகும், இது பூஜ்யத்திற்கு சமமான ஒற்றை மதிப்பைக் கொண்டுள்ளது.
null என்பது "ஒன்றுமில்லை" அல்லது "தெரியாத மதிப்பு" என்ற பொருளைக் கொண்ட ஒரு சிறப்பு மதிப்பு, அதாவது. இது தெளிவாக எதையும் குறிக்கவில்லை.
பொருள்ஒரு பொருள் என்பது பெயர்-மதிப்பு ஜோடிகளைக் கொண்ட தரவுக் கட்டமைப்பாகும்.
பொருள் இலக்கணத்தைப் பயன்படுத்தி ஒரு பொருளை உருவாக்குவது பின்வருமாறு செய்யப்படுகிறது:
(பெயர்_1: மதிப்பு_1, பெயர்_2: மதிப்பு_2, பெயர்_3: மதிப்பு_3, ... )
நீங்கள் பார்க்க முடியும் என, பெயர் ஒரு பெருங்குடலைப் பயன்படுத்தி மதிப்பிலிருந்து பிரிக்கப்படுகிறது, மேலும் ஜோடிகள் கமாவைப் பயன்படுத்தி ஒருவருக்கொருவர் பிரிக்கப்படுகின்றன.
மேலும், ஜோடியின் மதிப்பு ஒரு செயல்பாடாக இருந்தால், அது இந்த பொருளின் முறை என்று அழைக்கப்படுகிறது. மற்ற அனைத்து ஜோடிகளும், அதாவது. ஒரு செயல்பாடு மதிப்பாகப் பயன்படுத்தப்படாத ஜோடிகள் பொருள் பண்புகள் என்று அழைக்கப்படுகின்றன.
வேறு வார்த்தைகளில் கூறுவதானால், ஒரு பொருள் என்பது பண்புகள் மற்றும் முறைகளைக் கொண்ட தரவுக் கட்டமைப்பாகும்.
Var நபர் = (பெயர்: "விட்டலி", வயது: 27, getAge: செயல்பாடு () ( திரும்ப "வயது: " + this.age; ) )
ஒரு பொருளின் பண்புகளை அணுகுவது ஒரு காலகட்டத்தின் மூலம் அல்லது அடைப்புக்குறி குறியீட்டைப் பயன்படுத்தி செய்யப்படுகிறது.
// உலாவி கன்சோலில் வயதுச் சொத்தின் மதிப்பைக் காட்டவும் // 1வது முறை (ஒரு புள்ளி வழியாக) console.log(person.age); // முறை 2 (அடைப்புக்குறிகளைப் பயன்படுத்தி) console.log(நபர்["வயது"]); // getAge முறையை அழைக்கவும்; அது தரும் மதிப்பு console.log(person.getAge()) க்கு வெளியீடாக இருக்கும்;
ஆபரேட்டர் வகைஒரு வெளிப்பாட்டின் தரவு வகை பற்றிய தகவலை ஒரு சரமாகப் பெற ஆபரேட்டர் வகை பயன்படுத்தப்படுகிறது.
ஆபரேட்டர் வகையின் தொடரியல் (அடைப்புக்குறிகள் இல்லாத விருப்பம்):
வெளிப்பாடு வகை
ஆபரேட்டர் தொடரியல் வகை (அடைப்புக்குறிகளைப் பயன்படுத்தி):
வகை(வெளிப்பாடு)
வர் பெயர், வயது = 37, மின்னஞ்சல் = " [மின்னஞ்சல் பாதுகாக்கப்பட்டது]", உரிமம் = உண்மை, ஆர்வம்: பூஜ்யம், கடைசி அனுபவம்: ( காலம்: "ஜூன் 2011 - ஜூன் 2018", இடம்: "ISACA, மாஸ்கோ", நிலை: "வலை வடிவமைப்பாளர்" ), getExperience: function() ( return lastExperience.period + " ("+ lastExperience.position + " - " + lastExperience.place + ")"; ); பெயர் வகை; // "வரையறுக்கப்படாத" வயது வகை; // "எண்" வகை என்பது உரிமம்; // "பூலியன்" வகை ஆர்வம்; / / "பொருள்" (1) கடந்த அனுபவத்தின் வகை; // "பொருள்" வகை அனுபவத்தைப் பெறுதல்; // "செயல்பாடு" (2) /* (1) என்பது முதலில் செயல்படுத்தப்பட்டதில் இருந்து மொழியில் இருக்கும் ஒரு பிழை; அது இல்லை பொருந்தக்கூடிய தன்மையை பராமரிக்க சரி செய்யப்பட்டது மற்றும் ஸ்கிரிப்ட்களை எழுதும் போது இது கணக்கில் எடுத்துக்கொள்ளப்பட வேண்டும்; பூஜ்யம் ஒரு பழமையான தரவு வகை, இது ஒரு பொருள் அல்ல */ /* (2) - ஆபரேட்டர் வகை தனித்தனியாக செயல்பாடுகளை பிரிப்பது மிகவும் வசதியானது; ஆனால் JavaScipt இல் உள்ள ஒரு செயல்பாடும் ஆப்ஜெக்ட் ஆகும்; பின்வரும் கட்டுமானத்தை செயல்படுத்துவதன் மூலம் இதை எளிதாக சரிபார்க்க முடியும்: */ typeof getExperience.__proto__.__proto__ // "object" (செயல்பாட்டு முன்மாதிரி ஒரு பொருள்)
மாறிலிகள்ECMAScript 6 இன் வெளியீட்டில், மாறிலிகளை உருவாக்குவது சாத்தியமானது. இது const முக்கிய சொல்லைப் பயன்படுத்தி செய்யப்படுகிறது.
கான்ஸ்ட் COLOR_RED = "#ff0000";
மாறிலி என்பது ஒரு மாறி, அதன் மதிப்பு மாற்றத்திலிருந்து பாதுகாக்கப்படுகிறது. அந்த. நீங்கள் மதிப்பை மாற்ற முயற்சிக்கும்போது, ஒரு பிழை வீசப்படும்.
கான்ஸ்ட் COLOR_RED = "#ff0000"; COLOR_RED = "#f44336"; // பிடிக்கப்படாத வகைப் பிழை: நிலையான மாறிக்கான ஒதுக்கீடு.
எடுத்துக்காட்டாக, ஒரு மாறிலி ஒரு பொருளைக் கொண்டிருந்தால், அதை மாற்ற முடியாது, அல்லது அதற்கு பதிலாக. ஆனால் இந்த பொருளின் பண்புகள் மாற்றப்படலாம்.
கான்ஸ்ட் நிறங்கள் = (சிவப்பு: "#ff0000", பச்சை: "#00ff00", நீலம்: "#00ff00" ) COLORS = ["#ff0000","#00ff00","#00ff00"]; // பிடிக்கப்படாத வகைப் பிழை: நிலையான மாறிக்கான ஒதுக்கீடு. COLORS.green = "#4caf50";
தரவு வகைகள் நிரலாக்க மொழிகளில் தரவை வகைப்படுத்த உதவுகின்றன. எடுத்துக்காட்டாக, ஒரு எண் மற்றும் எழுத்துச் சரம் என்பது ஜாவாஸ்கிரிப்ட் வித்தியாசமாக நடத்தும் வெவ்வேறு வகையான தரவு.
ஒவ்வொரு தரவு வகையும் குறிப்பிட்ட மதிப்புகளை எடுத்து குறிப்பிட்ட செயல்களைச் செய்ய முடியும் என்பதால் இது முக்கியமானது. ஜாவாஸ்கிரிப்டில் மாறிகளில் செயல்பாடுகளைச் செய்ய, கொடுக்கப்பட்ட ஒவ்வொரு மாறியின் தரவு வகையைப் புரிந்துகொள்வது அவசியம்.
இந்த டுடோரியல் ஜாவாஸ்கிரிப்ட் தரவு வகைகளை உங்களுக்கு அறிமுகப்படுத்தும்.
குறிப்பு: இந்த வழிகாட்டியில் உள்ள தகவல் முழுமையானது அல்ல, ஆனால் இது அடிப்படை JavaScript விருப்பங்களின் மேலோட்டத்தை உங்களுக்கு வழங்கும்.
டைனமிக் தட்டச்சுஜாவாஸ்கிரிப்ட் ஒரு டைனமிக் மொழி. இதன் பொருள் தரவு வகை சரிபார்ப்பு ரன் நேரத்தில் செய்யப்படுகிறது, தொகுக்கும் நேரத்தில் அல்ல.
டைனமிக் மொழிகளில், அதே பெயரின் மாறிகள் சேமிக்க பயன்படுத்தப்படலாம் பல்வேறு வகையானதகவல்கள்.
எடுத்துக்காட்டாக, var முக்கிய சொல்லால் வரையறுக்கப்பட்ட மாறி t, பல்வேறு வகையான தரவுகளை சேமிக்க முடியும்; இது துவக்கப்படலாம் ஆனால் வரையறுக்கப்படாமல் விடப்படும்:
var t = 16; // t என்பது ஒரு எண்
var t = "தெரசா"; // t என்பது ஒரு சரம்
var t = உண்மை; // t என்பது பூலியன்
var t; // t என்பது வரையறுக்கப்படவில்லை
அனைத்து டி மாறிகளும் வெவ்வேறு ஜாவாஸ்கிரிப்ட் தரவு வகைகளைக் கொண்டிருக்கின்றன. ஜாவாஸ்கிரிப்டில், ஒரு மாறியைப் பயன்படுத்துவதற்கு முன் அதன் தரவு வகையை நீங்கள் வெளிப்படையாகக் குறிப்பிட வேண்டியதில்லை.
எண்கள்ஜாவாஸ்கிரிப்ட் ஒற்றை எண் தரவு வகையைக் கொண்டுள்ளது, முழு எண்கள் மற்றும் மிதக்கும் புள்ளி எண்களை வேறுபடுத்துவதில்லை. எனவே, ஜாவாஸ்கிரிப்டில் உள்ள எண்களை தசம இடங்களுடன் அல்லது இல்லாமல் எழுதலாம்:
var எண்1 = 93;
var எண்2 = 93.00;
மேலே உள்ள எடுத்துக்காட்டில், இரண்டு மாறிகளும் எண்களைக் கொண்டிருக்கின்றன, அதில் காற்புள்ளி உள்ளதா இல்லையா.
ஜாவாஸ்கிரிப்டில் உள்ள அறிவியல் குறியீடானது, மிகப் பெரிய அல்லது சிறிய எண்களை சுருக்கிக் கொள்ள உங்களை அனுமதிக்கிறது:
var எண்3 = 987e8; // 98700000000
var எண்4 = 987e-8; // 0.00000987
ஜாவாஸ்கிரிப்ட்டில், எண்கள் 15 இலக்கங்கள் வரை துல்லியமாகக் கருதப்படுகின்றன. இதன் பொருள் 16 வது இலக்கத்தை அடைந்த பிறகு எண்கள் வட்டமிடப்படும்:
var எண்5 = 999999999999999; // 999999999999999 ஆக உள்ளது
var எண்6 = 9999999999999999; //00000000000000000
மேலும், ஜாவாஸ்கிரிப்டில் உள்ள எண்களுக்கு மூன்று குறியீட்டு அர்த்தங்கள் உள்ளன:
முடிவிலி - எண் மதிப்பு, இது முடிவிலியை நெருங்கும் நேர்மறை எண்.
முடிவிலி என்பது ஒரு எண் மதிப்பாகும், இது முடிவிலியை நெருங்கும் எதிர்மறை எண்ணைக் குறிக்கிறது.
NaN - எண் அல்ல, மிதக்கும் புள்ளி எண்ணின் சிறப்பு நிலை.
ஜாவாஸ்கிரிப்ட்டில் கிடைக்கக்கூடிய அதிகபட்ச எண்ணைத் தாண்டி எண்ணை எண்ணும்போது முடிவிலி மற்றும் -முடிவிலி ஆகியவை வழங்கப்படும். பூஜ்ஜியத்தால் வகுத்தல் போன்ற வரையறுக்கப்படாத மதிப்புகளை எண்ணும் போது அவை தோன்றும்:
var எண்7 = 5 / 0; // முடிவிலி
var எண்8 = -5 / 0; // -முடிவிலி
தொழில்நுட்ப ரீதியாக, ஜாவாஸ்கிரிப்டில் அதிகபட்ச வரம்பான 1.797693134862315E+308 ஐ விட அதிகமாக இருந்தால், இன்ஃபினிட்டி திரும்பப் பெறப்படும்.
அதேபோல, -1.797693134862316E+308ஐத் தாண்டி எண் வரும்போது -இன்ஃபினிட்டி காட்டப்படும்.
முடிவிலி எண்ணை சுழல்களிலும் பயன்படுத்தலாம்:
அதே நேரத்தில் (எண்9 != முடிவிலி) (
// இங்கே குறியீடு எண்9 = முடிவிலி மூலம் செயல்படுத்தப்படும்
}
வரையறுக்கப்படாத எண்களுக்கு, NaN அச்சிடப்படுகிறது. எண் மற்றும் எண் அல்லாத மதிப்பில் ஒரு கணித செயல்பாட்டைச் செய்ய முயற்சித்தால், நீங்கள் NaN பெறுவீர்கள். உதாரணத்திற்கு:
var x = 20 / "சுறா"; // x என்பது NaN ஆக இருக்கும்
20ஐ ஷார்க் சரத்தால் வகுக்க முடியாது என்பதால், x இன் மதிப்பு NaN ஆக இருக்கும்.
இருப்பினும், சரத்தை ஒரு எண் மதிப்பாக மதிப்பிட முடியுமானால், ஜாவாஸ்கிரிப்ட் கணித வெளிப்பாட்டை மதிப்பிடும்:
var y = 20 / "5"; //y 4 ஆக இருக்கும்
ஜாவாஸ்கிரிப்ட் 5 ஐ ஒரு எண் மதிப்பாகக் கருதுவதால், 5 கணிதப் பிரிவு ஆபரேட்டருடன் வேலை செய்யும்.
ஒரு வெளிப்பாட்டின் ஒரு மாறியை NaN என அமைத்தால், இரண்டாவது செயலி எண்ணாக இருந்தாலும், அதன் விளைவு NaN ஆக இருக்கும்.
var a = NaN;
var b = 37;
var c = a + b; // c என்பது NaN ஆக இருக்கும்
எனவே, ஜாவாஸ்கிரிப்ட்டில் ஒரே ஒரு எண் தரவு வகை மட்டுமே உள்ளது. ஜாவாஸ்கிரிப்ட்டில், எண்களை முழு எண்களாகவும் மிதக்கும் புள்ளி எண்களாகவும் பிரிக்க வேண்டிய அவசியமில்லை, ஏனெனில் ஜாவாஸ்கிரிப்ட் ஒரு மாறும் மொழி.
சரங்கள்சரம் என்பது ஒன்று அல்லது அதற்கு மேற்பட்ட எழுத்துக்களின் (எழுத்துக்கள், எண்கள் மற்றும் பிற குறியீடுகள்) வரிசையாகும். சரங்கள் உரைத் தரவைக் குறிக்கின்றன.
ஜாவாஸ்கிரிப்ட்டில், சரங்கள் ஒற்றை மற்றும் இரட்டை மேற்கோள்களில் வருகின்றன. ஒரு சரத்தை உருவாக்க, நீங்கள் மேற்கோள்களில் எழுத்துக்களின் வரிசையை இணைக்க வேண்டும்:
var singleQuotes = "இது ஒற்றை மேற்கோள்களில் ஒரு சரம்.";
var doubleQuotes = "இது இரட்டை மேற்கோள்களில் ஒரு சரம்.";
நீங்கள் ஒற்றை அல்லது இரட்டை மேற்கோள்களைப் பயன்படுத்தலாம், ஆனால் ஒரே குறியீட்டிற்குள் நீங்கள் ஒரு வகை மேற்கோளை தொடர்ந்து பயன்படுத்த வேண்டும்.
திட்டம் "வணக்கம், உலகம்!" கணினி நிரலாக்கத்தில் சரங்கள் எவ்வாறு பயன்படுத்தப்படுகின்றன என்பதை நிரூபிக்கிறது. அடிப்படையில், இல் இந்த எடுத்துக்காட்டில்ஒரு சரம் என்பது "ஹலோ, வேர்ல்ட்!" என்ற சொற்றொடரை உருவாக்கும் எழுத்துக்களின் வரிசையாகும். எச்சரிக்கையில் ().
செயல்பாடு helloFunction() (
எச்சரிக்கை ("வணக்கம், உலகம்!");
}
என்னை கிளிக் செய்யவும்
குறியீட்டை இயக்கி, என்னை கிளிக் செய்யவும் பொத்தானைக் கிளிக் செய்வதன் மூலம், உரையுடன் கூடிய பாப்-அப் சாளரத்தைக் காண்பீர்கள்:
மற்ற தரவு வகைகளைப் போலவே, சரங்களையும் மாறிகளில் சேமிக்க முடியும்.
var hw = "வணக்கம், உலகம்!";
மாறியை அழைப்பதன் மூலம் நீங்கள் சரத்தைக் காட்டலாம்:
...
var hw = "வணக்கம், உலகம்!";
செயல்பாடு helloFunction() (
எச்சரிக்கை(hw);
}
...
வணக்கம், உலகம்!
சரங்கள் பயனருக்கு தகவலை அனுப்பவும், நிரலுக்குத் திரும்பவும் அனுமதிக்கின்றன.
பூலியன் தரவு வகைஒரு பூலியன் (அல்லது பூலியன்) தரவு வகை இரண்டு மதிப்புகளைக் கொண்டுள்ளது - உண்மை மற்றும் தவறு.
கணினி அறிவியலில் தர்க்கம் மற்றும் வழிமுறைகளுடன் தொடர்புடைய உண்மை மதிப்புகளைக் குறிக்க இந்த வகை பயன்படுத்தப்படுகிறது.
குறிப்பு: இந்த தரவு வகை கணிதவியலாளர் ஜார்ஜ் பூல் பெயரிடப்பட்டது.
கணிதத்தில் பல செயல்பாடுகள் உண்மை அல்லது பொய் என மதிப்பிடக்கூடிய முடிவுகளை உருவாக்குகின்றன:
மேலும்:
- 500 > 100 உண்மை
- 1 > 5 தவறானது
குறைவாக:
- 200 < 400 true
- 4 < 2 false
- 5 = 5 உண்மை
- 500 = 400 தவறானது
மற்ற வகைகளைப் போலவே, பூலியன் தரவு வகையும் மாறிகளில் சேமிக்கப்படும்.
var myBool = 5 > 8; //பொய்
5 ஆனது 8 ஐ விட அதிகமாக இல்லாததால், myBool தவறானதாக இருக்கும்.
நீங்கள் ஜாவாஸ்கிரிப்ட்டில் குறியிடும்போது, பூலியன் தரவு எவ்வாறு செயல்படுகிறது மற்றும் பல்வேறு உண்மை-மதிப்பீட்டு செயல்பாடுகள் மற்றும் செயல்பாடுகள் ஒரு நிரலின் ஓட்டத்தை எவ்வாறு மாற்றும் என்பதை நீங்கள் நன்கு அறிந்திருப்பீர்கள்.
அணிவரிசைகள்ஒரு வரிசை ஒரு மாறிக்குள் பல மதிப்புகளைக் கொண்டிருக்கலாம். இதன் பொருள் நீங்கள் ஒரு வரிசையில் மதிப்புகளின் பட்டியலைச் சேமித்து அவற்றை மீண்டும் மீண்டும் செய்யலாம்.
வரிசையில் உள்ள ஒவ்வொரு மதிப்பும் ஒரு உறுப்பு என்று அழைக்கப்படுகிறது. ஒரு குறியீட்டைப் பயன்படுத்தி ஒரு வரிசையின் கூறுகளை நீங்கள் அணுகலாம்.
வரிசைகள் சதுர அடைப்புக்குறிகளால் வரையறுக்கப்படுகின்றன.
சரம் வரிசை இது போல் தெரிகிறது:
var மீன் = ["சுறா", "கட்டில்ஃபிஷ்", "கோமாளி", "ஈல்"];
மீன் மாறியை அழைப்பதன் மூலம், நீங்கள் முடிவைப் பெறுவீர்கள்:
["சுறா", "கட்டில்ஃபிஷ்", "கோமாளி", "ஈல்"]
அணிவரிசைகள் மிகவும் நெகிழ்வான தரவு வகையாகும், ஏனெனில் அவை மாறக்கூடியவை: நீங்கள் உறுப்புகளின் மதிப்புகளைச் சேர்க்கலாம், அகற்றலாம் மற்றும் மாற்றலாம்.
பொருள்கள்ஜாவாஸ்கிரிப்டில் உள்ள ஒரு பொருள் விசை:மதிப்பு ஜோடிகளைக் கொண்டுள்ளது.
பொருள் தொடரியல் முக்கிய:மதிப்பு ஜோடிகளைக் கொண்டுள்ளது. ஒரு பொருள் இருபுறமும் (()) சுருள் பிரேஸ்களால் பிரிக்கப்படுகிறது.
பொருளில் உள்ள ஜோடிகள் இடைவெளிகளால் பிரிக்கப்படுகின்றன:
var சாமி = (முதல்பெயர்:"வாலி", கடைசிப்பெயர்:"சுறா", நிறம்:"நீலம்", இடம்:"கடல்");
ஒரு பொருளை பல வரிகளிலும் எழுதலாம் (இது பெரிய பொருள்களுக்கு குறிப்பாக உண்மை).
var wally = (
முதல் பெயர்: "வாலி",
கடைசி பெயர்: "சுறா",
நிறம்: "நீலம்",
இடம்: "கடல்"
};
நீங்கள் உருவாக்கும் ஒவ்வொரு நிரலும் பல தரவு வகைகளைக் கொண்டிருக்கலாம், ஆனால் செயல்பாடுகள் பொதுவாக ஒரு தரவு வகையிலேயே செய்யப்படுகின்றன. எண்களுக்கு கணிதம் பயன்படுத்தப்படுகிறது, மற்றும் சரங்களுக்கு வெட்டுதல் பயன்படுத்தப்படுகிறது.
அனைத்து வகையான தரவுகளுடன் பணிபுரியும் ஆபரேட்டர்களைப் பயன்படுத்துவதன் மூலம் (உதாரணமாக, + ஆபரேட்டர் எண்களைச் சேர்க்கலாம் அல்லது சரம் ஒருங்கிணைப்பைச் செய்யலாம்), நீங்கள் எதிர்பாராத முடிவுகளைப் பெறலாம்.
நீங்கள் இணைப்பிற்காக ஒரு மாறியை உருவாக்கினால், ஜாவாஸ்கிரிப்ட் ஒவ்வொரு உறுப்பையும் ஒரு சரமாக விளக்குகிறது.
var o = "கடல்" + 5 + 3;
மாறி o ஐ அழைப்பதன் மூலம், பின்வரும் முடிவைப் பெறுவீர்கள்:
இருப்பினும், சரத்தில் முதலில் எண்கள் மற்றும் பின்னர் ஒரு சரம் இருந்தால், + ஆபரேட்டர் கூட்டல் மற்றும் பின்னர் ஒருங்கிணைப்பை செய்யும்:
var p = 5 + 3 + "கடல்";
8 பெருங்கடல்
முடிவுகள் கணிக்க முடியாதவை என்பதால், ஒரு தரவு வகையில் செயல்பாடுகள் மற்றும் முறைகளைச் செய்வது மிகவும் வசதியானது. இருப்பினும், வேறு சில நிரலாக்க மொழிகள் செய்வது போல, தரவு வகைகளை கலக்கும்போது JavaScript பிழைகளைத் தராது.
முடிவுரைநீங்கள் இப்போது JavaScript தரவு வகைகளை நன்கு அறிந்திருக்கிறீர்கள். ஜாவாஸ்கிரிப்ட் நிரல்களை எழுதும்போது இங்கு பட்டியலிடப்பட்டுள்ள ஒவ்வொரு வகைகளும் முக்கியமானவை.
குறிச்சொற்கள்: ஒரு மாறி என்பது ஒரு மதிப்பை ஒதுக்கிய அடையாளங்காட்டியாகும். ஒரு நிரலில் ஒரு மாறியை அணுகலாம், இதனால் அதற்கு ஒதுக்கப்பட்ட மதிப்புடன் வேலை செய்கிறது.ஒரு ஜாவாஸ்கிரிப்ட் மாறி, அதில் சேமிக்கப்படும் மதிப்புகளின் வகை பற்றிய தகவலைக் கொண்டிருக்கவில்லை. இதன் பொருள், எடுத்துக்காட்டாக, ஒரு மாறிக்கு ஒரு சரத்தை எழுதுவதன் மூலம், நீங்கள் அதற்கு ஒரு எண்ணை எழுதலாம். அத்தகைய செயல்பாடு நிரலில் பிழையை ஏற்படுத்தாது. அதனால்தான் ஜாவாஸ்கிரிப்ட் சில நேரங்களில் "டைப் செய்யப்படாத" மொழி என்று அழைக்கப்படுகிறது.
ஒரு மாறியைப் பயன்படுத்துவதற்கு முன், அது var அல்லது let முக்கிய சொல்லைப் பயன்படுத்தி அறிவிக்கப்பட வேண்டும். நாம் ஒரு மாறிலியைப் பற்றி பேசினால், const என்ற முக்கிய சொல் பயன்படுத்தப்படுகிறது. இந்த முக்கிய வார்த்தைகளைப் பயன்படுத்தாமல் நீங்கள் ஒரு மாறியை அறிவிக்கலாம் மற்றும் அதற்கு ஒரு மதிப்பை ஒதுக்கலாம், ஆனால் அவ்வாறு செய்ய பரிந்துரைக்கப்படவில்லை.
▍முக்கிய வார்த்தை var ES2015 தரநிலைக்கு முன், var முக்கிய வார்த்தையின் பயன்பாடு இருந்தது ஒரே வழிமாறி அறிவிப்புகள்.Var a = 0
இந்தக் கட்டமைப்பில் var ஐத் தவிர்த்துவிட்டால், அறிவிக்கப்படாத மாறிக்கு மதிப்பு ஒதுக்கப்படும். இந்த செயல்பாட்டின் முடிவு நிரல் செயல்படுத்தப்படும் பயன்முறையைப் பொறுத்தது.
எனவே, கண்டிப்பான பயன்முறை என்று அழைக்கப்படுவது இயக்கப்பட்டால், இது ஒரு பிழையை ஏற்படுத்தும். கண்டிப்பான பயன்முறை இயக்கப்படவில்லை என்றால், மாறி மறைமுகமாக அறிவிக்கப்பட்டு உலகளாவிய பொருளுக்கு ஒதுக்கப்படும். குறிப்பாக, இந்த வழியில் ஒரு செயல்பாட்டில் மறைமுகமாக அறிவிக்கப்பட்ட ஒரு மாறி செயல்பாடு முடிந்த பிறகும் கிடைக்கும். பொதுவாக, செயல்பாடுகளில் அறிவிக்கப்பட்ட மாறிகள் அவற்றின் நோக்கத்திற்கு அப்பால் செல்லாது என்று எதிர்பார்க்கப்படுகிறது. இது போல் தெரிகிறது:
செயல்பாடு notVar() ( bNotVar = 1 //இதைச் செய்யாமல் இருப்பது நல்லது) notVar() console.log(bNotVar)
1 கன்சோலில் தோன்றும், ஒரு நிரலில் இருந்து பொதுவாக யாரும் அத்தகைய நடத்தையை எதிர்பார்க்க மாட்டார்கள், bNotVar = 1 என்ற வெளிப்பாடு ஒரு மாறியை அறிவித்து துவக்கும் முயற்சியாகத் தெரியவில்லை, மாறாக ஒரு மாறியை அணுகுவதற்கான முயற்சியைப் போன்றது. செயல்பாடு (இது மிகவும் சாதாரணமானது). இதன் விளைவாக, மறைமுகமான மாறி அறிவிப்புகள் குறியீட்டைப் படிப்பவர்களுக்கு குழப்பத்தை ஏற்படுத்துகின்றன மற்றும் எதிர்பாராத நிரல் நடத்தைக்கு வழிவகுக்கும். பின்னர் நாம் செயல்பாடுகள் மற்றும் நோக்கங்கள் இரண்டையும் பற்றி பேசுவோம், ஆனால் ஒரு வெளிப்பாட்டின் பொருள் மாறியை அறிவிக்கும் போது எப்போதும் சிறப்பு முக்கிய வார்த்தைகளைப் பயன்படுத்த முயற்சிக்கவும். இந்த எடுத்துக்காட்டில், செயல்பாட்டு உடல் var bNotVar = 1 என மீண்டும் எழுதப்பட்டால், மேலே உள்ள குறியீட்டு பகுதியை இயக்க முயற்சித்தால் பிழைச் செய்தி வரும் (நீங்கள் அதை உலாவி கன்சோலில் பார்க்கலாம்).
எடுத்துக்காட்டாக, இது இப்படித் தோன்றலாம்: கண்டறியப்படாத குறிப்புப் பிழை: bNotVar வரையறுக்கப்படவில்லை . நிரல் இல்லாத மாறியுடன் வேலை செய்ய முடியாது என்பதில் அதன் பொருள் கொதிக்கிறது. எதிர்பாராத விதமாக நடந்துகொள்ளக்கூடிய புரிந்துகொள்ள முடியாத குறியீட்டை எழுதுவதை விட, நீங்கள் முதலில் ஒரு நிரலைத் தொடங்கும்போது இதுபோன்ற பிழைச் செய்தியைப் பார்ப்பது மிகவும் நல்லது.
ஒரு மாறியை அறிவிக்கும் போது, அது துவக்கப்படவில்லை அல்லது எந்த மதிப்பையும் ஒதுக்கவில்லை என்றால், அது தானாகவே வரையறுக்கப்படாத மதிப்பு ஒதுக்கப்படும்.
Var a //வகை a === "வரையறுக்கப்படாதது"
var முக்கிய வார்த்தையுடன் அறிவிக்கப்பட்ட மாறிகள் மீண்டும் பல முறை அறிவிக்கப்படலாம், அவற்றுக்கு புதிய மதிப்புகளை ஒதுக்கலாம் (ஆனால் இது குறியீட்டைப் படிக்கும் நபருக்கு குழப்பமாக இருக்கலாம்).
Var a = 1 var a = 2
நீங்கள் ஒரு வெளிப்பாட்டில் பல மாறிகளை அறிவிக்கலாம்:
Var a = 1, b = 2
ஒரு மாறியின் நோக்கம் இந்த மாறி அணுகக்கூடிய (தெரியும்) நிரலின் பகுதி.
ஒரு செயல்பாட்டிற்கு வெளியே var முக்கிய வார்த்தையுடன் துவக்கப்பட்ட ஒரு மாறியானது உலகளாவிய பொருளுக்கு ஒதுக்கப்படுகிறது. இது உலகளாவிய நோக்கத்தைக் கொண்டுள்ளது மற்றும் நிரலில் எங்கிருந்தும் அணுகலாம். ஒரு செயல்பாட்டின் உள்ளே var முக்கிய சொல்லைப் பயன்படுத்தி ஒரு மாறி அறிவிக்கப்பட்டால், அது அந்தச் செயல்பாட்டிற்குள் மட்டுமே தெரியும், அது ஒரு உள்ளூர் மாறியாக இருக்கும்.
var ஐப் பயன்படுத்தும் ஒரு செயல்பாடு, உலகளாவிய நோக்கத்தில் ஒரு மாறியின் பெயரைப் போலவே இருக்கும் ஒரு மாறியை அறிவித்தால், அது உலகளாவிய மாறியை "மேலறியும்". அதாவது, ஒரு செயல்பாட்டிற்குள் அத்தகைய மாறியை அணுகும்போது, அதன் உள்ளூர் பதிப்பு பயன்படுத்தப்படும்.
தொகுதிகள் (சுருள் பிரேஸ்களில் உள்ள குறியீட்டின் பகுதிகள்) புதிய நோக்கங்களை உருவாக்காது என்பதைப் புரிந்துகொள்வது அவசியம். புதிய பகுதிசெயல்பாடு அழைக்கப்படும் போது தெரிவுநிலை உருவாக்கப்படுகிறது. var முக்கிய சொல்லானது பிளாக் ஸ்கோப்பை விட செயல்பாட்டு நோக்கம் என்று அழைக்கப்படுகிறது.
செயல்பாட்டுக் குறியீட்டில் ஒரு மாறி அறிவிக்கப்பட்டால், அது முழு செயல்பாட்டுக் குறியீட்டிற்கும் தெரியும். செயல்பாட்டுக் குறியீட்டின் முடிவில் var ஐப் பயன்படுத்தி ஒரு மாறி அறிவிக்கப்பட்டாலும், ஜாவாஸ்கிரிப்ட் ஒரு மாறி ஏற்றும் பொறிமுறையைக் கொண்டிருப்பதால், குறியீட்டின் தொடக்கத்தில் அதை அணுகலாம். இந்த பொறிமுறையானது மாறி அறிவிப்புகளை "தூக்குகிறது", ஆனால் அவற்றின் துவக்க செயல்பாடுகள் அல்ல. இது குழப்பத்திற்கு ஒரு ஆதாரமாக இருக்கலாம், எனவே உங்கள் செயல்பாட்டின் தொடக்கத்தில் மாறிகளை அறிவிப்பதை வழக்கமாக்கிக் கொள்ளுங்கள்.
▍Let முக்கிய வார்த்தை ES2015 இல் அறிமுகப்படுத்தப்பட்டது, மேலும் எளிமையான முறையில், var இன் "பிளாக்" பதிப்பு என்று அழைக்கலாம். லெட் கீவேர்டுடன் அறிவிக்கப்பட்ட மாறிகள், அது அறிவிக்கப்பட்ட பிளாக், ஸ்டேட்மெண்ட் அல்லது வெளிப்பாடு மற்றும் உள்ளமைக்கப்பட்ட தொகுதிகளுக்கு ஸ்கோப் செய்யப்படுகின்றன."லெட்" என்ற வார்த்தையே தெளிவாக தெரியவில்லை என்றால், அதற்கு பதிலாக "லெட்" என்ற வார்த்தையைப் பயன்படுத்துவதை நீங்கள் கற்பனை செய்யலாம். பின்னர் லெட் கலர் = "சிவப்பு" என்பதை ஆங்கிலத்தில் பின்வருமாறு மொழிபெயர்க்கலாம்: "நிறம் சிவப்பு நிறமாக இருக்கட்டும்", மற்றும் ரஷ்ய மொழியில் பின்வருமாறு: "நிறம் சிவப்பு நிறமாக இருக்கட்டும்".
let keyword ஐப் பயன்படுத்துவதன் மூலம், var முக்கிய சொல்லுடன் வரும் தெளிவின்மைகளைத் தவிர்க்கலாம் (உதாரணமாக, let ஐப் பயன்படுத்தி ஒரே மாறியை இரண்டு முறை அறிவிக்க முடியாது). ஒரு செயல்பாட்டிற்கு வெளியே let ஐப் பயன்படுத்துவது, லூப்களை துவக்கும் போது, உலகளாவிய மாறிகளை உருவாக்காது.
எடுத்துக்காட்டாக, இந்த குறியீடு பிழையை உருவாக்கும்:
க்கு (நான் = 0; i< 5; i++) {
console.log(i)
}
console.log(i)
லூப் துவக்கப்படும் போது, கவுண்டர் i var முக்கிய சொல்லைப் பயன்படுத்தி அறிவிக்கப்பட்டால், அதன் வேலையை முடித்த பிறகு நான் லூப்பின் வெளியே கிடைக்கும்.
இந்த நாட்களில், நவீன தரநிலைகளின் அடிப்படையில் JS நிரல்களை உருவாக்கும்போது, var ஐ முற்றிலுமாக கைவிட்டு, let and const முக்கிய வார்த்தைகளை மட்டுமே பயன்படுத்துவது மிகவும் சாத்தியமாகும்.
▍கான்ஸ்ட் முக்கிய வார்த்தை var அல்லது let keywords ஐப் பயன்படுத்தி அறிவிக்கப்பட்ட மாறிகளின் மதிப்புகள் மேலெழுதப்படலாம். இந்த முக்கிய வார்த்தைகளுக்குப் பதிலாக const பயன்படுத்தப்பட்டால், ஒரு மாறிலி அறிவிக்கப்பட்டு அதன் உதவியுடன் துவக்கப்பட்ட ஒரு புதிய மதிப்பை ஒதுக்க முடியாது.கான்ஸ்ட் ஏ = "சோதனை"
இந்த எடுத்துக்காட்டில், மாறிலி a புதிய மதிப்பை ஒதுக்க முடியாது. ஆனால் a என்பது ஒரு எண்ணைப் போன்ற ஒரு பழமையான மதிப்பு அல்ல, ஆனால் ஒரு பொருளாக இருந்தால், const முக்கிய சொல்லைப் பயன்படுத்துவது மாற்றங்களிலிருந்து இந்த பொருளைப் பாதுகாக்காது என்பதைக் கவனத்தில் கொள்ள வேண்டும்.
ஒரு பொருள் ஒரு மாறியில் சேமிக்கப்படுகிறது என்று அவர்கள் கூறும்போது, அவர்கள் உண்மையில் அர்த்தம் என்னவென்றால், மாறி பொருளின் குறிப்பை சேமிக்கிறது. இந்த இணைப்பை மாற்ற முடியாது, ஆனால் இணைப்பு செல்லும் பொருளையே மாற்ற முடியும்.
கான்ஸ்ட் முக்கிய சொல் பொருள்களை மாறாததாக மாற்றாது. மாற்றங்களிலிருந்து தொடர்புடைய மாறிலிகளில் எழுதப்பட்ட குறிப்புகளை இது வெறுமனே பாதுகாக்கிறது. இது போல் தெரிகிறது:
கான்ஸ்ட் obj = () console.log(obj.a) obj.a = 1 //works console.log(obj.a) //obj = 5 //பிழையை ஏற்படுத்துகிறது
துவக்கத்தின் போது, ஒரு புதிய வெற்று பொருள் obj மாறிலிக்கு எழுதப்படுகிறது. அதன் சொத்தை அணுகுவதற்கான முயற்சி, இல்லாதது, பிழையை ஏற்படுத்தாது. கன்சோல் வரையறுக்கப்படவில்லை. அதன் பிறகு, பொருளில் ஒரு புதிய சொத்தை சேர்த்து, அதை மீண்டும் அணுக முயற்சிக்கிறோம். இந்த முறை இந்த சொத்தின் மதிப்பு கன்சோலில் 1 ஆகும். எடுத்துக்காட்டின் கடைசி வரியை நீங்கள் கருத்துரைத்திருந்தால், இந்தக் குறியீட்டை இயக்க முயற்சிப்பது பிழையை ஏற்படுத்தும்.
கான்ஸ்ட் முக்கிய சொல் லெட் க்கு மிகவும் ஒத்திருக்கிறது, குறிப்பாக, இது பிளாக் ஸ்கோப்பைக் கொண்டுள்ளது.
நவீன நிலைமைகளில், மாற்றத் திட்டமிடப்படாத அனைத்து நிறுவனங்களையும் அறிவிக்க const முக்கிய சொல்லைப் பயன்படுத்துவது மிகவும் ஏற்றுக்கொள்ளத்தக்கது, சிறப்பு நிகழ்வுகளில் மட்டுமே அனுமதிக்கப்படுகிறது. ஏன்? முழு புள்ளி என்னவென்றால், நிரலை சிக்கலாக்காமல் மற்றும் பிழைகளைத் தவிர்ப்பதற்காக கிடைக்கக்கூடிய எளிமையான கட்டுமானங்களைப் பயன்படுத்த முயற்சிப்பது சிறந்தது.
ஜாவாஸ்கிரிப்ட் தரவு வகைகள் சில நேரங்களில் "டைப் செய்யப்படாத" மொழி என்று அழைக்கப்படுகின்றன, ஆனால் இது அவ்வாறு இல்லை. நீங்கள் வெவ்வேறு வகைகளின் மதிப்புகளை மாறிகளில் எழுதலாம் என்பது உண்மைதான், ஆனால் ஜாவாஸ்கிரிப்ட்டில் இன்னும் தரவு வகைகள் உள்ளன. குறிப்பாக, நாம் பழமையான மற்றும் பொருள் தரவு வகைகளைப் பற்றி பேசுகிறோம்.மதிப்பின் தரவு வகையைத் தீர்மானிக்க, நீங்கள் ஆபரேட்டர் வகையைப் பயன்படுத்தலாம். இது இயக்கத்தின் வகையைக் குறிக்கும் சரத்தை வழங்குகிறது.
▍Primitive Data வகைகள் இங்கே JavaScript பழமையான தரவு வகைகளின் பட்டியல் உள்ளது:- எண்
- லேசான கயிறு
- பூலியன் (பூலியன் மதிப்பு)
- பூஜ்யம் (சிறப்பு மதிப்பு பூஜ்யம்)
- வரையறுக்கப்படாத (சிறப்பு மதிப்பு வரையறுக்கப்படவில்லை)
- சின்னம் (சின்னம், சிறப்பு நிகழ்வுகளில் பயன்படுத்தப்படுகிறது, ES6 இல் அறிமுகப்படுத்தப்பட்டது)
இந்தப் பட்டியலில் இருந்து பொதுவாகப் பயன்படுத்தப்படும் தரவு வகைகளைப் பற்றிப் பார்ப்போம்.
ஜாவாஸ்கிரிப்டில் உள்ள வகை எண்ணின் எண் வகை மதிப்புகள் 64-பிட் இரட்டை துல்லியமான மிதக்கும் புள்ளி எண்களாக குறிப்பிடப்படுகின்றன.குறியீட்டில், தசம எண் அமைப்பில் உள்ள எண்கள் முழு எண்களாகவும் பின்னங்களாகவும் குறிப்பிடப்படுகின்றன. எண்களை எழுத மற்ற முறைகளைப் பயன்படுத்தலாம். எடுத்துக்காட்டாக, ஒரு எண் எழுத்தின் தொடக்கத்தில் 0x என்ற முன்னொட்டு இருந்தால், அது ஹெக்ஸாடெசிமல் குறியீட்டில் எழுதப்பட்ட எண்ணாகக் கருதப்படுகிறது. எண்களை அதிவேகக் குறிப்பிலும் எழுதலாம் (அத்தகைய எண்களில் e என்ற எழுத்தைக் காணலாம்).
முழு எண்களை எழுதுவதற்கான எடுத்துக்காட்டுகள் இங்கே:
10 5354576767321 0xCC // ஹெக்ஸாடெசிமல் எண்
இங்கே பின்னங்கள் உள்ளன.
3.14 .1234 5.2e4 //5.2 * 10^4
எண் எழுத்துக்கள் (இந்த நடத்தை வேறு சில பழமையான வகைகளுக்கும் பொதுவானது), நீங்கள் அவற்றைப் பொருள்களாக அணுக முயற்சிக்கும்போது, தானாகவே, செயல்பாட்டின் காலத்திற்கு, தொடர்புடைய பொருள்களாக மாற்றப்படும், அவை "பொருள் ரேப்பர்கள்" என்று அழைக்கப்படுகின்றன. இந்த வழக்கில் நாம் எண் பொருள் ரேப்பர் பற்றி பேசுகிறோம்.
இங்கே, எடுத்துக்காட்டாக, a மாறியை அணுகுவதற்கான முயற்சியானது, இதில் ஒரு எண் எழுத்துக்குறி உள்ளது, இது Google Chrome கன்சோலில் ஒரு பொருளாகத் தெரிகிறது.
எண் பொருள் ரேப்பர் குறிப்பு
எடுத்துக்காட்டாக, நீங்கள் வகை எண்ணின் பொருளின் toString() முறையைப் பயன்படுத்தினால், அது எண்ணின் சரம் பிரதிநிதித்துவத்தை வழங்கும். தொடர்புடைய கட்டளை இது போல் தெரிகிறது, இது உலாவி கன்சோலில் (மற்றும் வழக்கமான குறியீட்டில்) செயல்படுத்தப்படலாம்:
A.toString()
முறையின் பெயருக்குப் பிறகு இரட்டை அடைப்புக்குறிகளைக் கவனியுங்கள். நீங்கள் அவற்றை வழங்கவில்லை என்றால், கணினி பிழையை உருவாக்காது, ஆனால் எதிர்பார்த்த வெளியீட்டிற்கு பதிலாக, எண் 5 இன் சரம் பிரதிநிதித்துவத்திற்கு ஒத்ததாக இல்லாத ஒன்றை கன்சோலில் காண்பீர்கள்.
உலகளாவிய எண் பொருளை ஒரு கட்டமைப்பாளராகப் பயன்படுத்தலாம், அதன் உதவியுடன் புதிய எண்களை உருவாக்கலாம் (இருப்பினும், இது கிட்டத்தட்ட இந்த வடிவத்தில் பயன்படுத்தப்படவில்லை), அதன் நிகழ்வுகளை உருவாக்காமல் (அதாவது, குறிப்பிட்ட எண்கள்) ஒரு சுயாதீன நிறுவனமாகவும் பயன்படுத்தப்படலாம். அதன் உதவியுடன் குறிப்பிடப்படுகிறது). எடுத்துக்காட்டாக, அதன் Number.MAX_VALUE பண்பு JavaScript இல் குறிப்பிடக்கூடிய அதிகபட்ச எண் மதிப்பைக் கொண்டுள்ளது.
வகை சரம் வகை சரத்தின் மதிப்புகள் எழுத்துக்களின் வரிசைகள். இத்தகைய மதிப்புகள் ஒற்றை அல்லது இரட்டை மேற்கோள்களில் இணைக்கப்பட்ட சர எழுத்துகளாக குறிப்பிடப்படுகின்றன."ஒரு சரம்" "மற்றொரு சரம்"
பின்சாய்வு எழுத்தைப் பயன்படுத்தி சர மதிப்புகளை பல பகுதிகளாகப் பிரிக்கலாம்.
"A\string"
வரியானது எஸ்கேப் சீக்வென்ஸ்கள் என அழைக்கப்படுவதைக் கொண்டிருக்கலாம், அவை கன்சோலுக்கு வரியை வெளியிடும் போது விளக்கப்படும். எடுத்துக்காட்டாக, வரிசை \n என்பது ஒரு புதிய வரி எழுத்து. அதே மேற்கோள் குறிகளுக்குள் இணைக்கப்பட்ட சரங்களுக்கு மேற்கோள் குறிகளைச் சேர்க்க பின்சாய்வு எழுத்து பயன்படுத்தப்படலாம். \ உடன் மேற்கோள் எழுத்தை எஸ்கேப் செய்வதால் கணினி அதை ஒரு சிறப்பு எழுத்தாக கருதாது.
"நான் ஒரு டெவலப்பர்"
+ ஆபரேட்டரைப் பயன்படுத்தி சரங்களை இணைக்கலாம்.
"A" + "சரம்"
டெம்ப்ளேட் எழுத்துக்கள் ES2015 இல், டெம்ப்ளேட் லிட்டரல்கள் அல்லது டெம்ப்ளேட் சரங்கள் என்று அழைக்கப்படும். அவை பின்கோட்டுகளில் (`) இணைக்கப்பட்ட சரங்கள் மற்றும் சில சுவாரஸ்யமான பண்புகளைக் கொண்டுள்ளன.`ஒரு சரம்`
எடுத்துக்காட்டாக, ஜாவாஸ்கிரிப்ட் வெளிப்பாடுகளை டெம்ப்ளேட் எழுத்துக்களாக மதிப்பிடுவதன் விளைவாக வரும் சில மதிப்புகளை நீங்கள் மாற்றலாம்.
`$(ஏதாவது) கொண்ட ஒரு சரம்` `$(ஏதாவது+ஏதாவது) கொண்ட ஒரு சரம்` `$(obj.something())'
பின் மேற்கோள்களைப் பயன்படுத்துவது பல வரிகளில் சரம் எழுத்துகளை எழுதுவதை எளிதாக்குகிறது:
`$(ஏதாவது) கொண்ட ஒரு சரம்`
பூலியன் வகை ஜாவாஸ்கிரிப்ட் பூலியன் மதிப்புகளுடன் பணிபுரியும் போது பயன்படுத்தப்படும் ஒரு ஜோடி ஒதுக்கப்பட்ட சொற்களைக் கொண்டுள்ளது: உண்மை மற்றும் தவறு. ஒப்பீட்டு ஆபரேட்டர்கள், அதாவது == , === ,< , >, உண்மையோ பொய்யோ திரும்பவும் .ஒரு நிரலின் ஓட்டத்தைக் கட்டுப்படுத்த உதவும் if மற்றும் போது போன்ற அறிக்கைகளில் பூலியன் வெளிப்பாடுகள் பயன்படுத்தப்படுகின்றன.
உண்மை அல்லது தவறான மதிப்பு எதிர்பார்க்கப்படும் இடத்தில், உண்மை (உண்மை) அல்லது தவறான (தவறு) என மொழியால் தானாகவே மதிப்பிடப்படும் பிற மதிப்புகளை நீங்கள் பயன்படுத்தலாம் என்பதைக் கவனத்தில் கொள்ள வேண்டும்.
குறிப்பாக, பின்வருபவை தவறான மதிப்புகள்:
0 -0 NaN வரையறுக்கப்படாத பூஜ்ய "" //வெற்று சரம்
மீதமுள்ள மதிப்புகள் உண்மை.
ரிட்டர்ன் கீவார்டைப் பயன்படுத்தி வெளிப்படையாகத் திருப்பியளிக்கப்படாத செயல்பாடுகளிலிருந்து இந்த மதிப்பு தானாகவே திரும்பும். ஒரு செயல்பாடு அழைக்கப்படும் போது குறிப்பிடப்படாத அளவுருவை எடுத்துக் கொண்டால், அது வரையறுக்கப்படாததாக அமைக்கப்படும்.
வரையறுக்கப்படாத மதிப்பைச் சரிபார்க்க, பின்வரும் கட்டுமானத்தைப் பயன்படுத்தலாம்.
வகை மாறி === "வரையறுக்கப்படவில்லை"
▍ பொருள்கள் அனைத்து பழமையான மதிப்புகள் பொருள் வகை. நாங்கள் செயல்பாடுகள், வரிசைகள், "பொருள்கள்" என்று அழைப்பது மற்றும் பல நிறுவனங்களைப் பற்றி பேசுகிறோம். இந்த தரவு வகைகள் அனைத்தும் பொருளின் வகையை அடிப்படையாகக் கொண்டவை, மேலும் அவை ஒன்றுக்கொன்று பல வழிகளில் வேறுபட்டாலும், அவற்றிற்கும் பொதுவானது அதிகம்.வெளிப்பாடுகள் வெளிப்பாடுகள் என்பது குறியீட்டுத் துண்டுகள் ஆகும். . JavaScript இல் பல வகை வெளிப்பாடுகள் உள்ளன எண்கணித வெளிப்பாடுகள் இந்த வகை எண்களை மதிப்பிடும் வெளிப்பாடுகளை உள்ளடக்கியது.1 / 2 i++ i -= 2 i * 2
சரம் வெளிப்பாடுகள் அத்தகைய வெளிப்பாடுகளை மதிப்பிடுவதன் விளைவாக சரங்கள் ஆகும்."A " + "string" "A" += "string"
முதன்மை வெளிப்பாடுகள் எழுத்துகள், மாறிலிகள் மற்றும் அடையாளங்காட்டிகளுக்கான குறிப்புகள் இந்த வகைக்குள் அடங்கும்.2 0.02 "ஏதோ" உண்மை தவறு இது //செயல்படுத்தும் சூழல், தற்போதைய பொருளின் குறிப்பு வரையறுக்கப்படாத i //இங்கு நான் ஒரு மாறி அல்லது மாறிலி
இதில் சில ஜாவாஸ்கிரிப்ட் முக்கிய வார்த்தைகள் மற்றும் கட்டுமானங்களும் அடங்கும்.
செயல்பாட்டு வகுப்பு செயல்பாடு* //மகசூல் ஜெனரேட்டர் //ஜெனரேட்டர் விளைச்சலை இடைநிறுத்த/மீண்டும் தொடங்குவதற்கான கட்டளை* //மற்றொரு ஐட்டரேட்டர் அல்லது ஜெனரேட்டர் ஒத்திசைவு செயல்பாட்டிற்கான பிரதிநிதித்துவம்* //ஒத்திசைவற்ற செயல்பாட்டு வெளிப்பாடு காத்திருக்கிறது //ஒரு ஒத்திசைவற்ற செயல்பாடு / வடிவத்தை செயல்படுத்த காத்திருக்கும் அமைப்பு /நான் // வழக்கமான வெளிப்பாடு() //குழுவாக்கம்
வரிசைகள் மற்றும் பொருள்களுக்கான துவக்க வெளிப்பாடுகள் //அரே லிட்டரல் () //ஆப்ஜெக்ட் லிட்டரல் (a: 1, b: 2) (a: (b: 1)) தருக்க வெளிப்பாடுகள் தருக்க வெளிப்பாடுகள் தருக்க ஆபரேட்டர்கள், அவற்றின் கணக்கீட்டின் விளைவாக தருக்க மதிப்புகள்.A && b a || பி!ஏ
சொத்து அணுகல் வெளிப்பாடுகள் இந்த வெளிப்பாடுகள் பொருள்களின் பண்புகள் மற்றும் முறைகளை அணுக உங்களை அனுமதிக்கின்றன.Object.property //ஒரு பொருள் பொருள் பொருளின் ஒரு சொத்து (அல்லது முறை)
பொருள் உருவாக்க வெளிப்பாடுகள் புதிய பொருள்() புதிய a(1) புதிய MyRectangle("பெயர்", 2, (a: 4)) செயல்பாடு அறிவிப்பு வெளிப்பாடுகள் செயல்பாடு() () செயல்பாடு(a, b) ( திரும்ப a * b ) (a, b) => a * b a => a * 2 () => ( return 2 ) அழைப்பு வெளிப்பாடுகள் செயல்பாடுகள் அல்லது பொருள்களின் முறைகளை அழைக்க இத்தகைய வெளிப்பாடுகள் பயன்படுத்தப்படுகின்றன.A.x(2) window.resize()
பொருள்களுடன் பணிபுரிதல், மேலே உள்ள பொருள்களை நாம் ஏற்கனவே சந்தித்துள்ளோம், பொருள் எழுத்துக்களைப் பற்றி பேசுகிறோம், அவற்றின் முறைகளை அழைக்கிறோம், அவற்றின் பண்புகளை அணுகுகிறோம். இங்கே நாம் பொருட்களைப் பற்றி இன்னும் விரிவாகப் பேசுவோம், குறிப்பாக, முன்மாதிரி மரபுரிமையின் பொறிமுறையையும் வகுப்பு முக்கிய வார்த்தையின் பயன்பாட்டையும் பார்ப்போம். . பெரும்பாலான பொருள் சார்ந்த மொழிகள் வர்க்க அடிப்படையிலான பரம்பரை மாதிரியைப் பயன்படுத்துகின்றன.ஒவ்வொரு ஜாவாஸ்கிரிப்ட் பொருளுக்கும் ஒரு சிறப்புப் பண்பு உள்ளது (__proto__) அது அதன் முன்மாதிரியான மற்றொரு பொருளைக் குறிக்கிறது. ஒரு பொருள் முன்மாதிரியின் பண்புகள் மற்றும் முறைகளைப் பெறுகிறது.
நாம் ஒரு பொருளைப் பயன்படுத்தி உருவாக்கப்பட்ட ஒரு பொருளைக் கொண்டுள்ளோம் என்று வைத்துக் கொள்வோம்.
கான்ஸ்ட் கார் = ()
அல்லது ஆப்ஜெக்ட் கன்ஸ்ட்ரக்டரைப் பயன்படுத்தி ஒரு பொருளை உருவாக்கினோம்.
கான்ஸ்ட் கார் = புதிய பொருள்()
இந்த நிகழ்வுகளில் ஏதேனும், கார் பொருளின் முன்மாதிரி Object.prototype .
நீங்கள் ஒரு பொருளாக ஒரு வரிசையை உருவாக்கினால், அதன் முன்மாதிரி Array.prototype பொருளாக இருக்கும்.
மாறுபாடு பட்டியல் = //அல்லது const பட்டியல் = புதிய வரிசை()
இதை நீங்கள் பின்வருமாறு சரிபார்க்கலாம்.
Car.__proto__ == Object.prototype //true car.__proto__ == புதிய பொருள்().__proto__ //true list == புதிய வரிசை().__proto__ //உண்மை
இங்கே நாங்கள் __proto__ பண்புகளைப் பயன்படுத்தினோம்; இது டெவலப்பருக்குக் கிடைக்க வேண்டியதில்லை, ஆனால் அதை வழக்கமாக அணுகலாம். அதிகம் என்பதை கவனத்தில் கொள்ள வேண்டும் நம்பகமான வழியில்ஒரு பொருளின் முன்மாதிரியைப் பெறுவதற்கு getPrototypeOf() முறை உலகளாவியது பொருள்.
Object.getPrototypeOf(புதிய பொருள்())
ஒரு முன்மாதிரியின் அனைத்து பண்புகள் மற்றும் முறைகள் அந்த முன்மாதிரியைக் கொண்ட பொருளுக்குக் கிடைக்கும். இங்கே, எடுத்துக்காட்டாக, ஒரு வரிசைக்கு அவர்களின் பட்டியல் எப்படி இருக்கும்.
வரிசை குறிப்பு
அனைத்து பொருட்களுக்கும் அடிப்படை முன்மாதிரி Object.prototype ஆகும்.
Array.prototype.__proto__ == Object.prototype
Object.prototypeக்கு முன்மாதிரி இல்லை.
நாம் மேலே பார்த்தது ஒரு முன்மாதிரி சங்கிலியின் உதாரணம்.
நீங்கள் ஒரு பொருளின் சொத்து அல்லது முறையை அணுக முயற்சிக்கும்போது, அந்தப் பொருளுக்கு அத்தகைய பண்பு அல்லது முறை இல்லை என்றால், அவற்றின் தேடல் அதன் முன்மாதிரியில் செய்யப்படுகிறது, பின்னர் முன்மாதிரியின் முன்மாதிரியில், மற்றும் விரும்பிய சொத்து கண்டுபிடிக்கப்படும் வரை, அல்லது முன்மாதிரிகளின் சங்கிலி முடிவடையாது.
புதிய ஆபரேட்டரைப் பயன்படுத்தி பொருள்களை உருவாக்குவது மற்றும் பொருள் அல்லது வரிசை எழுத்துக்களைப் பயன்படுத்துவதைத் தவிர, Object.create() முறையைப் பயன்படுத்தி ஒரு பொருளின் நிகழ்வை உருவாக்கலாம். இந்த முறைக்கு அனுப்பப்பட்ட முதல் வாதம் அது உருவாக்கும் பொருளின் முன்மாதிரியாக இருக்கும் ஒரு பொருளாகும்.
கான்ஸ்ட் கார் = Object.create(Object.prototype)
isPrototypeOf() முறையைப் பயன்படுத்தி ஒரு பொருள் மற்றொரு பொருளின் முன்மாதிரி சங்கிலியின் ஒரு பகுதியாக உள்ளதா என்பதை நீங்கள் சரிபார்க்கலாம்.
கான்ஸ்ட் பட்டியல் = Array.prototype.isPrototypeOf(list)
கன்ஸ்ட்ரக்டர் செயல்பாடுகள் மேலே, நாங்கள் ஏற்கனவே மொழியில் உள்ள கன்ஸ்ட்ரக்டர் செயல்பாடுகளைப் பயன்படுத்தி புதிய பொருட்களை உருவாக்கினோம் (அவற்றை அழைக்கும்போது புதிய முக்கிய வார்த்தை பயன்படுத்தப்படுகிறது). அத்தகைய செயல்பாடுகளை நீங்களே உருவாக்கலாம். ஒரு உதாரணத்தைப் பார்ப்போம்.செயல்பாடு நபர்(பெயர்) ( this.name = பெயர் ) Person.prototype.hello = செயல்பாடு() ( console.log(this.name) ) நபர் = புதிய நபர்("Flavio") person.hello() console.log( Person.prototype.isPrototypeOf(person))
இங்கே நாம் ஒரு கட்டமைப்பாளர் செயல்பாட்டை உருவாக்குகிறோம். அழைக்கப்பட்டால், அது உருவாக்கப்படுகிறது புதிய பொருள், இது விசையால் குறிக்கப்படுகிறது இந்த வார்த்தைகட்டமைப்பாளரின் உடலில். இந்த பொருளுக்கு ஒரு பெயர் சொத்தை சேர்த்து, கட்டமைப்பாளருக்கு அனுப்பப்பட்டதை எழுதுகிறோம். இந்த பொருள் கன்ஸ்ட்ரக்டரிடமிருந்து தானாகவே திரும்பும். கன்ஸ்ட்ரக்டர் செயல்பாட்டைப் பயன்படுத்தி, நீங்கள் பல பொருள்களை உருவாக்கலாம், அதன் பெயர் பண்புகள் உருவாக்கப்படும்போது கன்ஸ்ட்ரக்டருக்கு அனுப்பப்பட்டவைகளைக் கொண்டிருக்கும்.
கன்ஸ்ட்ரக்டரை உருவாக்கிய பிறகு, அதன் முன்மாதிரிக்கு ஒரு செயல்பாட்டைச் சேர்ப்போம், இது இந்தச் செயல்பாட்டைப் பயன்படுத்தி உருவாக்கப்பட்ட பொருளின் பெயர் சொத்தின் மதிப்பை கன்சோலில் அச்சிடும். இந்த கன்ஸ்ட்ரக்டரைப் பயன்படுத்தி உருவாக்கப்பட்ட அனைத்து பொருட்களும் ஒரே மாதிரியைக் கொண்டிருக்கும், எனவே ஒரே ஹலோ() செயல்பாட்டைப் பயன்படுத்துகின்றன. நபர் வகையின் மற்றொரு பொருளை உருவாக்கி அதன் hello() செயல்பாட்டை ஏற்கனவே எடுத்துக்காட்டில் உள்ள பொருளின் செயல்பாட்டுடன் ஒப்பிடுவதன் மூலம் இதை எளிதாகச் சரிபார்க்கலாம் (இந்த விஷயத்தில், செயல்பாட்டின் பெயர் அடைப்புக்குறி இல்லாமல் எழுதப்பட்டுள்ளது).
▍வகுப்புகள் ES6 தரநிலையில், ஜாவாஸ்கிரிப்ட் "வகுப்பு" என்ற கருத்தை அறிமுகப்படுத்தியது.முன்பு, ஜாவாஸ்கிரிப்ட் மேலே விவரிக்கப்பட்ட முன்மாதிரி மரபுவழி பொறிமுறையை மட்டுமே பயன்படுத்த முடியும். பிற மொழிகளில் இருந்து JS க்கு வந்த புரோகிராமர்களுக்கு இந்த வழிமுறை வழக்கத்திற்கு மாறானதாகத் தோன்றியது. எனவே, மொழியில் வகுப்புகள் தோன்றின, இது சாராம்சத்தில், முன்மாதிரி மரபுவழி பொறிமுறைக்கான "தொடக்கிய சர்க்கரை" ஆகும். அதாவது, உருவாக்கப்பட்ட பொருள்கள் பாரம்பரிய வழி, மற்றும் வகுப்புகளைப் பயன்படுத்தி உருவாக்கப்பட்ட பொருள்கள் முன்மாதிரிகளைக் கொண்டுள்ளன.
வகுப்பு பிரகடனம் இது ஒரு வகுப்பு அறிவிப்பு போல் இருக்கும்.வகுப்பு நபர் (கட்டமைப்பாளர்(பெயர்) ( this.name = name ) hello() ("Hello, I am" + this.name + "") )
ஒரு வகுப்பில் ஒரு அடையாளங்காட்டி உள்ளது, இது புதிய ClassIdentifier() கட்டமைப்பைப் பயன்படுத்தி புதிய பொருட்களை உருவாக்க பயன்படுகிறது.
ஒரு புதிய பொருள் உருவாக்கப்படும் போது, கன்ஸ்ட்ரக்டர் முறை அழைக்கப்படுகிறது மற்றும் அதற்கு அளவுருக்கள் அனுப்பப்படும்.
நீங்கள் ஒரு வகுப்பில் முறைகளை அறிவிக்கலாம். எங்கள் விஷயத்தில், hello() என்பது வகுப்பின் அடிப்படையில் உருவாக்கப்பட்ட அனைத்து பொருள்களாலும் அழைக்கப்படும் ஒரு முறையாகும். நபர் வகுப்பைப் பயன்படுத்தி ஒரு புதிய பொருளை உருவாக்குவது இப்படித்தான் இருக்கும்.
கான்ஸ்ட் ஃபிளேவியோ = புதிய நபர்("ஃப்ளேவியோ") flavio.hello()
வகுப்பு அடிப்படையிலான பரம்பரை வகுப்புகள் மற்ற வகுப்புகளை நீட்டிக்க முடியும். அத்தகைய வகுப்புகளிலிருந்து உருவாக்கப்பட்ட பொருள்கள் அசல் வகுப்பின் முறைகள் மற்றும் நீட்டிக்கப்பட்ட வகுப்பில் குறிப்பிடப்பட்ட முறைகள் இரண்டையும் பெறுகின்றன.மற்றொரு வகுப்பை விரிவுபடுத்தும் ஒரு வகுப்பு (அந்த வகுப்பின் துணைப்பிரிவு) பெற்றோர் வகுப்பின் பெயரைப் போன்ற ஒரு முறையைக் கொண்டிருந்தால், அந்த முறை அசல் ஒன்றை விட முன்னுரிமை பெறுகிறது.
வகுப்பு புரோகிராமர் நபரை நீட்டிக்கிறார் ( hello() ( return super.hello() + " I am a programmer." ) ) const flavio = new Programmer("Flavio") flavio.hello()
மேலே உள்ள எடுத்துக்காட்டில் உள்ள hello() முறையை அழைப்பது Hello, I am Flavio என்ற சரத்தை வழங்கும். நான் ஒரு புரோகிராமர்.
வகுப்புகள் மாறிகள் (பண்புகள்) இருப்பதை வழங்காது; வகுப்புகளைப் பயன்படுத்தி உருவாக்கப்பட்ட பொருட்களின் பண்புகள் கட்டமைப்பாளரில் கட்டமைக்கப்பட வேண்டும்.
ஒரு வகுப்பிற்குள், சூப்பர் கீவேர்டைப் பயன்படுத்தி பெற்றோர் வகுப்பை அணுகலாம்.
நிலையான முறைகள் வகுப்பில் விவரிக்கப்பட்டுள்ள முறைகள் வகுப்பிலிருந்து உருவாக்கப்பட்ட பொருட்களை அணுகுவதன் மூலம் அழைக்கப்படலாம், ஆனால் வகுப்பை அணுகுவதன் மூலம் அல்ல. வகுப்பை நேரடியாக அணுகுவதன் மூலம் நிலையான முறைகளை அழைக்கலாம்.தனிப்பட்ட முறைகள் JavaScript ஆனது தனிப்பட்ட முறைகளை அறிவிக்க உங்களை அனுமதிக்கும் உள்ளமைக்கப்பட்ட பொறிமுறையைக் கொண்டிருக்கவில்லை. எடுத்துக்காட்டாக, மூடல்களைப் பயன்படுத்துவதன் மூலம் இந்த வரம்பைக் கடக்க முடியும், பெறுபவர்கள் மற்றும் செட்டர்கள், பெறு அல்லது செட் முக்கிய வார்த்தைகளுடன் முன்னொட்டாக ஒரு வகுப்பில் உள்ள முறைகளை நீங்கள் வரையறுக்கலாம். வகுப்பின் அடிப்படையில் உருவாக்கப்பட்ட பொருட்களின் பண்புகளுக்கான அணுகலைக் கட்டுப்படுத்தப் பயன்படும் செயல்பாடுகள் - பெறுபவர்கள் மற்றும் செட்டர்கள் என்று அழைக்கப்படுவதை உருவாக்க இது உங்களை அனுமதிக்கிறது. நீங்கள் ஒரு போலி சொத்தின் மதிப்பைப் படிக்க முயற்சிக்கும் போது பெறுபவர் அழைக்கப்படுகிறது, மேலும் புதிய மதிப்பை எழுத முயற்சிக்கும்போது செட்டர் அழைக்கப்படுகிறது.வகுப்பு நபர் (கட்டமைப்பாளர் (பெயர்) ( this.userName = பெயர் ) பெயர் (மதிப்பு) அமைக்கவும் ( this.userName = மதிப்பு ) பெயரைப் பெறவும் () ( this.userName ) )
சுருக்கம் இந்த உள்ளடக்கத்தில் மாறிகள், தரவு வகைகள், வெளிப்பாடுகள் மற்றும் ஜாவாஸ்கிரிப்டில் உள்ள பொருட்களுடன் வேலை செய்வது பற்றி பேசினோம். எங்கள் அடுத்த பொருளின் தலைப்பு செயல்பாடுகளாக இருக்கும்.அன்பான வாசகர்களே! நீங்கள் நீண்ட காலமாக JS இல் எழுதிக்கொண்டிருந்தால், மொழியின் வர்க்க முக்கிய வார்த்தையின் தோற்றத்தைப் பற்றி நீங்கள் எப்படி உணருகிறீர்கள் என்பதை எங்களிடம் கூறுங்கள்.
இந்த டுடோரியலில் நாம் ஒரு மிக முக்கியமான கருத்தை அறிமுகப்படுத்துவோம் - ஜாவாஸ்கிரிப்ட் தரவு வகைகள். இந்த கருத்தை நீங்கள் உன்னிப்பாக கவனிக்க பரிந்துரைக்கிறோம் - ஆரம்பத்தில் இருந்தே நீங்கள் அதை புரிந்து கொள்ளவில்லை என்றால், நீங்கள் உருவாக்கிய நிரலின் விசித்திரமான நடத்தையை நீங்கள் அடிக்கடி சமாளிக்க வேண்டியிருக்கும்.
டைனமிக் தட்டச்சுநடந்து கொண்டிருக்கிறது கணினி நிரல்கள்வெவ்வேறு மதிப்புகளைக் கையாளவும், அவை ஒவ்வொன்றும் ஒரு நிரலாக்க மொழியில் செயலாக்கப்படலாம் மற்றும் ஒரு குறிப்பிட்ட தரவு வகையைச் சேர்ந்தவை.
ஜாவாஸ்கிரிப்ட்டில், தரவு வகைகளை இரண்டு வகைகளாகப் பிரிக்கலாம்: எளிய (முதன்மை என்றும் அழைக்கப்படுகிறது) வகைகள் மற்றும் கூட்டு (குறிப்பு அல்லது பொருள் என்றும் அழைக்கப்படுகிறது).
ஜாவாஸ்கிரிப்ட் என்பது பலவீனமாக தட்டச்சு செய்யப்பட்ட அல்லது டைனமிக் நிரலாக்க மொழியாகும், இது நிரல் செயலாக்கத்தின் போது தரவு வகைகளை வரையறுக்கவும், பாகுபடுத்தவும் மற்றும் தொகுக்கவும் அனுமதிக்கிறது. இதன் பொருள் நீங்கள் மாறியின் வகையை முன்கூட்டியே வரையறுக்க வேண்டியதில்லை. நிரல் செயல்பாட்டின் போது வகை தானாகவே தீர்மானிக்கப்படும்.
எனவே, நிரலின் வெவ்வேறு பகுதிகளில், ஒரே மாறி வெவ்வேறு வகைகளின் மதிப்புகளைப் பெறலாம்:
ECMAScript® தரநிலை பின்வரும் தரவு வகைகளை வரையறுக்கிறது:
- எளிய (முதன்மை என்றும் அழைக்கப்படுகிறது) வகைகள்:
- பூலியன் - இரண்டு சாத்தியமான மதிப்புகளை எடுக்கலாம், சில நேரங்களில் உண்மை மற்றும் தவறு என்று அழைக்கப்படுகிறது;
- null - மதிப்பு பூஜ்யமானது, பொதுவாக வேண்டுமென்றே, இல்லாத அல்லது தவறான பொருள் அல்லது முகவரியைக் குறிக்கும் குறிப்பைக் குறிக்கிறது;
- வரையறுக்கப்படாத - வரையறுக்கப்படாத மதிப்புடன் துவக்கப்பட்ட முன் வரையறுக்கப்பட்ட உலகளாவிய மாறியைக் குறிக்கிறது;
- எண் (ஆங்கில எண்) - 64-பிட் இரட்டை துல்லியமான மிதக்கும் புள்ளி எண்ணின் வடிவத்தில் உள்ள எண் தரவு வகை;
- சரம் (ஆங்கில சரம்) - உரையைக் குறிக்கப் பயன்படுத்தப்படும் எழுத்துகளின் வரிசை;
- சின்னம் (eng. சின்னம்) என்பது ஒரு தரவு வகையாகும், இவற்றின் நிகழ்வுகள் தனித்துவமானவை மற்றும் மாறாதவை. (ECMAScript 6 இல் புதியது).
- ஒரு பொருள் என்பது பெயரிடப்பட்ட மதிப்புகளின் தொகுப்பாகும், பொதுவாக ஒரு பொருளின் பண்புகள் என்று அழைக்கப்படுகிறது.
ஒவ்வொரு தரவு வகையையும் பார்ப்பதற்கு முன், முதலில் ஆபரேட்டர் வகையைப் பற்றி அறிந்து கொள்வோம். ஆபரேட்டர் வகையானது மாறியின் தரவு வகையை விவரிக்கும் சரத்தை வழங்குகிறது.
பின்வரும் எடுத்துக்காட்டைப் பயன்படுத்தி இது எவ்வாறு செயல்படுகிறது என்பதை விளக்குவோம்:
எடுத்துக்காட்டு ஸ்கிரிப்ட் மாறிகளை அறிவிக்கிறது, அவற்றை துவக்குகிறது (மதிப்புகளை ஒதுக்குகிறது), பின்னர் ஒவ்வொரு மாறியின் வகையையும் அச்சிடுகிறது.
பழமையான மற்றும் கலப்பு தரவு வகைகளுக்கு இடையிலான வேறுபாடு அவற்றின் மதிப்புகள் நகலெடுக்கப்படும் போது ஏற்படுகிறது.
ஒரு மாறிக்கு ஒரு எளிய வகையின் மதிப்பை ஒதுக்கும்போது, அந்த மதிப்பு (உதாரணமாக, ஒரு எண்) மாறிக்கு எழுதப்படும். ஒரு எளிய வகையின் மாறியை மற்றொன்றுக்கு நாம் ஒதுக்கும்போது, அது மதிப்பை நகலெடுக்கிறது. இதன் விளைவாக, ஒவ்வொரு மாறிக்கும் அதன் சொந்த மதிப்பு இருக்கும் மற்றும் மாறிகளில் ஒன்றில் ஏற்படும் மாற்றங்கள் மற்ற மாறியின் மதிப்பை எந்த வகையிலும் பாதிக்காது:
ஒரு மாறிக்கு ஒரு கூட்டு (குறிப்பு) வகையின் மதிப்பை நாம் ஒதுக்கும்போது, மதிப்புக்கான குறிப்பு (ஒரு பொருளின் குறிப்பு) மாறிக்கு எழுதப்படுகிறது. ஒரு மாறியை (இதன் மதிப்பு ஒரு கலப்பு மதிப்புக்கான குறிப்பைக் கொண்டுள்ளது) மற்றொரு மாறிக்கு ஒதுக்கும்போது, கூட்டு மதிப்பின் குறிப்பு நகலெடுக்கப்படும். இதன் விளைவாக, இரண்டு மாறிகளும் ஒரே கலப்பு மதிப்பைக் குறிக்கின்றன, மேலும் ஒரு மாறியின் மதிப்பில் ஏற்படும் மாற்றங்கள் மற்ற மாறியைப் பாதிக்கும்:
பழமையான வகைகள்ஜாவாஸ்கிரிப்டில் உள்ள அனைத்து தரவு வகைகளும், பொருள்களைத் தவிர, மாறாதவை அல்லது மாறாதவை. இதன் பொருள் அவற்றின் மதிப்புகளை மாற்ற முடியாது, ஆனால் புதிய, வேறுபட்ட மதிப்புடன் மட்டுமே மேலெழுதப்படும். எடுத்துக்காட்டாக, சரங்களை எழுத்தின் அடிப்படையில் சரிசெய்ய முடியாது - அவை முழுமையாக மீண்டும் எழுதப்படும். அத்தகைய வகைகளின் மதிப்புகள் "பழமையானவை" என்று அழைக்கப்படுகின்றன.
ஒரு நிரல் செயல்படக்கூடிய எளிமையான தரவுகள் லிட்டரல்கள் எனப்படும். எழுத்துக்கள் என்பது ஜாவாஸ்கிரிப்டில் மதிப்புகளைக் குறிக்கப் பயன்படுத்தப்படும் எண்கள் அல்லது சரங்கள். வழங்கப்பட்ட தகவல்கள் மிகவும் மாறுபட்டதாக இருக்கலாம், எனவே அர்த்தங்கள் மாறுபடும் பல்வேறு வகையான. ஜாவாஸ்கிரிப்டில் உள்ள எளிய தரவு வகைகள் அடிப்படை தரவு வகைகள் என்று அழைக்கப்படுகின்றன: எண்கள், சரங்கள் மற்றும் பூலியன்கள். அவை அனைத்தும் "பழமையானவை" என வகைப்படுத்தப்பட்டுள்ளன.
பூலியன் (தர்க்கரீதியான) வகை "பூலியன்"தர்க்கரீதியான அல்லது பூலியன் மதிப்புகள் (அவற்றின் கண்டுபிடிப்பாளரின் பெயருக்குப் பிறகு - பூலியன்), இரண்டு மதிப்புகளில் ஒன்றை மட்டுமே கொண்டிருக்க முடியும்: உண்மை (உண்மை) அல்லது தவறான (தவறு). மதிப்புகள் உண்மைஅல்லது தவறானது பொதுவாக ஒப்பீடு அல்லது தருக்க செயல்பாடுகளில் தோன்றும்.
பின்வரும் நிரல் ஒரு பூலியன் மாறியை உருவாக்கி அதன் மதிப்பை if/else அறிக்கையைப் பயன்படுத்தி சோதிக்கிறது:
எந்த வெளிப்பாட்டையும் ஒப்பீட்டு வெளிப்பாடாகப் பயன்படுத்தலாம். 0, பூஜ்ய, வரையறுக்கப்படாத அல்லது வெற்று சரத்தை வழங்கும் எந்த வெளிப்பாடும் தவறானதாக விளக்கப்படும். வேறு எந்த மதிப்பையும் குறிப்பிடும் வெளிப்பாடு உண்மை என விளக்கப்படுகிறது.
குறிப்பு: பூலியன் மதிப்புகளை எழுதும் போது, அவை மேற்கோள்களில் இணைக்கப்படவில்லை: var myVar = true;
அதே நேரத்தில், var myVar = "true" என அறிவிப்பது ஒரு சரம் மாறியை உருவாக்குகிறது.
ஜாவாஸ்கிரிப்ட்டில், முழு எண் மற்றும் மிதக்கும் புள்ளி எண் ஆகியவற்றுக்கு இடையே வேறுபாடு இல்லை - அடிப்படையில், ஜாவாஸ்கிரிப்ட் அனைத்து எண்களையும் மிதக்கும் புள்ளி மதிப்பாகக் குறிக்கிறது.
ஜாவாஸ்கிரிப்ட் எண்களைக் குறிக்க IEEE-754 தரத்தால் வரையறுக்கப்பட்ட 64-பிட் வடிவமைப்பைப் பயன்படுத்துகிறது. இந்த வடிவம் ±1.7976931348623157 × 10308 முதல் ±5 × 10 -324 வரையிலான எண்களைக் குறிக்கும் திறன் கொண்டது.
நிரல் குறியீட்டில் நேரடியாகக் காணப்படும் ஒரு எண், எண் எழுத்துக்குறி எனப்படும். தசம முழு எண் எழுத்துகளுக்கு கூடுதலாக, ஜாவாஸ்கிரிப்ட் ஹெக்ஸாடெசிமல் மதிப்புகளை அங்கீகரிக்கிறது.
ஹெக்ஸாடெசிமல் எண்கள் 0 முதல் 9 வரையிலான எண்களின் வரிசையையும், a முதல் f வரையிலான எழுத்துக்களையும் சேர்க்கலாம், அவை எழுத்து வரிசை "0x" உடன் தொடங்க வேண்டும்.
Var a = 255; var b = 0xFF; // எண் 255 ஹெக்ஸாடெசிமல் குறியீட்டில்
கூடுதலாக, ஜாவாஸ்கிரிப்ட் சிறப்பு எண் மதிப்புகளைக் கொண்டுள்ளது:
- NaN (எண் அல்லது கணக்கீட்டு பிழை அல்ல). சரங்கள் அல்லது வரையறுக்கப்படாத மதிப்பு போன்ற தவறான தரவுகளின் தவறான கணிதச் செயல்பாட்டின் விளைவாகும்.
- முடிவிலி (நேர்மறை முடிவிலி). நேர்மறை எண் ஜாவாஸ்கிரிப்டில் குறிப்பிட முடியாத அளவுக்கு அதிகமாக இருக்கும் போது பயன்படுத்தப்படுகிறது.
- -முடிவிலி (எதிர்மறை முடிவிலி). எதிர்மறை எண் ஜாவாஸ்கிரிப்ட்டில் குறிப்பிட முடியாத அளவுக்கு அதிகமாக இருக்கும் போது பயன்படுத்தப்படுகிறது.
- ±0 (நேர்மறை மற்றும் எதிர்மறை 0). ஜாவாஸ்கிரிப்ட் நேர்மறை மற்றும் எதிர்மறை பூஜ்ஜியத்தை வேறுபடுத்துகிறது.
ஒரு சரம் வகை என்பது 16-பிட் மதிப்புகளின் மாறாத, வரிசைப்படுத்தப்பட்ட வரிசையாகும், இவை ஒவ்வொன்றும் யூனிகோட் எழுத்தைக் குறிக்கும் (எழுத்துக்கள், எண்கள், நிறுத்தற்குறிகள், சிறப்பு எழுத்துகள் மற்றும் இடைவெளிகள்). கோடுகள் காலியாக இருக்கலாம் அல்லது ஒன்று அல்லது அதற்கு மேற்பட்ட எழுத்துக்களைக் கொண்டிருக்கலாம். இரட்டை (") அல்லது ஒற்றை (") மேற்கோள்களைப் பயன்படுத்தி சரங்கள் உருவாக்கப்படுகின்றன. ஒரு ஜோடி ஒற்றை மேற்கோள்களால் பிரிக்கப்பட்ட ஒரு சரம் இரட்டை மேற்கோள்களைப் பயன்படுத்தலாம், மாறாக, ஒரு ஜோடி இரட்டை மேற்கோள்களால் இணைக்கப்பட்ட ஒரு சரத்திற்குள் ஒற்றை மேற்கோள்களைப் பயன்படுத்தலாம்:
ஜாவாஸ்கிரிப்ட்டில், இரட்டை மற்றும் ஒற்றை மேற்கோள்களுக்கு இடையில் எந்த வித்தியாசமும் இல்லை, ஆனால் ஒரு சரத்தின் தொடக்கத்திலும் முடிவிலும் உள்ள மேற்கோள்கள் வேறுபட்டதாக இருக்கக்கூடாது. எடுத்துக்காட்டாக, இது போன்ற ஒரு வெளிப்பாடு தொடரியல் பிழையை ஏற்படுத்தும்:
var firstName = "அதிகபட்சம்"; //தொடரியல் பிழை - வெவ்வேறு மேற்கோள்கள்
குறிப்பு: ஜாவாஸ்கிரிப்டில் C, C++ மற்றும் Java இல் உள்ள சார் போன்ற சிறப்பு ஒற்றை எழுத்து தரவு வகை இல்லை. ஒற்றை எழுத்து அலகு நீளத்தின் சரத்தால் குறிக்கப்படுகிறது.
பூஜ்ய தரவு வகை பூஜ்ய வகை ஒரு சிறப்பு மதிப்பைக் கொண்டுள்ளது—பூஜ்யம்.பூஜ்ய முக்கிய சொல்லை ஒரு செயல்பாடாகவோ அல்லது மாறி பெயராகவோ பயன்படுத்த முடியாது. மதிப்பு பூஜ்யம் என்பது ஒரு "வெற்று" பொருளின் குறிப்பு மற்றும் ஒரு சிறப்பு நோக்கத்தைக் கொண்டுள்ளது - இது வழக்கமாக ஒரு மாறியைத் தொடங்கப் பயன்படுகிறது, அது பின்னர் ஒரு மதிப்பை ஒதுக்கும்.
பூஜ்ய மதிப்பிற்கான ஆபரேட்டர் வகை "பொருள்" சரத்தை வழங்குகிறது, இது பூஜ்ய மதிப்பு ஒரு சிறப்பு "வெற்று" பொருள் என்பதைக் குறிக்கிறது.
வரையறுக்கப்படாத தரவு வகைவரையறுக்கப்படாத வகை அதன் சொந்த வகையை உருவாக்குகிறது, இதில் ஒரு சிறப்பு மதிப்பு உள்ளது - வரையறுக்கப்படாதது. இது var ஆபரேட்டரைப் பயன்படுத்தி அறிவிக்கப்பட்ட மாறியின் மதிப்பு, ஆனால் துவக்கப்படவில்லை:
மதிப்பு, இல்லாத பொருள் சொத்து அல்லது வரிசை உறுப்பு ஆகியவற்றை ஒதுக்காத மாறியை அணுகும்போது வரையறுக்கப்படாத மதிப்பு வழங்கப்படும்.
வரையறுக்கப்படாத மதிப்பைக் கொண்ட மாறி, வரையறுக்கப்படாத மாறியிலிருந்து வேறுபட்டது என்பதைக் கவனத்தில் கொள்ள வேண்டும்:
இந்த எடுத்துக்காட்டில், எச்சரிக்கை() முறை வயது மாறியின் மதிப்பைக் காட்டுகிறது, இது வரையறுக்கப்படவில்லை. இரண்டாவது வழக்கில், அறிவிக்கப்படாத கார் மாறி எச்சரிக்கை() முறைக்கு அனுப்பப்படுகிறது, இது பிழைக்கு வழிவகுக்கிறது.
புதிய புரோகிராமர்களுக்கு பின்வரும் உதாரணம் சற்றே குழப்பமாக இருக்கலாம், ஏனெனில்... தொடங்கப்படாத மற்றும் அறிவிக்கப்படாத மாறி இரண்டிற்கும் ஆபரேட்டர் வகை வரையறுக்கப்படாமல் திரும்பும்:
மேலே உள்ள எடுத்துக்காட்டில், மாறி வயது அறிவிக்கப்பட்டது, ஆனால் அதில் எதுவும் எழுதப்படவில்லை, எனவே அதன் மதிப்பு வரையறுக்கப்படவில்லை. கார் மாறி அறிவிக்கப்படவில்லை - உண்மையில், அது இல்லை. இருப்பினும், வகை இரண்டு நிகழ்வுகளிலும் சரத்தை வரையறுக்கப்படவில்லை. இது சில அர்த்தங்களைத் தருகிறது, ஏனென்றால் தொழில்நுட்ப ரீதியாக அவை முற்றிலும் வேறுபட்டவை என்றாலும், இந்த மாறிகள் எதையும் கொண்டு எந்தச் செயல்பாடுகளையும் செய்ய இயலாது.
குறிப்பு: அறிவிக்கப்பட்ட மாறியை எப்போதும் துவக்குவது பரிந்துரைக்கப்படுகிறது. இந்த வழக்கில், ஆபரேட்டர் வகை வரையறுக்கப்படாமல் திரும்பும் என்பதை நீங்கள் அறிவீர்கள், ஏனெனில் மாறி அறிவிக்கப்படவில்லை, அது துவக்கப்படாததால் அல்ல.
வரையறுக்கப்படாத மதிப்பு பூஜ்யத்திலிருந்து பெறப்பட்டது, எனவே ECMA-262 இல் == சமமான ஆபரேட்டர் அவற்றை சமமாகக் கருதுகிறது:
பூஜ்ய மற்றும் வரையறுக்கப்படாதவை தொடர்புடையவை என்றாலும், அவை வித்தியாசமாகப் பயன்படுத்தப்படுகின்றன. ஒரு மாறிக்கு வரையறுக்கப்படாத மதிப்பை நீங்கள் வெளிப்படையாக ஒதுக்கக்கூடாது, ஆனால் இது பூஜ்யத்திற்கு பொருந்தாது. தேவையான பொருள் கிடைக்கவில்லை என்றால், அதற்கு பதிலாக பூஜ்யத்தைப் பயன்படுத்த வேண்டும். இது ஒரு வெற்றுப் பொருளுக்கு ஒரு சுட்டியாக பூஜ்யத்தை அறிமுகப்படுத்தியதைக் குறிக்கிறது, மேலும் வரையறுக்கப்படாதவற்றிலிருந்து அதன் வேறுபாட்டை வலியுறுத்துகிறது.
ஒரு நிரலில் பூஜ்ய மற்றும் வரையறுக்கப்படாதவற்றை வேறுபடுத்த, நீங்கள் அடையாள ஆபரேட்டரைப் பயன்படுத்தலாம் === :
தரவு வகை சின்னம்ECMAScript பதிப்பு 6 முதல் ஜாவாஸ்கிரிப்ட்டில் ஒரு சின்னம் ஒரு புதிய கூடுதலாகும். ஒரு சின்னம் என்பது தனிப்பட்ட அடையாளங்காட்டிகளை உருவாக்கப் பயன்படும் தனித்துவமான, மாறாத, பழமையான மதிப்பாகும்.
ஒரு குறியீட்டை உருவாக்க, நீங்கள் குறியீட்டு செயல்பாட்டை அழைக்க வேண்டும்:
var mySymbol = சின்னம்();
ஒரு குறியீட்டை வரையறுக்க, நீங்கள் ஆபரேட்டர் வகையைப் பயன்படுத்தலாம்; மதிப்பு ஒரு குறியீடாக இருந்தால், சரம் சின்னம் திரும்பப் பெறப்படும்:
சின்னச் செயல்பாட்டிற்கு விருப்பமான அளவுரு உள்ளது - குறியீட்டை விவரிக்க உதவும் ஒரு சரம்:
சொத்துப் பெயர் ஒரு சரம், எனவே பொருள்கள் சரங்களை மதிப்புகளுடன் தொடர்புபடுத்துவதாகக் கருதலாம். ஒன்றாக, இந்தத் தகவல்கள் முக்கிய மதிப்பு ஜோடிகளை உருவாக்குகின்றன.
IN ஜாவாஸ்கிரிப்ட் பொருள்கள்இரண்டு தொடரியல்களில் ஒன்றைப் பயன்படுத்தி உருவாக்கலாம்:
1. var obj = (); // பொருளைப் பயன்படுத்துதல் 2. var obj = புதிய பொருள்(); // கன்ஸ்ட்ரக்டர் எனப்படும் முறையைப் பயன்படுத்துகிறது
ஒரு பொருளைப் பயன்படுத்தி ஒரு பொருளை உருவாக்குவது வழக்கமான மாறியை வரையறுப்பதில் தொடங்குகிறது. இந்த அறிக்கையின் வலது பக்கம் ஒரு பொருளை எழுத்துப்பூர்வமாக எழுதுகிறது - இது சுருள் பிரேஸ்களில் () இணைக்கப்பட்ட ஜோடிகளின் கமாவால் பிரிக்கப்பட்ட பட்டியல். "பெயர் மதிப்பு", சுருள் பிரேஸ்களில் இணைக்கப்பட்டுள்ளது. சொத்தின் பெயர் மற்றும் மதிப்பு பெருங்குடலால் பிரிக்கப்படுகின்றன:
var cat = ( "கால்கள்": 4, "பெயர்": "Murzik", "நிறம்": "சிவப்பு" )
பொருள்களை உருவாக்குவதற்கான இரண்டாவது வழி Object() கன்ஸ்ட்ரக்டரைப் பயன்படுத்துவதாகும். இந்த வழக்கில், புதிய பொருள்() வெளிப்பாடு முதலில் பயன்படுத்தப்படுகிறது, அதன் விளைவாக வரும் பொருளின் பண்புகள் வரையறுக்கப்பட்டு துவக்கப்படும்:
- ஒரு பொருளைப் பயன்படுத்துதல்
- கன்ஸ்ட்ரக்டர் எனப்படும் முறையைப் பயன்படுத்துகிறது
