ECMAScript బిట్ ఆపరేటర్
- ముంది పేజీ ఒకరంగ ఆపరేటర్స్
- తరువాత పేజీ లాజికల్ ఆపరేటర్స్
బిట్ ఆపరేషన్స్ సంఖ్యల లోపలి ప్రాంతం (సంఖ్యలను ప్రతినిధీకరించే 32 స్థానాలు) లో పని చేస్తాయి.
సంఖ్యలను మళ్ళీ పరిశీలించండి
ECMAScript సంఖ్యలకు రెండు రకాలు ఉన్నాయి, అవి సిగ్నేడ్ ఇంట్జర్స్ (సంఖ్యలను నిర్వహించడానికి అనుమతిస్తుంది పోసిటివ్ మరియు నెగటివ్ సంఖ్యలను) మరియు అన్ని సంఖ్యలను నిర్వహించడానికి అనుమతిస్తుంది అన్ని సంఖ్యలను ఉపయోగించబడుతుంది. ECMAScript లో, అన్ని సంఖ్యల అసముచిత రూపాలు సిగ్నేడ్ ఇంట్జర్స్ గా అనుమతిస్తాయి, ఇది అర్థం ఏమిటి?
సంఖ్యలను నిర్వహించడానికి సిగ్నేడ్ ఇంట్జర్స్ ఉపయోగిస్తారు, ఇవి 31 స్థానాలను ఉపయోగిస్తాయి. సంఖ్యలను నిర్వహించడానికి మూడో స్థానాన్ని ఉపయోగిస్తారు, 0 అనేది సంఖ్యను సంఖ్యగా ప్రతినిధీకరిస్తుంది, 1 అనేది సంఖ్యను నక్షత్రంగా ప్రతినిధీకరిస్తుంది. సంఖ్యల పరిధి -2147483648 నుండి 2147483647 వరకు ఉంది.
కేవలం సంఖ్యలను నిర్వహించడానికి బైనరీ ప్రస్పక్షంలో రెండు విధాలు ఉన్నాయి, ఒకటి సంఖ్యలను నిర్వహించడానికి మరొకటి ముందుకు వెళ్ళబడుతుంది. ఈ రెండు రకాలలో సంఖ్యలు నిజ బైనరీ ప్రస్పక్షంలో నిర్వహించబడతాయి, మొదటి 31 స్థానాలు ప్రతి స్థానం మూలం సంఖ్యను ప్రతినిధీకరిస్తాయి, మొదటి స్థానం (స్థానం 0) మూలం సంఖ్యను ప్రతినిధీకరిస్తుంది0రెండవ స్థానం (స్థానం 1) రెండును ప్రతినిధీకరిస్తుంది1వాడని స్థానాలను 0 తో పూరించడం జరుగుతుంది, అంటే వాటిని పాటించకుండా ఉంటాయి. ఉదాహరణకు, ఈ చిత్రం సంఖ్య 18 యొక్క ప్రస్పక్షాన్ని ప్రదర్శిస్తుంది.
18 యొక్క బైనరీ ప్రస్పక్షం మొదటి 5 స్థానాలను మాత్రమే వాడుతుంది, ఇవి ఈ సంఖ్యయొక్క నిజ స్థానాలు. ఈ సంఖ్యను బైనరీ స్ట్రింగ్ ప్రస్పక్షంగా మార్చినప్పుడు, ఈ నిజ స్థానాలను చూడవచ్చు:
var iNum = 18; alert(iNum.toString(2)); // అవుట్పుట్ "10010"
ఈ కోడ్ కేవలం "10010" ని అవుట్పుట్ చేస్తుంది, లేదా 18 యొక్క 32 బిట్ ప్రస్పక్షం కాదు. ఇతర స్థానాలు ముఖ్యంగా కాదు, ఎందుకంటే మొదటి 5 స్థానాలు మాత్రమే ఈ దశమాక్షి సంఖ్యను నిర్ణయించగలవు. ఈ చిత్రం ప్రకారం చూడండి:
负数也存储为二进制代码，不过采用的形式是二进制补码。计算数字二进制补码的步骤有三步：
- 确定该数字的非负版本的二进制表示（例如，要计算 -18的二进制补码，首先要确定 18 的二进制表示）
- 求得二进制反码，即要把 0 替换为 1，把 1 替换为 0
- 在二进制反码上加 1
సంఖ్య -18 యొక్క బైనరీ ప్రదర్శనను నిర్ధారించడానికి, ముందుగా 18 యొక్క బైనరీ ప్రదర్శనను గణించాలి ఇలా ఉంటుంది:
0000 0000 0000 0000 0000 0000 0001 0010
తరువాత, బైనరీ కమ్ప్లీమెంట్లో గణించడం ఇలా ఉంటుంది:
1111 1111 1111 1111 1111 1111 1110 1101
చివరగా, బైనరీ కమ్ప్లీమెంట్లో 1 జోడించడం ఇలా ఉంటుంది:
1111 1111 1111 1111 1111 1111 1110 1101
1
---------------------------------------
1111 1111 1111 1111 1111 1111 1110 1110
కాబట్టి, -18 యొక్క బైనరీ ప్రదర్శన 1111 1111 1111 1111 1111 1111 1110 1110 ఉంటుంది. గమనించండి, సంకేతాలను ప్రాప్యంగా పెట్టడం లో, డెవలపర్లు బిట్ 31 ను ప్రాప్యంగా లేకపోవడం జరుగుతుంది.
ఆసక్తికరంగా, నిజమైన సంఖ్యలను బైనరీ స్ట్రింగ్ లో మార్చిన తర్వాత, ECMAScript బైనరీ కమ్ప్లీమెంట్ రూపంలో చూపించబడదు, కానీ సంఖ్యల అభిముఖంలో సంఖ్యల అభిముఖంలో ముందుగా చూపించబడుతుంది. ఉదాహరణకు:
var iNum = -18; alert(iNum.toString(2)); //ప్రదర్శించబడుతుంది "-10010"
ఈ కోడు "-10010" ని ప్రదర్శిస్తుంది, కానీ బైనరీ కమ్ప్లీమెంట్ కాకుండా, బిట్ 31 ను ప్రాప్యంగా లేకపోవడం కొరకు చేయబడింది. సులభతరంగా, ECMAScript సంఖ్యలను ఒక సరళమైన పద్ధతిలో ప్రాప్యంగా పెట్టుతుంది, కాబట్టి డెవలపర్లు వాటి వినియోగాన్ని పరిగణించకుండా ఉంటారు.
మరొక పక్షంలో, నిజమైన సంఖ్యలు చివరి బిట్టినందున మరొక సంఖ్యలో ప్రదర్శించబడతాయి. ఈ మోడ్లో, 32 వ బిట్టినందున సంఖ్యలు సంకేతాలను చూపించడం జరుగుతుంది, కానీ వాటి విలువలో 2 ఉంటుంది.31ఈ అదనపు బిట్టినందున, నిజమైన సంఖ్యల విస్తృతి 0 నుండి 4294967295 వరకు ఉంటుంది. 2147483647 కంటే తక్కువగా ఉన్న సంఖ్యలకు, నిజమైన సంఖ్యలు సంకేతాలను చూపించడం జరుగుతుంది, కానీ 2147483647 కంటే ఎక్కువగా ఉన్న సంఖ్యలకు, 31 వ బిట్టినందున సంకేతాలను చూపించడం జరుగుతుంది (సంకేతాలలో ఈ బిట్టినందున ఎల్లప్పుడూ 0 ఉంటుంది).
నిజమైన సంఖ్యలను స్ట్రింగ్ లో మార్చిన తర్వాత, వాటి యొక్క నిజమైన బిట్లను మాత్రమే తిరిగి చూపుతుంది.
గమనిక:సంఖ్యలను దాని కాలక్రమంలో ముందుగా నిర్ధారించబడింది. మాత్రమే ECMAScript యొక్క స్థానిక కాలక్రమాలు నిజమైన సంఖ్యలను సృష్టించగలవు.
స్థానిక కాలక్రమం NOT
స్థానిక కాలక్రమంలో NOT కాలక్రమం అని పేర్కొనబడింది (~), ఇది ECMAScript లో బైనరీ కాలక్రమంతో సంబంధించిన కాలక్రమాలలో కొన్నింటి ఒకటి.
స్థానిక ఆపరేషన్ NOT మూడు చర్యల ప్రక్రియగా ఉంటుంది:
- ఆపరేషన్ నంబర్ను 32 బిట్స్ గా మార్చండి
- బైనరీ సంఖ్యను బైనరీ రివర్స్ గా మార్చండి
- బైనరీ సంఖ్యను ఫ్లోటింగ్ నంబర్ గా మార్చండి
ఉదాహరణకు:
var iNum1 = 25; //25 అనగా 00000000000000000000000000011001 var iNum2 = ~iNum1; //మార్పుదల 11111111111111111111111111100110 alert(iNum2); //నిర్గమన "-26"
స్థానిక ఆపరేషన్ NOT అంటే సంఖ్యను ముందుకు మార్చి, తరువాత కనికి తగ్గించి, అప్పుడు 25 ను -26 చేస్తుంది. ఈ పద్ధతిలో కూడా అదే ఫలితం పొందవచ్చు:
var iNum1 = 25; var iNum2 = -iNum1 -1; alert(iNum2); //నిర్గమన -26
స్థానిక ఆపరేషన్ AND
స్థానిక ఆపరేషన్ AND సంకేతం (&) ద్వారా ప్రకటించబడుతుంది, ఇది నేరుగా సంఖ్యల బైనరీ రూపం పై ఆపరేషన్ చేస్తుంది. ప్రతి స్థానంలో అంచనా కోసం, AND ఆపరేషన్ కొన్ని నియమాలను ఉపయోగిస్తుంది:
| 第一个数字中的数位 | రెండవ సంఖ్య యొక్క స్థానాలు | ఫలితం |
|---|---|---|
| 1 | 1 | 1 |
| 1 | 0 | 0 |
| 0 | 1 | 0 |
| 0 | 0 | 0 |
ఉదాహరణకు, 25 మరియు 3 కు AND ఆపరేషన్ కోడ్ ఈ కింద ఉంది:
var iResult = 25 & 3; alert(iResult); //నిర్గమన "1"
25 మరియు 3 కు AND ఆపరేషన్ ఫలితం 1కు అవుతుంది. ఎందుకు? ఈ కింద వివరణ:
25 = 0000 0000 0000 0000 0000 0000 0001 1001 3 = 0000 0000 0000 0000 0000 0000 0000 0011 --------------------------------------------- AND = 0000 0000 0000 0000 0000 0000 0000 0001
25 మరియు 3 లో, కేవలం ఒక స్థానం (స్థానం 0)లో మాత్రమే 1 ఉంది, అందువల్ల ఇతర స్థానాలు అన్ని 0లు అయినా, ఫలితం 1 అవుతుంది.
స్థానిక ఆపరేషన్ OR
స్థానిక ఆపరేషన్ OR సంకేతం (|) ద్వారా ప్రకటించబడుతుంది, ఇది నేరుగా సంఖ్యల బైనరీ రూపం పై ఆపరేషన్ చేస్తుంది. ప్రతి స్థానంలో అంచనా కోసం, OR ఆపరేషన్ కొన్ని నియమాలను ఉపయోగిస్తుంది:
| 第一个数字中的数位 | రెండవ సంఖ్య యొక్క స్థానాలు | ఫలితం |
|---|---|---|
| 1 | 1 | 1 |
| 1 | 0 | 1 |
| 0 | 1 | 1 |
| 0 | 0 | 0 |
ఇక ఇది AND ఆపరేషన్ సంకేతం తో ఉపయోగించిన ఉదాహరణతో, 25 మరియు 3 కు OR ఆపరేషన్ కోడ్ ఈ కింద ఉంది:
var iResult = 25 | 3; alert(iResult); //నిర్గమన "27"
25 మరియు 3 కు OR ఆపరేషన్ ఫలితం 27కు అవుతుంది:
25 = 0000 0000 0000 0000 0000 0000 0001 1001 3 = 0000 0000 0000 0000 0000 0000 0000 0011 -------------------------------------------- OR = 0000 0000 0000 0000 0000 0000 0001 1011
ఈ రెండు సంఖ్యలలో, 4 సంఖ్యాంశాలు 1తో పూర్తి అయినా, ఆ సంఖ్యాంశాలు ఫలితానికి అందిస్తాయి. బైనరీ కోడ్ 11011 సంఖ్య 27కు సమానం.
位运算 XOR
位运算 XOR 由符号（^）表示，当然，也是直接对二进制形式进行运算。XOR 不同于 OR，当只有一个数位存放的是 1 时，它才返回 1。真值表如下：
| 第一个数字中的数位 | రెండవ సంఖ్య యొక్క స్థానాలు | ఫలితం |
|---|---|---|
| 1 | 1 | 0 |
| 1 | 0 | 1 |
| 0 | 1 | 1 |
| 0 | 0 | 0 |
25 మరియు 3 నుండి XOR ఆపరేటర్ ఫలితం కోడ్ కింది విధంగా ఉంటుంది:
var iResult = 25 ^ 3; alert(iResult); //అవుతుంది "26"
25 మరియు 3 నుండి XOR ఆపరేటర్ ఫలితం 26 అవుతుంది:
25 = 0000 0000 0000 0000 0000 0000 0001 1001 3 = 0000 0000 0000 0000 0000 0000 0000 0011 --------------------------------------------- XOR = 0000 0000 0000 0000 0000 0000 0001 1010
మూడు సంఖ్యలలో, మొత్తం 4 స్థానాలు నిలచినవి, ఈ స్థానాలు ఫలితంలో పరిచయం చేసుకుంటాయి. బైనరీ కోడ్ 11010 అనురూపం 26.
కుడికి మార్పు కలిగించే ఆపరేటర్
కుడికి మార్పు కలిగించే ఆపరేటర్ రెండు చిన్న తెగలు ద్వారా ప్రస్తుతపరచబడుతుంది (<<). ఇది సంఖ్యలో అన్ని స్థానాలను ప్రస్తుతపరచబడిన స్థానాల సంఖ్యకు కుడికి మార్పు చేస్తుంది. ఉదాహరణకు, సంఖ్య 2 (అనురూపం 10 బైనరీలో) ను 5 స్థానాలకు కుడికి మార్పు చేస్తే, అది 64 (అనురూపం 1000000 బైనరీలో) అవుతుంది:
var iOld = 2; //అనురూపం 10 var iNew = iOld << 5; //అనురూపం 1000000 దశమాంశం 64
గమనిక:కుడికి మార్పు చేస్తున్నప్పుడు, సంఖ్య యొక్క కుడిప్రక్కన అనేక ఖాళీ స్థానాలు ఉంటాయి. కుడికి మార్పు కలిగించే ఆపరేటర్ ఈ ఖాళీ స్థానాలను 0 తో పూరిస్తుంది, అది పూర్తి 32 స్థానాల సంఖ్యను చేస్తుంది.
గమనిక:కుడికి మార్పు కలిగించే ఆపరేటర్ సంఖ్య సంకేతాన్ని కాపాడుతుంది. ఉదాహరణకు, -2 ను 5 స్థానాలకు కుడికి మార్పు చేస్తే, అది -64 అవుతుంది, కాదు 64. "సంకేతం అయిన స్థానంలో 32 స్థానంలో నిలచుతుంది లేదు?" అవుతుంది, కానీ ఇది ECMAScript బ్యాక్ గ్రౌండ్ లో జరుగుతుంది, కార్యకర్త రెండవ స్థానాన్ని ప్రత్యక్షంగా అనుసంధానించలేరు. కూడాను, నిరాకరణ స్ట్రింగ్ ఫార్మాట్ లో అవుతుంది, ఉదాహరణకు, -2 ను -10 లో ప్రదర్శిస్తారు.
సంకేతిక కుడి మార్పు కలిగించే ఆపరేటర్
సంకేతిక కుడి మార్పు కలిగించే ఆపరేటర్ రెండు పెద్ద తెగలు ద్వారా ప్రస్తుతపరచబడుతుంది (>>). ఇది 32 స్థానాల సంఖ్యలో అన్ని స్థానాలను మొత్తంగా కుడికి మార్పు చేస్తుంది, అది దాని సంకేతాన్ని కాపాడుతుంది (ప్రత్యేకంగా ప్రత్యేకంగా లేదా నిరాకరణ). సంకేతిక కుడి మార్పు కలిగించే ఆపరేటర్ కుడికి మార్పు కలిగించే ఆపరేటర్తో విపరీతం. ఉదాహరణకు, 64 ను 5 స్థానాలకు కుడికి మార్పు చేస్తే, అది 2 అవుతుంది:
var iOld = 64; // బైనరీ 1000000 var iNew = iOld >> 5; //等于二进制 10 十进制 2
同样，移动数位后会造成空位。这次，空位位于数字的左侧，但位于符号位之后。ECMAScript 用符号位的值填充这些空位，创建完整的数字，如下图所示：
无符号右移运算
无符号右移运算符由三个大于号（>>>）表示，它将无符号 32 位数的所有数位整体右移。对于正数，无符号右移运算的结果与有符号右移运算一样。
用有符号右移运算中的例子，把 64 右移 5 位，将变为 2：
var iOld = 64; // బైనరీ 1000000 var iNew = iOld >>> 5; // బైనరీ 10 పదకం 2
నకారాత్మక సంఖ్యలకు, పరిస్థితి వివిధంగా ఉంటుంది.
అనిగమ కుడి ముందుకు చేరువ ఆపరేటర్ ఫలితం అన్ని గాలి స్థానాలను 0 తో నింపుతుంది. సకారాత్మక సంఖ్యలకు, ఇది సిగ్నెడ్ కుడి ముందుకు చేరువ ఆపరేటర్ ఫలితం తో అదే ఉంటుంది, కానీ నకారాత్మక సంఖ్యలకు, నకారాత్మక సంఖ్యను సకారాత్మక సంఖ్యగా పరిగణించబడుతుంది.
అనిగమ కుడి ముందుకు చేరువ ఆపరేటర్ ఫలితం ఒక 32 బిట్ పజిటివ్ నంబర్ ఉంటుంది, అందువల్ల నకారాత్మక సంఖ్యలకు అనిగమ కుడి ముందుకు చేరువ ఆపరేటర్ ఫలితం ఒక అతి పెద్ద నంబర్ ఉంటుంది. ఉదాహరణకు, నకారాత్మక సంఖ్య -64 ని 5 బిట్లు కుడి ముందుకు చేరువ చేస్తే, 134217726 అనే నంబర్ పొందుతారు. ఈ ఫలితాన్ని ఎలా పొందారు అని నీరు అడగవచ్చు?
ఈ పనిని చేయడానికి, ఈ సంఖ్యను అనిగమ సమానమైన అనిగమ రూపంలో మార్చాలి (అయితే ఈ సంఖ్య సిగ్నెడ్ ఉంది), ఈ రూపం పొందడానికి కోడ్ ఉపయోగించవచ్చు:
var iUnsigned64 = -64 >>> 0;
అప్పుడు, Number రకం యొక్క toString() ద్వారా నిజమైన బిట్ ప్రతినిధికి పొందండి, బేస్ 2 ఉపయోగించబడింది:
alert(iUnsigned64.toString(2));
ఇది 11111111111111111111111111000000 అనే విధంగా ఉంటుంది, అనగా సిగ్నెడ్ ఇంటిజర్ -64 యొక్క బైనరీ కంప్లమెంట్ ప్రాతిపదికన ఉంటుంది, కానీ ఇది అనిగమ ఇంటిజర్ 4294967232 సమానంగా ఉంటుంది.
ఈ కారణంగా, అనిగమ కుడి ముందుకు చేరువ ఆపరేటర్ని ఉపయోగించడానికి జాగ్రత్తగా ఉండండి.
- ముంది పేజీ ఒకరంగ ఆపరేటర్స్
- తరువాత పేజీ లాజికల్ ఆపరేటర్స్
