Bitwise Operator ng ECMAScript

Ang bit operator ay gumagawa ng operasyon sa digital na lebel ng numero (katulad ng 32 na bit na ginagamit upang ipakita ang numero).

Muling isusubaybay ang integer

May dalawang uri ng integer sa ECMAScript, totoo ang may simbolyong integer (pinapayagan ang positibong at negatibong numero) at ang walang simbolyong integer (pinapayagan lamang ang positibong numero). Sa ECMAScript, lahat ng integer na literal ay may simbolyong integer, ibig sabihin kung ano?

Ang may simbolyong integer ay ginagamit sa 31 na bit upang ipakita ang halaga ng integer, sa ikatlong bit (bit 32) ay ginagamit upang ipakita ang simbolo ng integer, 0 para sa positibong numero at 1 para sa negatibong numero. Ang saklaw ng halaga ay mula -2147483648 hanggang 2147483647.

May dalawang paraan para mapag-imbak ang may simbolyong integer sa binarikong paraan, isa para sa positibong numero at isa para sa negatibong numero. Ang positibong numero ay nangangalaga ng tunay na binarikong paraan, ang bawat bit sa unang 31 na bit ay nangangahulugan ng kapangyarihan ng 2, mula sa unang bit (bit 0) na nangangahulugan ng 20Ang ikalawang bit (bit 1) ay nangangahulugan ng 21Ang hindi nagamit na bit ay pinupunan ng 0, o pinagwawalang pansin. Halimbawa, ang diagrama ay nagtampok ng representasyon ng numero 18.

32 na binarik na palatandaan na may simbolo na integer

Ang binarang bersyon ng 18 ay gumamit lamang ng unang limang bit, sila ang tunay na bit ng numero. Kapag inilalagay ang numero sa binarang string, makikita ang tunay na bit:

var iNum = 18;
alert(iNum.toString(2));	//Nagluluto ng "10010"

Ang kodigong ito ay nagluluto lamang ng "10010", hindi ng 32-bit na representasyon ng 18. Ang ibang numero ay hindi mahalaga, dahil ang limang unang bit lamang ang kinakailangan upang matukoy ang decimal na halaga. Tulad ng ito sa diagrama:

5 na binarik na palatandaan na integer 18

Ang negatibong numero ay inilalagay bilang binary code, ngunit sa anyo ng binaryang komplementaryo. Ang tatlong hakbang sa pagkalkula ng binaryang komplementaryo ng numero ay:

  1. Tukuyin ang binaryong paglalarawan ng hindi negatibong bersyon ng numero (halimbawa, para makalkula ang binaryang komplementaryo ng -18, kailangan makuha muna ang binaryong paglalarawan ng 18)
  2. Makuha ang binaryang inverse, sa gayon ay kailangan palitan ang 0 sa 1, at ang 1 sa 0
  3. Dagdagan ang binaryang inverse

Para matukoy ang binaryong paglalarawan ng -18, kailangan makuha muna ang binaryong paglalarawan ng 18, tulad ng ibabang kasama.

0000 0000 0000 0000 0000 0000 0001 0010

Kamakailan, kailangan kalkulahin ang binaryang inverse, tulad ng ibabang kasama.

1111 1111 1111 1111 1111 1111 1110 1101

Sa wakas, dagdagan ang binaryang inverse, tulad ng ibabang kasama.

1111 1111 1111 1111 1111 1111 1110 1101
                                      1
---------------------------------------
1111 1111 1111 1111 1111 1111 1110 1110

Kaya ang binaryong paglalarawan ng -18 ay 1111 1111 1111 1111 1111 1111 1110 1110. Tandaan, kapag pinagpapatakbo ang may simbolyong integer, ang developer ay hindi makakapasok sa bit 31.

Kaya may interes na, kapag inilalagay ang negatibong integer sa string na binary, ang ECMAScript ay hindi nagpapakita sa anyo ng binaryang komplementaryo, kundi sa anyo ng negatibong halaga ng standard na binary code ng absolute value. Halimbawa:

