JavaScript typeof

JavaScript typeof ஆபரேட்டரைக் கற்றுக்கொள்ளுங்கள்

typeof ஆபரேட்டர்

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

முதன்மை தரவு வகைகள்

JavaScript இல், முதன்மை மதிப்பு என்பது பண்புகள் அல்லது முறைகள் இல்லாத ஒற்றை மதிப்பு ஆகும்.

JavaScript க்கு 7 முதன்மை தரவு வகைகள் உள்ளன:

string

number

boolean

bigint

symbol

null

undefined

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

எடுத்துக்காட்டுகள்

typeof "John"         // string ஐ வழங்குகிறது
typeof ("John"+"Doe") // string ஐ வழங்குகிறது  
typeof 3.14           // number ஐ வழங்குகிறது
typeof 33             // number ஐ வழங்குகிறது
typeof (33 + 66)      // number ஐ வழங்குகிறது
typeof true           // boolean ஐ வழங்குகிறது
typeof false          // boolean ஐ வழங்குகிறது
typeof 1234n          // bigint ஐ வழங்குகிறது
typeof Symbol()       // symbol ஐ வழங்குகிறது
typeof x              // undefined ஐ வழங்குகிறது
typeof null           // object ஐ வழங்குகிறது

⚠️ குறிப்பு:

JavaScript இல், null ஒரு முதன்மை மதிப்பு. இருப்பினும், typeof object ஐ வழங்குகிறது. இது JavaScript இல் அறியப்பட்ட ஒரு பிழை மற்றும் வரலாற்று காரணங்களைக் கொண்டுள்ளது.

சிக்கலான தரவு வகைகள்

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

JavaScript க்கு ஒரு சிக்கலான தரவு வகை உள்ளது:

📦 object

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

typeof ஆபரேட்டர் இரண்டு வகைகளை மட்டுமே வழங்குகிறது:

object

பொருட்களுக்கு

function

செயல்பாடுகளுக்கு

எடுத்துக்காட்டு

typeof {name:'John'}   // object ஐ வழங்குகிறது
typeof [1,2,3,4]       // object ஐ வழங்குகிறது
typeof new Map()       // object ஐ வழங்குகிறது  
typeof new Set()       // object ஐ வழங்குகிறது

typeof function (){}   // function ஐ வழங்குகிறது

💡 குறிப்பு:

typeof ஆபரேட்டர் அனைத்து வகையான பொருள்களுக்கும் object ஐ வழங்குகிறது: பொருட்கள், வரிசைகள், தேதிகள், செட்கள், வரைபடங்கள். ஒரு JavaScript பொருள் வரிசையா அல்லது தேதியா என்பதை தீர்மானிக்க typeof ஐப் பயன்படுத்த முடியாது.

ஒரு வரிசையை எவ்வாறு அங்கீகரிப்பது

ஒரு மாறி வரிசையா என்பதை எப்படி அறிவது?

ECMAScript 5 (2009) இதற்காக ஒரு புதிய முறையை வரையறுத்தது: Array.isArray():

// ஒரு வரிசையை உருவாக்கவும்
const fruits = ["apples", "bananas", "oranges"];
Array.isArray(fruits);

instanceof ஆபரேட்டர்

instanceof ஆபரேட்டர், ஒரு பொருள் குறிப்பிட்ட பொருள் வகையின் உதாரணமாக இருந்தால் true ஐ வழங்குகிறது:

// ஒரு Date ஐ உருவாக்கவும்
const time = new Date();
(time instanceof Date);

// ஒரு வரிசையை உருவாக்கவும்
const fruits = ["apples", "bananas", "oranges"];
(fruits instanceof Array);

// ஒரு Map ஐ உருவாக்கவும்
const fruits = new Map([
  ["apples", 500],
  ["bananas", 300],
  ["oranges", 200]
]);
(fruits instanceof Map);

// ஒரு Set ஐ உருவாக்கவும்
const fruits = new Set(["apples", "bananas", "oranges"]);
(fruits instanceof Set);

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

வரையறுக்கப்படாத மாறியின் typeof ஆனது undefined ஆகும்.

typeof car;

மதிப்பு இல்லாத மாறியின் typeof ஆனது undefined ஆகும். மதிப்பும் undefined ஆகும்.

let car;
typeof car;

எந்த மாறியையும் மதிப்பை undefined ஆக அமைப்பதன் மூலம் காலியாக்க முடியும். வகையும் undefined ஆக இருக்கும்.

let car = "Volvo";
car = undefined;

காலி மதிப்புகள்

காலி மதிப்பு undefined உடன் எந்த தொடர்பும் இல்லை. ஒரு காலி சரத்திற்கு சட்டபூர்வமான மதிப்பு மற்றும் வகை இரண்டும் உள்ளன.

let car = "";
typeof car;

Null

JavaScript இல் null என்பது "எதுவும் இல்லை". இது இல்லாத ஒன்று என்று கருதப்படுகிறது.

துரதிர்ஷ்டவசமாக, JavaScript இல், null இன் தரவு வகை ஒரு object ஆகும்.

