JavaScript Data Types తెలుగులో | string, number, boolean, null, undefined

🟨 JavaScript (ES2026+) 🟢 Lesson 4 📂 Phase 01: JavaScript Fundamentals & Basics 📅 2026 Edition

📌 Covered in this lesson: string · number · boolean · null · undefined · typeof Operator · NaN · Infinity · "5" vs 5

ఇంట్లో వంటగదిలో చూడండి. బియ్యం, పప్పు, ఉప్పు, నూనె అన్నీ వేర్వేరు డబ్బాల్లో ఉంటాయి. ఎందుకంటే అవన్నీ వేర్వేరు రకాలు. బియ్యాన్ని కొలిచే విధానం వేరు, నూనెను కొలిచే విధానం వేరు కదా?

Programming లో కూడా అంతే. Variable డబ్బాల్లో పెట్టే విలువలు వేర్వేరు రకాలు (types) గా ఉంటాయి. పేరు (text), సంఖ్య (number), అవును/కాదు (true/false) ఇలా. ఈ రకాలనే Data Types అంటారు.

ఒక విలువ ఏ రకానికి చెందినదో తెలిస్తేనే, దానితో ఏం చేయొచ్చో, ఏం చేయలేమో తెలుస్తుంది. ఉదాహరణకు, రెండు సంఖ్యలను కూడొచ్చు, కానీ "పేరు" ను "పేరు" తో కూడితే ఏమవుతుంది? ఈ chapter లో అవన్నీ చూద్దాం.

1ఈ chapter లో మీరు నేర్చుకునేవి

JavaScript లోని ముఖ్యమైన data types: string, number, boolean, null, undefined
typeof operator తో ఒక విలువ ఏ రకమో తెలుసుకోవడం
null మరియు undefined మధ్య తేడా
NaN మరియు Infinity అంటే ఏమిటి
"5" మరియు 5 మధ్య తేడా

2Primitive Data Types అంటే ఏమిటి?

JavaScript లో సరళమైన, ప్రాథమిక రకాలను Primitive data types అంటారు. ఈ chapter లో మనం ముఖ్యమైన ఐదింటిని నేర్చుకుందాం:

Data Type	అర్థం	ఉదాహరణ
string	అక్షరాల text	`"రవి"`, `'Hello'`
number	సంఖ్యలు (పూర్ణ మరియు దశాంశ)	`25`, `3.14`, `-7`
boolean	అవును లేదా కాదు	`true`, `false`
null	"ఉద్దేశపూర్వకంగా ఖాళీ"	`null`
undefined	"ఇంకా విలువ ఇవ్వలేదు"	`undefined`

(ఇవి కాకుండా bigint, symbol అనే మరో రెండు ఉన్నాయి. అవి చాలా అరుదుగా వాడతారు, కాబట్టి ప్రస్తుతానికి వదిలేద్దాం.)

3typeof operator: విలువ ఏ రకమో తెలుసుకోవడం

ఏదైనా విలువ ఏ data type కి చెందినదో తెలుసుకోవడానికి typeof అనే operator వాడతాం.

JavaScript — typeof Operator ▶ Run Code

console.log(typeof "Hello");
console.log(typeof 25);
console.log(typeof true);
console.log(typeof undefined);

Output:

string
number
boolean
undefined

typeof తర్వాత విలువ లేదా variable రాస్తే, దాని రకం text గా వస్తుంది. ఈ chapter అంతా దీన్ని వాడుతూనే ఉంటాం.

41. String: Text డేటా

String అంటే అక్షరాల వరుస. పేరు, ఊరు, message, ఇలా text ఏదైనా string. String ని ఎప్పుడూ quotes మధ్యలో రాయాలి.

JavaScript — String Creation

let name1 = "రవి";
let name2 = 'సీత';
let message = `నమస్కారం`;

console.log(name1);
console.log(name2);
console.log(message);
console.log(typeof name1); // string

Quotes లోపల quotes రాయడం

