வகைகள்

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

மிகவும் பொதுவான வகைகள்:

• Number (எண்): எண்கள் முழு எண்களாக (எ.கா., 1, -5, 100) அல்லது மிதவை-புள்ளி மதிப்புகளாக (எ.கா., 3.14, -2.5, 0.01) இருக்கலாம். JavaScript இல் முழு எண்கள் மற்றும் மிதவை-புள்ளி மதிப்புகளுக்கு தனித்தனி வகை இல்லை; இரண்டையும் எண்களாக கருதுகிறது.
• String (சரம்): சரங்கள் எழுத்துகளின் வரிசைகளாகும், ஒற்றை மேற்கோள்கள் (எ.கா., 'hello') அல்லது இரட்டை மேற்கோள்கள் (எ.கா., "world") மூலம் குறிப்பிடப்படுகின்றன.
• Boolean: Boolean கள் உண்மை அல்லது பொய் மதிப்பை குறிக்கின்றன. அவை true அல்லது false என எழுதலாம் (மேற்கோள்கள் இல்லாமல்).
• Null: null வகை ஒரு null மதிப்பை குறிக்கிறது, இது "மதிப்பு இல்லை" என்று பொருள்படும். அதை null என எழுதலாம் (மேற்கோள்கள் இல்லாமல்).
• Undefined: undefined வகை அமைக்கப்படாத மதிப்பை குறிக்கிறது. ஒரு மாறி அறிவிக்கப்பட்டிருந்தால் ஆனால் மதிப்பு ஒதுக்கப்படவில்லை என்றால், அது undefined.
• Object (பொருள்): ஒரு பொருள் பண்புகளின் தொகுப்பாகும், ஒவ்வொன்றும் பெயர் மற்றும் மதிப்பு கொண்டது. சுருள் பிரேஸ்களைப் ({}) பயன்படுத்தி மற்றும் பெயர்-மதிப்பு ஜோடிகளைப் பயன்படுத்தி பண்புகளை ஒதுக்கி ஒரு பொருளை உருவாக்கலாம்.
• Array (வரிசை): ஒரு வரிசை என்பது உருப்படிகளின் தொகுப்பை வைத்திருக்கக்கூடிய ஒரு சிறப்பு வகையான பொருளாகும். சதுர அடைப்புக்குறிகளைப் ([]) பயன்படுத்தி மற்றும் மதிப்புகளின் பட்டியலை ஒதுக்கி ஒரு வரிசையை உருவாக்கலாம்.
• Function (செயல்பாடு): ஒரு செயல்பாடு என்பது வரையறுக்கப்பட்டு பின்னர் பெயரால் அழைக்கக்கூடிய குறியீட்டின் ஒரு block. செயல்பாடுகள் வாதங்களை (உள்ளீடுகளை) ஏற்கலாம் மற்றும் ஒரு மதிப்பை (வெளியீட்டை) திரும்பப் பெறலாம். function முக்கியசொல்லைப் பயன்படுத்தி ஒரு செயல்பாட்டை உருவாக்கலாம்.

JavaScript ஒரு "loosely typed" மொழியாகும், அதாவது மாறிகள் என்ன வகையான தரவு என்பதை நீங்கள் வெளிப்படையாக அறிவிக்க வேண்டியதில்லை. நீங்கள் ஒரு மாறியை அறிவிக்கிறீர்கள் என்பதை குறிக்க var முக்கியசொல்லை பயன்படுத்த வேண்டும், மேலும் மொழிபெயர்ப்பாளர் சூழலில் இருந்து மற்றும் மேற்கோள்களின் பயன்பாட்டிலிருந்து நீங்கள் என்ன தரவு வகை பயன்படுத்துகிறீர்கள் என்பதை கண்டுபிடிக்கும்.

let age = 30
let name = "Cecilia"
let isMarried = true

assert(typeof age === "number" && typeof name === "string" && typeof isMarried === "boolean");

typeof ஆபரேட்டர் ஒரு மாறியின் தரவு வகைகளை சரிபார்க்க பயன்படுத்தப்படுகிறது.

typeof "John"                 // "string" திரும்பப் பெறுகிறது
typeof 3.14                   // "number" திரும்பப் பெறுகிறது
typeof NaN                    // "number" திரும்பப் பெறுகிறது
typeof false                  // "boolean" திரும்பப் பெறுகிறது
typeof [1,2,3,4]              // "object" திரும்பப் பெறுகிறது
typeof {name:'John', age:34}  // "object" திரும்பப் பெறுகிறது
typeof new Date()             // "object" திரும்பப் பெறுகிறது
typeof function () {}         // "function" திரும்பப் பெறுகிறது
typeof myCar                  // "undefined" திரும்பப் பெறுகிறது *
typeof null                   // "object" திரும்பப் பெறுகிறது

JavaScript இல் பயன்படுத்தப்படும் தரவு வகைகள் மதிப்புகளை கொண்டிருப்பதன் அடிப்படையில் இரண்டு வகைகளாக வேறுபடுத்தலாம்.

மதிப்புகளை கொண்டிருக்கக்கூடிய தரவு வகைகள்:

• string
• number
• boolean
• object
• function

மதிப்புகளை கொண்டிருக்க முடியாத தரவு வகைகள்:

• null
• undefined

ஒரு primitive தரவு மதிப்பு என்பது கூடுதல் பண்புகள் மற்றும் முறைகள் இல்லாத ஒரு எளிய தரவு மதிப்பாகும், மேலும் இது ஒரு பொருள் அல்ல. அவை மாற்ற முடியாதவை, அதாவது அவற்றை மாற்ற முடியாது. 7 primitive தரவு வகைகள் உள்ளன:

• string
• number
• bigint
• boolean
• undefined
• symbol
• null

let person = {
  name: "Mary",
  age: 25,
  isMarried: false
};

assert(typeof person.age === "number" && typeof person.name === "string" && typeof person.isMarried === "boolean");