ஒரு பொருளை null ஆக அமைப்பதன் மூலம் காலியாக்கலாம்:

// ஒரு பொருளை உருவாக்கவும்
let person = {firstName:"John", lastName:"Doe", age:50, eyeColor:"blue"};

person = null;
// இப்போது மதிப்பு null, ஆனால் வகை இன்னும் ஒரு பொருள்

ஒரு பொருளை undefined ஆக அமைப்பதன் மூலமும் காலியாக்கலாம்:

let person = {firstName:"John", lastName:"Doe", age:50, eyeColor:"blue"};

person = undefined;
// இப்போது மதிப்பு மற்றும் வகை இரண்டும் undefined

Undefined மற்றும் Null இடையேயான வேறுபாடு

undefined மற்றும் null ஆகியவை மதிப்பில் சமமாக இருந்தாலும் வகையில் வேறுபட்டவை:

typeof undefined      // undefined
typeof null           // object

null === undefined    // false
null == undefined     // true

constructor பண்பு

constructor பண்பு அனைத்து JavaScript மாறிகளுக்கும் constructor செயல்பாட்டை வழங்குகிறது.

// function Object() {[native code]} ஐ வழங்குகிறது:
{name:'John',age:34}.constructor

// function Array() {[native code]} ஐ வழங்குகிறது:
[1,2,3,4].constructor

// function Date() {[native code]} ஐ வழங்குகிறது:
new Date().constructor

// function Set() {[native code]} ஐ வழங்குகிறது:
new Set().constructor

// function Map() {[native code]} ஐ வழங்குகிறது:
new Map().constructor

// function Function() {[native code]} ஐ வழங்குகிறது:
function () {}.constructor

Constructor உடன், ஒரு பொருள் வரிசையா என்பதை சரிபார்க்கலாம்:

(myArray.constructor === Array);

Constructor உடன், ஒரு பொருள் தேதியா என்பதை சரிபார்க்கலாம்:

(myDate.constructor === Date);

அனைத்தும் ஒன்றாக

typeof "John"          // "string" ஐ வழங்குகிறது
typeof ("John"+"Doe")  // "string" ஐ வழங்குகிறது
typeof 3.14            // "number" ஐ வழங்குகிறது
typeof (33 + 66)       // "number" ஐ வழங்குகிறது
typeof NaN             // "number" ஐ வழங்குகிறது
typeof 1234n           // "bigint" ஐ வழங்குகிறது
typeof true            // "boolean" ஐ வழங்குகிறது
typeof false           // "boolean" ஐ வழங்குகிறது
typeof {name:'John'}   // "object" ஐ வழங்குகிறது
typeof [1,2,3,4]       // "object" ஐ வழங்குகிறது
typeof {}              // "object" ஐ வழங்குகிறது
typeof []              // "object" ஐ வழங்குகிறது
typeof new Object()    // "object" ஐ வழங்குகிறது
typeof new Array()     // "object" ஐ வழங்குகிறது
typeof new Date()      // "object" ஐ வழங்குகிறது
typeof new Set()       // "object" ஐ வழங்குகிறது
typeof new Map()       // "object" ஐ வழங்குகிறது
typeof function () {}  // "function" ஐ வழங்குகிறது
typeof x               // "undefined" ஐ வழங்குகிறது
typeof null            // "object" ஐ வழங்குகிறது

⚠️ குறிப்பு:

NaN (எண் அல்ல) இன் தரவு வகை number!

void ஆபரேட்டர்

void ஆபரேட்டர் ஒரு வெளிப்பாட்டை மதிப்பீடு செய்து undefined ஐ வழங்குகிறது. "void(0)" பயன்படுத்தி வெளிப்பாட்டை மதிப்பீடு செய்யும்போது திரும்ப மதிப்பைப் பயன்படுத்தாமல் undefined முதன்மை மதிப்பைப் பெற இந்த ஆபரேட்டர் பெரும்பாலும் பயன்படுத்தப்படுகிறது.

<a href="javascript:void(0);">
  பயனற்ற இணைப்பு
</a>

<a href="javascript:void(document.body.style.backgroundColor='red');">
  bodyயின் பின்னணி நிறத்தை சிவப்பு ஆக மாற்ற என்னை கிளிக் செய்யவும்
</a>

பயிற்சி

பின்வரும் குறியீட்டைக் கவனியுங்கள்:

x = typeof('John' + 35);

x இன் மதிப்பு என்னவாக இருக்கும்?

string
✗ தவறு! 'John' + 35 என்ற வெளிப்பாடு "John35" என்ற சரத்தை வழங்குகிறது, எனவே typeof ஆனது "string" ஐ வழங்குகிறது
undefined
✗ தவறு! வெளிப்பாடு வரையறுக்கப்பட்டுள்ளது, எனவே undefined அல்ல
number
✓ சரி! இது ஒரு எண்ணுடன் சரத்தை இணைக்கிறது, இது ஒரு சரத்தை விளைவிக்கிறது
boolean
✗ தவறு! வெளிப்பாடு பூலியன் மதிப்பை வழங்கவில்லை