console.log("It's a nice day");
console.log('అతను "హాయ్" అన్నాడు');

String పొడవు (.length)

let language = "JavaScript";
console.log(language.length); // 10

.length తో string లో ఎన్ని అక్షరాలు ఉన్నాయో సులభంగా తెలుస్తుంది.

52. Number: సంఖ్యలు, Infinity & NaN

JavaScript లో number అనే ఒకే రకం ఉంటుంది. పూర్ణ సంఖ్యలు (10), దశాంశ సంఖ్యలు (3.14), రుణ సంఖ్యలు (-5) అన్నీ number లే.

JavaScript — Number Type

let age = 25;
let price = 99.50;
let temperature = -4;

console.log(typeof age);   // number
console.log(typeof price); // number

ప్రత్యేక number విలువలు: Infinity మరియు NaN

Infinity: ఒక సంఖ్యను సున్నాతో భాగిస్తే (గణితంలో ఇది కుదరదు), JavaScript Infinity ఇస్తుంది.

console.log(10 / 0);  // Infinity
console.log(-10 / 0); // -Infinity

NaN (Not a Number): సంఖ్య కాని దాన్ని సంఖ్యలా లెక్కించడానికి ప్రయత్నిస్తే NaN వస్తుంది. ఆశ్చర్యంగా NaN కూడా "number" రకమే!

console.log("abc" * 2);  // NaN
console.log(typeof NaN); // number

దశాంశ సంఖ్యల విచిత్రం (Floating Point Quirk)

console.log(0.1 + 0.2); // 0.30000000000000004

0.3 రావాలి కదా? కంప్యూటర్లు దశాంశ సంఖ్యలను binary లో store చేసే విధానం వల్ల చిన్న తేడా వస్తుంది. డబ్బు లెక్కల్లో దీని గురించి జాగ్రత్తగా ఉండాలి.

63. Boolean: అవును లేదా కాదు (true / false)

Boolean కి కేవలం రెండే విలువలు ఉంటాయి: true (అవును) మరియు false (కాదు). ఇది లైట్ స్విచ్ లాంటిది — ఆన్ లేదా ఆఫ్.

JavaScript — Boolean Comparisons

let isStudent = true;
let isMarried = false;

console.log(typeof isStudent); // boolean
console.log(10 > 5);           // true
console.log(3 === 4);          // false

గుర్తుంచుకోండి: true మరియు false ని quotes లో రాయకూడదు. "true" అనేది కేవలం ఒక text (string).

74. undefined vs 5. null

🎬 రియల్ లైఫ్ అనలాజీ: సినిమా హాల్ సీట్ బుకింగ్

ఈ రెంటికి తేడా చాలా సులభం:

undefined: డబ్బా ఉంది కానీ ఏమీ పెట్టడం మర్చిపోయాం, లేదా ఇంకా పెట్టలేదు. (మీరు ఇంకా seat select చేయలేదు).
null: డబ్బా ఉంది, మరియు "ఇది ఖాళీ" అని మనమే ఉద్దేశపూర్వకంగా చెప్పాం. (మీరు "నాకు ఏ seat వద్దు" అని స్పష్టంగా చెప్పారు).

JavaScript — null vs undefined

let phoneNumber;
console.log(phoneNumber);        // undefined
console.log(typeof phoneNumber); // undefined

let selectedSeat = null;
console.log(selectedSeat);        // null
console.log(typeof selectedSeat); // object (హిస్టారిక్ బగ్!)

⚠️ typeof null విచిత్రం:

typeof null ఎప్పుడూ "object" అని వస్తుంది! ఇది 1995 లో JavaScript మొదటి version లో జరిగిన ఒక పొరపాటు. పాత వెబ్సైట్లు పాడవ్వకూడదని దీన్ని అలాగే ఉంచేశారు.

8"5" మరియు 5 మధ్య తేడా (కూడిక vs అతికింపు)

JavaScript — String Concatenation vs Number Addition

