జావాస్క్రిప్ట్ బిట్ ఆపరేటర్స్
- పూర్వ పేజీ JS డిస్ట్రక్చర్
- తదుపరి పేజీ JS ప్రకరణ పద్ధతి
జావాస్క్రిప్ట్ బిట్ ఆపరేటర్స్
ఆపరేటర్ | పేరు | వివరణ |
---|---|---|
& | AND | రెండు స్థానాలలో రెండింటికీ 1 ఉంటే ప్రతి స్థానం 1 గా నిర్ధారిస్తుంది |
| | OR | రెండు స్థానాలలో ఒకటి మాత్రమే 1 ఉంటే ప్రతి స్థానం 1 గా నిర్ధారిస్తుంది |
^ | XOR | రెండు స్థానాలలో ఒకటి మాత్రమే 1 ఉంటే ప్రతి స్థానం 1 గా నిర్ధారిస్తుంది |
~ | NOT | అన్ని స్థానాలను తిరిగిపెట్టుతుంది |
<< | నల్లటితో ఎడమకి కదిలుతున్నది | కుడి దిశగా నల్లటిని ప్రోత్సాహించి ఎడమకి కదిలి, అత్యున్నత స్థానం బావలపడుతుంది. |
>> | సంకేతాత్మక కుడికి కదిలుతున్నది | ఎడమ దిశగా అత్యున్నత స్థానంలో కాపీని ప్రోత్సాహించి కుడికి కదిలి, అత్యంత కుడివైపు స్థానం బావలపడుతుంది. |
>>> | నల్లటితో కుడికి కదిలుతున్నది | ఎడమ దిశగా నల్లటిని ప్రోత్సాహించి కుడికి కదిలి, అత్యంత కుడివైపు స్థానం బావలపడుతుంది. |
ఉదాహరణ
ఆపరేషన్ | ఫలితం | సమానం | ఫలితం |
---|---|---|---|
5 & 1 | 1 | 0101 & 0001 | 0001 |
5 | 1 | 5 | 0101 | 0001 | 0101 |
5 ^ 1 | 4 | 0101 ^ 0001 | 0100 |
~ 5 | 10 | ~0101 | 1010 |
5 << 1 | 10 | 0101 << 1 | 1010 |
5 >> 1 | 2 | 0101 >> 1 | 0010 |
5 >>> 1 | 2 | 0101 >>> 1 | 0010 |
జావాస్క్రిప్ట్ 32 బిట్ బిట్ ఆపరేషన్స్ వాడుతుంది
జావాస్క్రిప్ట్ 64 బిట్ ఫ్లోటింగ్ పంటియన్స్ను వాడుతుంది, కానీ బిట్ ఆపరేషన్స్ 32 బిట్ బైనరీ సంఖ్యలతో చేస్తాయి.
బిట్ ఆపరేషన్స్ చేసే ముందు, జావాస్క్రిప్ట్ నంబర్లను 32 బిట్ సిగ్నేడ్ అండర్ ఇంటిజర్స్గా మారుస్తుంది.
బిట్ ఆపరేషన్స్ పూర్తి అయిన తర్వాత, ఫలితం 64 బిట్ జావాస్క్రిప్ట్ నంబర్గా మారుతుంది.
పై ఉదాహరణలు 4 బిట్ల అనిల్య బైనరీ సంఖ్యలను వాడుతాయి. కాబట్టి ~ 5 10 అవుతుంది.
జావాస్క్రిప్ట్ 32 బిట్ సిగ్నేడ్ అండర్ ఇంటిజర్స్ వాడుతుంది, జావాస్క్రిప్ట్ -6 అవుతుంది.
00000000000000000000000000000101 (5)
11111111111111111111111111111010 (~5 = -6)
సిగ్నేడ్ అండర్ ఇంటిజర్స్ మొదటి బిట్ని కాల్చుకుంటాయి.
బిట్లు ఆపరేషన్ AND
బిట్లు ఆపరేషన్ AND చేసినప్పుడు, బిట్లు అన్ని 1 అయితే 1 అవుతుంది。
ఒకటి ఉదాహరణ:
ఆపరేషన్ | ఫలితం |
---|---|
0 & 0 | 0 |
0 & 1 | 0 |
1 & 0 | 0 |
1 & 1 | 1 |
నాలుగు బిట్ల ఉదాహరణ:
ఆపరేషన్ | ఫలితం |
---|---|
1111 & 0000 | 0000 |
1111 & 0001 | 0001 |
1111 & 0010 | 0010 |
1111 & 0100 | 0100 |
బిట్లు ఆపరేషన్ OR
బిట్లు ఆపరేషన్ OR చేసినప్పుడు, అన్నింటిలో కన్నా కొన్ని 1 అయితే 1 అవుతుంది:
ఒకటి ఉదాహరణ
ఆపరేషన్ | ఫలితం |
---|---|
0 | 0 | 0 |
0 | 1 | 1 |
1 | 0 | 1 |
1 | 1 | 1 |
నాలుగు బిట్ల ఆపరేషన్:
ఆపరేషన్ | ఫలితం |
---|---|
1111 | 0000 | 1111 |
1111 | 0001 | 1111 |
1111 | 0010 | 1111 |
1111 | 0100 | 1111 |
బిట్లు ఆపరేషన్ XOR
బిట్లు ఆపరేషన్ XOR చేసినప్పుడు, బిట్లు వేర్వేరు అయితే 1 అవుతుంది:
ఒకటి ఉదాహరణ:
ఆపరేషన్ | ఫలితం |
---|---|
0 ^ 0 | 0 |
0 ^ 1 | 1 |
1 ^ 0 | 1 |
1 ^ 1 | 0 |
నాలుగు బిట్ల ఉదాహరణ:
ఆపరేషన్ | ఫలితం |
---|---|
1111 ^ 0000 | 1111 |
1111 ^ 0001 | 1110 |
1111 ^ 0010 | 1101 |
1111 ^ 0100 | 1011 |
జావాస్క్రిప్ట్ బిట్లు ఆపరేషన్ AND (&)
బిట్లు అన్ని 1 అయితే, బిట్లు ఆపరేషన్ AND ఫలితం 1 అవుతుంది:
దశమాకం | బైనరీ |
---|---|
5 | 00000000000000000000000000000101 |
1 | 00000000000000000000000000000001 |
5 & 1 | 00000000000000000000000000000001 (1) |
ఉదాహరణ
var x = 5 & 1;
జావాస్క్రిప్ట్ బిట్ ఆపరేషన్ OR (|)
స్థానాలలో కాకుండా ఒకటి ఉన్నప్పుడు OR మార్పు మూల్యం 1 వచ్చుతుంది:
దశమాకం | బైనరీ |
---|---|
5 | 00000000000000000000000000000101 |
1 | 00000000000000000000000000000001 |
5 | 1 | 00000000000000000000000000000101 (5) |
ఉదాహరణ
var x = 5 | 1;
JavaScript స్థానాల మార్పు XOR (^)
స్థానాలు వ్యత్యాసంగా ఉన్నప్పుడు XOR మూల్యం 1 వచ్చుతుంది:
దశమాకం | బైనరీ |
---|---|
5 | 00000000000000000000000000000101 |
1 | 00000000000000000000000000000001 |
5 ^ 1 | 00000000000000000000000000000100 (4) |
ఉదాహరణ
var x = 5 ^ 1;
JavaScript స్థానాల మార్పు NOT (~)
దశమాకం | బైనరీ |
---|---|
5 | 00000000000000000000000000000101 |
~5 | 11111111111111111111111111111010 (-6) |
ఉదాహరణ
var x = ~5;
JavaScript (పూరణం చేయబడిన) స్థానాల మార్పు (<<)
ఈదానిలో పూరణం చేయబడిన కుడిమూలక మూల్యం. కుడిపక్కన నుండి ఒకటి లేదా అంతకన్నా ఎక్కువ స్థానాలు చేరుస్తాయి, ప్రారంభ స్థానం పారుగుతుంది:
దశమాకం | బైనరీ |
---|---|
5 | 00000000000000000000000000000101 |
5 << 1 | 00000000000000000000000000001010 (10) |
ఉదాహరణ
var x = 5 << 1;
JavaScript (సంకేతం ఉండే) స్థానాల మూల్యం మార్పు (>>)
ఈదానిలో ప్రత్యేకంగా సంకేతం ఉండే కుడిమూలక మూల్యం. ప్రారంభ స్థానం నుండి చేరుస్తాయి, చివరి స్థానం పారుగుతుంది:
దశమాకం | బైనరీ |
---|---|
-5 | 11111111111111111111111111111011 |
-5 >> 1 | 11111111111111111111111111111101 (-3) |
ఉదాహరణ
var x = -5 >> 1;
JavaScript (పూరణం చేయబడిన) కుడిమూలక మూల్యం (>>>)
ఈదానిలో కుడిపక్కన నిరంతరం పూరణం చేయబడిన కుడిమూలక మూల్యం. కుడిపక్కన నుండి ఒకటి లేదా అంతకన్నా ఎక్కువ స్థానాలు చేరుస్తాయి, చివరి స్థానం పారుగుతుంది:
దశమాకం | బైనరీ |
---|---|
5 | 00000000000000000000000000000101 |
5 >>> 1 | 00000000000000000000000000000010 (2) |
ఉదాహరణ
var x = 5 >>> 1;
32-bit సాంకేతిక పద్ధతి సంఖ్య (బైనరీ సంఖ్య)
మాత్రమే ఒక స్థానాన్ని కలిగించిన 32 బిట్ పద్ధతి సులభంగా అర్థం కాగలదు:
రెండు స్థాయి ప్రతినిధిత్వం | పదము విలువ |
---|---|
00000000000000000000000000000001 | 1 |
00000000000000000000000000000010 | 2 |
00000000000000000000000000000100 | 4 |
00000000000000000000000000001000 | 8 |
00000000000000000000000000010000 | 16 |
00000000000000000000000000100000 | 32 |
00000000000000000000000001000000 | 64 |
మరిన్ని స్థాయిలు మార్చడం ద్వారా రెండు స్థాయి మొదలు పెట్టబడుతుంది:
రెండు స్థాయి ప్రతినిధిత్వం | పదము విలువ |
---|---|
00000000000000000000000000000101 | 5 (4 + 1) |
00000000000000000000000000101000 | 40 (32 + 8) |
00000000000000000000000000101101 | 45 (32 + 8 + 4 + 1) |
మాఘ్యములు నుండి పదములు రెండు స్థాయి ప్రతినిధిత్వం కలిగి ఉంటాయి మరియు అది 1 చేర్చబడుతుంది:
రెండు స్థాయి ప్రతినిధిత్వం | పదము విలువ |
---|---|
00000000000000000000000000000101 | 5 |
11111111111111111111111111111011 | -5 |
00000000000000000000000000101000 | 40 |
11111111111111111111111111011000 | -40 |
11111111111111111111111111011001 | -41 |
పదము నుండి రెండు స్థాయి మార్చండి
ఉదాహరణ
function dec2bin(dec){ return (dec >>> 0).toString(2); }
రెండు స్థాయి నుండి పదము మార్చండి
ఉదాహరణ
function bin2dec(bin){ return parseInt(bin, 2).toString(10); }
- పూర్వ పేజీ JS డిస్ట్రక్చర్
- తదుపరి పేజీ JS ప్రకరణ పద్ధతి