var iNum = -18;
alert(iNum.toString(2));	// Output "-10010"

Ang code na ito ay nagluluto ng "-10010", hindi ng binaryang komplementaryo, upang maiwasan ang paggamit ng bit 31. Para sa kagamitan, ang ECMAScript ay gumagamit ng isang simpleng paraan para sa paggamit ng integer, sa gayon ang mga developer ay hindi kailangan magmamalasakit sa kanilang paggamit.

Sa kabilang banda, ang unsigned integer ay nagpapakita ng huling bit bilang isa pang lugar ng bilang. Sa ganitong paraan, ang pang 32 na bit ay hindi ipinapakita bilang simbolo ng bilang, kundi may halaga na 2.31Dahil sa ekstra na bit, ang saklaw ng halaga ng unsigned integer ay mula 0 hanggang 4294967295. Para sa integer na mas mababa sa 2147483647, ang unsigned integer ay parang kahawig ng may simbolyong integer, ngunit para sa integer na mas malaki sa 2147483647, kailangan gamitin ang bit 31 (sa may simbolyong integer, ang bit na ito ay palaging 0).

Pagkatapos ayusin ang unsigned integer sa string, ibabalik lamang ang kanilang tunay na mga bit.

Pansin:Lahat ng literal na integer ay inilalagay bilang may simbolyong integer sa pamamagitan ng kasalukuyan. Lamang ang mga operator ng bit sa ECMAScript ang kayang gumawa ng unsigned integer.

Ang pagtatalaga ng negasyon sa bit

Ang pagtatalaga ng negasyon sa bit ay inilalarawan ng tanda ng pagpapaubos (~), ito ay isa sa ilang operador na may kaugnayan sa binaryong aritmetika sa ECMAScript.

Ang bit operation na NOT ay tatlong hakbang na proseso:

  1. Pag-convert ng operation number sa 32-bit number
  2. Pag-convert ng baytin ng numero sa kanilang baytin na kapalit
  3. Pag-convert ng baytin ng numero sa floating point number

Halimbawa:

var iNum1 = 25;		//25 ay katumbas ng 00000000000000000000000000011001
var iNum2 = ~iNum1;	//Magiging 11111111111111111111111111100110
alert(iNum2);		//maglabas ng "-26"

Ang bit operation na NOT ay tunay na pagtatanungo ng negatibo ng numero, pagkatapos ay magbawas ng 1, kaya ang 25 ay nagiging -26. Maaari ring makakuha ng parehong resulta sa pamamagitan ng sumusunod na paraan:

var iNum1 = 25;
var iNum2 = -iNum1 -1;
alert(iNum2);	//maglabas ng "-26"

Bit operation na AND

Ang bit operation na AND ay hinango ng simbolo (ampersand), dinirektang pagsasagawa ng pagtutulad sa baytin ng numero. Ito ay pinapakita ang bawat pwesto ng bawat numero, at ginagamit ang sumusunod na alituntunin sa pagtutulad ng dalawang pwesto sa parehong pwesto:

Ang mga lugar ng unang bilang Ang mga lugar ng ikalawang bilang Resulta
1 1 1
1 0 0
0 1 0
0 0 0

Halimbawa, upang gumawa ng pagpapa-AND ng numero 25 at 3, ang kodigo ay sumusunod:

var iResult = 25 & 3;
alert(iResult);	//maglabas ng "1"

Ang resulta ng pagpapa-AND ng 25 at 3 ay 1. Bakit? Nalalaman sa sumusunod:

 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

Maaring makita, sa 25 at 3, may isang pwesto ng numero (pwesto 0) na naglalaman ng 1, kaya ang ibang pwesto ay naglalaman ng 0, kaya ang resulta ay 1.

Bit operation na OR