console.log(5 + 3);   // 8 (నంబర్ల కూడిక)
console.log("5" + 3); // "53" (టెక్స్ట్ అతికింపు - Concatenation!)

5 + 3 రెండూ number లు కాబట్టి సంకలనం జరిగింది. కానీ "5" + 3 లో ఒకటి string కాబట్టి JavaScript వాటిని పక్కపక్కనే అతికించింది (Concatenation).

9అన్నీ కలిపి ఒక ఉదాహరణ: విద్యార్థి వివరాలు

JavaScript — Full Data Types Example ▶ Run Code

let studentName = "సీత";
let marks = 87.5;
let isPassed = true;
let address = null;
let phoneNumber;

console.log(studentName, "->", typeof studentName); // string
console.log(marks, "->", typeof marks);             // number
console.log(isPassed, "->", typeof isPassed);       // boolean
console.log(address, "->", typeof address);         // object
console.log(phoneNumber, "->", typeof phoneNumber); // undefined

⚠️ Beginners చేసే సాధారణ తప్పులు

Number ని quotes లో రాయడం: let age = "25"; age + 5; అంటే "255" వస్తుంది కానీ 30 రాదు! సంఖ్యలకు quotes వాడకూడదు.
Boolean ని quotes లో రాయడం: let isLoggedIn = "false"; అనేది boolean కాదు, string! దీన్ని if లో వాడితే true లా ప్రవర్తిస్తుంది!
NaN ని === తో పోల్చడం: NaN === NaN రిజల్ట్ false! NaN ని చెక్ చేయడానికి ఎప్పుడూ Number.isNaN() వాడాలి.

10ప్రాక్టీస్ ప్రశ్నలు & సమాధానాలు

కింది విలువల data types చెప్పండి: "hello", 42, 3.14, true, null, undefined, "100", false.
ఈ typeof లు ఏం print చేస్తాయి? typeof "true", typeof true, typeof (7 / 2), typeof NaN.
ఒక variable లో మీ పేరు, వయసు, student అవునా కాదా (boolean) పెట్టి, ప్రతిదాని typeof print చేయండి.
"10" + 5 మరియు 10 + 5 ఫలితాలు ఏమిటి? ఎందుకు వేర్వేరు?
0.1 + 0.2 === 0.3 ఏం ఇస్తుంది?

సమాధానాలు చూడండి

1. "hello" → string, 42 → number, 3.14 → number, true → boolean, null → null (కానీ typeof object), undefined → undefined, "100" → string, false → boolean.

2. string, boolean, number, number (NaN కూడా number రకమే!).

3. let myName = "రవి"; let myAge = 20; let isStudent = true; (Types: string, number, boolean).

4. "10" + 5 → "105" (string concatenation). 10 + 5 → 15 (number addition).

5. false. ఎందుకంటే 0.1 + 0.2 ఫలితం 0.30000000000000004.

🚀 మీరే try చేయండి

ఈ code ని మన compiler లో run చేసి, విలువలు మార్చి ఫలితాలు చూడండి:

let productName = "Laptop";
let price = 45000;
let inStock = true;
let discount = null;
let rating;

console.log(productName, "->", typeof productName);
console.log(price, "->", typeof price);
console.log(inStock, "->", typeof inStock);
console.log(discount, "->", typeof discount);
console.log(rating, "->", typeof rating);

👉 Our Compiler లో JavaScript try చేయండి

📌 Quick Summary:

Data type అంటే విలువ యొక్క రకం. typeof తో తెలుసుకోవచ్చు.
string: text. number: సంఖ్యలు (Infinity, NaN తో సహా). boolean: true / false.
undefined: విలువ ఇంకా ఇవ్వలేదు. null: ఉద్దేశపూర్వకంగా ఖాళీ.
typeof null ఎప్పుడూ "object" అని ఇస్తుంది (ఒక పాత quirk).
"5" (string) మరియు 5 (number) వేరు వేరు. "5" + 3 ఫలితం "53".