JavaScript Primitive and Reference Types
JavaScript Primitive మరియు Reference Types
JavaScript లో values ప్రధానంగా రెండు categories గా అర్థం చేసుకోవచ్చు: Primitive types మరియు Reference types.
Primitive Types
Primitive value అనేది ఒకే, స్వతంత్ర value. ఒక primitive variable ను మరో variable కు assign చేసినప్పుడు value యొక్క copy తయారవుతుంది. తరువాత copy ని మార్చినా original variable మారదు.
JavaScript primitive types లో string, number, bigint, boolean, undefined, symbol, మరియు null ఉన్నాయి.
Reference Types
Reference type variable లో object యొక్క actual data కాకుండా, ఆ object ఉన్న memory location కు reference ఉంటుంది. ఒక object ను మరో variable కు assign చేసినప్పుడు రెండు variables ఒకే object ను refer చేయవచ్చు.
Objects, arrays, మరియు functions reference types గా పనిచేస్తాయి. ఒక reference variable ద్వారా object ను మార్చితే, అదే object ను సూచిస్తున్న మరో variable లో కూడా మార్పు కనిపిస్తుంది.
Primitive Copy మరియు Reference Copy మధ్య తేడా
- Primitive value assignment లో independent copy ఏర్పడుతుంది.
- Object లేదా array assignment లో సాధారణంగా అదే reference copy అవుతుంది.
- Primitive values ను compare చేసినప్పుడు values compare అవుతాయి.
- Objects లేదా arrays ను compare చేసినప్పుడు వాటి references compare అవుతాయి.
Mutable మరియు Immutable
Primitive values సాధారణంగా immutable. అంటే ఆ value ను నేరుగా మార్చలేము; కొత్త value assign చేయాలి. Objects మరియు arrays mutable. అంటే వాటి properties లేదా elements ను మార్చవచ్చు.
Equality విషయంలో జాగ్రత్త
రెండు objects లో data ఒకేలా కనిపించినా, అవి వేర్వేరు objects అయితే strict equality operator === false ఇస్తుంది. రెండు variables ఒకే object ను refer చేస్తే మాత్రమే === true ఇస్తుంది.
Simple Explanation
ఒక primitive value ను ఒక box లో ఉన్న స్వతంత్ర వస్తువుగా ఊహించండి. ఆ box ను copy చేస్తే మరో స్వతంత్ర box వస్తుంది. కానీ reference type ను ఒక ఇంటి address లాగా ఊహించండి. Address ను copy చేసినప్పుడు కొత్త ఇల్లు తయారు కాదు; రెండు addresses ఒకే ఇంటిని చూపిస్తాయి.
అందువల్ల number లేదా string copy చేసిన తరువాత ఒకదాన్ని మార్చినా మరొకటి మారదు. కానీ array లేదా object ను copy చేసి దాని property మార్చితే, అదే reference ఉపయోగిస్తున్న మరో variable లో కూడా మార్పు కనిపిస్తుంది.
Real-Life Example
ఒక విద్యార్థి యొక్క marks ను primitive number గా తీసుకుంటే, marks ను మరో variable కు copy చేసినప్పుడు అది స్వతంత్ర సంఖ్యగా ఉంటుంది. Original marks మార్చకుండా copied marks మార్చవచ్చు.
కానీ విద్యార్థి యొక్క profile object ను ఇద్దరు teachers ఒకే file reference ద్వారా చూస్తున్నారని ఊహించండి. ఒక teacher ఆ file లోని status ను మార్చితే, మరో teacher చూసే అదే file లో కూడా ఆ మార్పు కనిపిస్తుంది. ఇదే reference type behavior.
Code Examples
Primitive value copy
let score = 80;
let copiedScore = score;
copiedScore = 95;
console.log(score);
console.log(copiedScore);ఇక్కడ score ఒక number primitive value. దాన్ని copiedScore కు assign చేసినప్పుడు value copy అవుతుంది. తరువాత copiedScore ను 95 గా మార్చినా score లోని 80 మారదు.
80 95
Reference type copy with an object
const user = { name: "Ravi", active: true };
const sameUser = user;
sameUser.active = false;
console.log(user.active);
console.log(user === sameUser);sameUser కు user object యొక్క reference assign అయింది. కాబట్టి sameUser.active ను false గా మార్చినప్పుడు user.active కూడా false అయింది. రెండు variables ఒకే object ను refer చేస్తున్నందున === true వస్తుంది.
false true
Array reference behavior
const numbers = [10, 20];
const sameNumbers = numbers;
sameNumbers.push(30);
console.log(numbers);
console.log(numbers === sameNumbers);Array కూడా reference type. sameNumbers ద్వారా 30 ను add చేసినప్పుడు original numbers array కూడా update అవుతుంది. రెండు variables ఒకే array reference ను కలిగి ఉన్నాయి.
[10, 20, 30] true
Line-by-Line Explanation
ఇక్కడ 10 మరియు 20 elements కలిగిన ఒక array ను create చేసి, దాని reference ను numbers variable లో ఉంచుతున్నాం.
ఈ line లో కొత్త array create కావడం లేదు. numbers variable లో ఉన్న అదే array reference ను sameNumbers కూడా ఉపయోగిస్తుంది.
ఖాళీ line code ను చదవడానికి సులభంగా చేయడానికి మాత్రమే ఉంది; program execution పై దీని ప్రభావం లేదు.
sameNumbers reference చేస్తున్న array లో push method ద్వారా 30 element ను add చేస్తున్నాం. అదే array ను numbers కూడా reference చేస్తున్నందున numbers లో కూడా 30 కనిపిస్తుంది.
ఈ ఖాళీ line కూడా code sections మధ్య readability కోసం మాత్రమే ఉంది.
మార్చబడిన numbers array ను console లో చూపిస్తుంది. Output లో 10, 20, 30 కనిపిస్తాయి.
numbers మరియు sameNumbers ఒకే array reference ను కలిగి ఉన్నాయా అని strict equality తో check చేస్తుంది. ఒకే reference కావడంతో true output వస్తుంది.
Try It
Try this JavaScript code:
let originalValue = 50;
let copiedValue = originalValue;
const profile = { active: true };
const profileCopy = profile;
console.log(originalValue);
console.log(copiedValue);
console.log(profile.active);
console.log(profile === profileCopy);Practice
Practice:
Task: పై code లో copiedMarks ను 90 గా మార్చండి. marks మాత్రం 75 గానే ఉండాలి. తరువాత profileCopy.active ను false గా మార్చండి. చివరి రెండు outputs reference behavior ను చూపాలి.
Hint:
number ఒక primitive value కాబట్టి copiedMarks = 90; ఉపయోగించండి. profileCopy ఒకే object ను refer చేస్తుంది కాబట్టి profileCopy.active = false; ఉపయోగించండి.
Common Mistakes
ఒక object ను మరో variable కు assign చేసినప్పుడు పూర్తిగా కొత్త object copy అవుతుందని అనుకోవడం.
సాధారణ assignment లో object యొక్క reference మాత్రమే copy అవుతుంది. Independent object కావాలంటే ప్రత్యేకంగా copy చేయాలి; ఆ విషయం తరువాతి lessons లో వివరంగా చూడవచ్చు.
రెండు objects లో data ఒకేలా కనిపిస్తే === true వస్తుందని అనుకోవడం.
=== objects కోసం data కాకుండా reference ను compare చేస్తుంది. రెండు variables ఒకే object ను refer చేసినప్పుడు మాత్రమే true వస్తుంది.
Primitive variable ను మార్చినప్పుడు original variable కూడా మారుతుందని అనుకోవడం.
Primitive assignment లో value independent copy అవుతుంది. Copy చేసిన variable ను మార్చినా original primitive variable మారదు.
const variable లోని object లేదా array ఏ విధంగానూ మార్చలేమని అనుకోవడం.
const reference ను reassign చేయకుండా ఉంచుతుంది. అయితే ఆ reference చూపిస్తున్న object యొక్క property లేదా array element ను మార్చవచ్చు.
Interview Questions
JavaScript లో primitive type మరియు reference type మధ్య ప్రధాన తేడా ఏమిటి?
Answer: Primitive assignment లో value యొక్క independent copy తయారవుతుంది. Reference type assignment లో object లేదా array కు సంబంధించిన reference copy అవుతుంది; రెండు variables ఒకే data structure ను refer చేయవచ్చు.
JavaScript primitive types ఏవి?
Answer: string, number, bigint, boolean, undefined, symbol, మరియు null primitive types.
ఈ code output ఏమిటి: let a = 10; let b = a; b = 20; console.log(a);
Answer: Output 10. ఎందుకంటే number ఒక primitive value, కాబట్టి b కు independent value copy అవుతుంది.
ఈ code లో result ఏమిటి: const a = {}; const b = a; console.log(a === b);
Answer: Output true. ఎందుకంటే a మరియు b ఒకే object reference ను కలిగి ఉన్నాయి.
Exam Questions
Primitive value ను copy చేసిన తరువాత copied variable ను మార్చితే original variable పై ఏమి ప్రభావం ఉంటుంది?
Answer:
Original variable పై ప్రభావం ఉండదు, ఎందుకంటే primitive value independent copy గా assign అవుతుంది.
const first = [1, 2]; const second = first; second.push(3); తరువాత first array ఏమవుతుంది?
Answer:
first array [1, 2, 3] అవుతుంది, ఎందుకంటే first మరియు second ఒకే array reference ను ఉపయోగిస్తున్నాయి.
Objects ను strict equality operator తో compare చేసినప్పుడు ఏమి compare అవుతుంది?
Answer:
Objects యొక్క contents కాదు; వాటి references లేదా memory identity compare అవుతుంది.
Quick Revision
- JavaScript values ను అర్థం చేసుకోవడానికి Primitive types మరియు Reference types ముఖ్యమైన categories.
- Primitive types: string, number, bigint, boolean, undefined, symbol, మరియు null.
- Primitive assignment లో value copy అవుతుంది; original మరియు copied variables independent గా ఉంటాయి.
- Objects, arrays, మరియు functions reference types గా పనిచేస్తాయి.
- Reference assignment లో సాధారణంగా అదే object లేదా array reference copy అవుతుంది.
- Objects మరియు arrays mutable; primitive values immutable గా పరిగణించబడతాయి.
- Objects లేదా arrays కోసం === references ను compare చేస్తుంది.
- const reference ను reassign చేయలేము, కానీ reference చూపిస్తున్న object లేదా array లోని data ను మార్చవచ్చు.