Ang bit operation na OR ay hinango ng simbolo (|), dinirektang pagsasagawa ng pagtutulad sa baytin ng numero. Sa pagtutulad ng bawat pwesto, ang operator ng OR ay gumagamit ng mga sumusunod na alituntunin:

Ang mga lugar ng unang bilang Ang mga lugar ng ikalawang bilang Resulta
1 1 1
1 0 1
0 1 1
0 0 0

Paggamit pa rin ng halimbawa ng operator ng AND, ang pagpapa-OR ng 25 at 3, ang kodigo ay sumusunod:

var iResult = 25 | 3;
alert(iResult);	//maglabas ng "27"

Ang resulta ng pagpapa-OR ng 25 at 3 ay 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

Maaring makita, sa dalawang numero, mayroong 4 na pwesto ng numero na naglalaman ng 1, ang mga pwesto na ito ay ipinasa sa resulta. Ang kodigo ng baytin 11011 ay katumbas ng 27.

Bit operation na XOR

Ang bit operation na XOR ay pinapakita ng simbolo na (^), siya rin ay gumagawa ng direktang operasyon sa binary form. Ang XOR ay hindi katulad ng OR, ito ay ibibigay ng 1 lamang kapag isang lugar lamang ay naglalaman ng 1. Ang truth table ay tulad nang ito:

Ang mga lugar ng unang bilang Ang mga lugar ng ikalawang bilang Resulta
1 1 0
1 0 1
0 1 1
0 0 0

Ang XOR operasyon sa 25 at 3, ang code ay tulad nang ito:

var iResult = 25 ^ 3;
alert(iResult);	//Output "26"

Ang resulta ng XOR operasyon sa 25 at 3 ay 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

Maaaring makita na sa dalawang bilang, mayroong 4 na lugar na naglalaman ng 1, ang mga ito ay inililipat sa resulta. Ang binagong code na 11010 ay katumbas ng 26.

Alinlanganang gumaling operadong

Ang alinlanganang gumaling operadong ay pinapakita ng dalawang mas mababang simbolo (<<). Ito ay inililipat ang lahat ng numero sa bilang nang kung anong dami ng lugar na itinutukoy. Halimbawa, kapag ang bilang 2 (katumbas ng 10 sa binary) ay inililipat ng 5 na lugar, ang resulta ay 64 (katumbas ng 1000000 sa binary):

var iOld = 2;		//Katumbas ng 10 sa binary
var iNew = iOld << 5;	//Katumbas ng 1000000 sa binary, 64 sa decimal

Pansin:Sa paninililipat ng lugar ng bilang, ang kanang bahagi ng bilang ay may limang walang laman na lugar. Ang alinlanganang gumaling operadong ay pinupunan ng 0 ang mga ito, upang ang resulta ay maging buong 32-bit na bilang.

Ang numero 2 ay nagsasalakay sa pag-angat

Pansin:Ang alinlanganang gumaling operadong ay ininanggap ang simbolo ng bilang. Halimbawa, kapag ang -2 ay inililipat ng 5 na lugar, ang halimbawa ay -64, hindi 64. 'Nag-iisa pa ba ang simbolo sa pang 32 na lugar?' Oo, ngunit ito ay ginagawa sa ECMAScript sa likod, ang mga developer ay hindi makapag-access sa pang 32 na lugar. Kahit na ang naka-eksit na binagong string ng bit, ang ini-display ay ang simbolo ng negatibo (halimbawa, ang -2 ay magiging -10.).

Symbolikong alinlanganang gumaling operadong

Ang symbolikong alinlanganang gumaling operadong pinapakita ng dalawang mahigit na simbolo (>>). Ito ay inililipat ang lahat ng numero sa 32-bit na bilang nang buong kalakhan, habang ininanggap ang simbolo ng bilang (positibo o negatibo). Ang symbolikong alinlanganang gumaling operadong ay kahalintulad sa kahalintulad na malilipat ng bata. Halimbawa, kapag ang 64 ay inililipat ng 5 na lugar, ito ay magiging 2:

var iOld = 64;		//ស្មើនឹង 1000000 នៅក្នុងទ្រង់ 2
var iNew = iOld >> 5;	//等于二进制 10 十进制 2

同样，移动数位后会造成空位。这次，空位位于数字的左侧，但位于符号位之后。ECMAScript 用符号位的值填充这些空位，创建完整的数字，如下图所示：

Ang numero 64 ay nagsasalakay sa may simbolo na pag-urong

បរិវត្តិការបញ្ចេញស្លាប់

បរិវត្តិការបញ្ចេញស្លាប់ ត្រូវបានបញ្ជាក់ដោយបីក្បាលធំ (>>>), វាបញ្ចេញទាំងអស់នៃចំនួន 32 បន្ទុក នៃចំនួនមិនមានសញ្ញា ដែលស្មើនឹងបរិវត្តិការបញ្ចេញស្លាប់ និង បរិវត្តិការបញ្ចេញស្លាប់ ដែលជាចំនួនមាន 1

ដោយបរិវត្តិការបញ្ចេញស្លាប់ ដែលជាឧទាហរណ៍ 64 ដែលបញ្ចេញ 5 បន្ទុក នឹងក្លាយជា 2

var iOld = 64;		//ស្មើនឹង 1000000 នៅក្នុងទ្រង់ 2
var iNew = iOld >>> 5;	//ស្មើនឹង 10 នៅក្នុងទ្រង់ 2 ឬ 2 នៅក្នុងទ្រង់ 10

សំរាប់ចំនួនមាន 1 ការដូចនេះ គឺមិនដូចគ្នានោះ

បរិវត្តិការបញ្ចេញស្លាប់ បញ្ចេញស្លាប់ទាំងអស់ ដោយ 0 និង 0 ដែលជាចំនួនមាន 0 និង 1 ដែលជាចំនួនមាន 1 ដែរ ដែលដូចជាបរិវត្តិការបញ្ចេញស្លាប់ និង បរិវត្តិការបញ្ចេញស្លាប់ ដែលមាន 1 ត្រូវតែប្រើប្រាស់ដោយជាចំនួនមាន 1

ដោយសារបរិវត្តិការបញ្ចេញស្លាប់ គឺជាចំនួន 32 បន្ទុក ជាចំនួនធំដែលអាចទទួលបានដោយបរិវត្តិការបញ្ចេញស្លាប់ចំនួន 64 ដែលបញ្ចេញ 5 បន្ទុក នឹងទទួលបាន 134217726 ។ តើយ៉ាងណាដែលអ្នកបានទទួលបាននេះ?

ដើម្បីធ្វើឲ្យវាអាចធ្វើបាន ត្រូវការបញ្ចាក់នោះ ត្រូវតែបញ្ជូនចំនួនទៅជាទម្រង់មិនមានសញ្ញារួម ទោះបីជាចំនួននោះនៅតែមានសញ្ញាទេ ដែលអាចទទួលបានដោយការប្រើប្រាស់នេះ

var iUnsigned64 = -64 >>> 0;

បន្ទាប់មក ប្រើ toString() នៃប្រភេទ Number ដើម្បីទទួលបានការបញ្ចេញលើកត្រល់ពិតប្រាកដ ដែលគោលដៅជាមួយនឹង 2:

alert(iUnsigned64.toString(2));

នេះនឹងបង្កើត 11111111111111111111111111000000 គឺជាការបញ្ចេញលើកត្រល់នៃចំនួនសុទ្ធ -64 នៅក្នុងទ្រង់ប្រវត្តិ 2 ប៉ុន្តែវាស្មើនឹងចំនួនសុទ្ធ 4294967232 ដែរ

សំរាប់ហេតុនេះ ត្រូវបានប្រើប្រាស់បរិវត្តិការបញ្ចេញស្លាប់ ត្រូវបានប្រើប្រាស់ដោយមិនមានការប្រុងប្រយ័ត្ន