Mashairi ya binari ya ECMAScript
- Kabla Matukio ya moja pekee
- Pya Matukio ya hisia
Matukio ya adabu ya kina yanaadilifu kwenye kina chini (kama kina ya adabu ya 32 taa) yanaadilifu.
Ukumbuka namba yenye maana
ECMAScript ina namba yenye maana zaidi ya pili, yaani namba yenye maana (inayoweza kutumika kwa namba za juu na namba za chini) na namba yenye maana tu (inayoweza kutumika kwa namba za juu tu). Kwenye ECMAScript, inasababisha kila namba ya kina inaadilifu, kimekuwa nini?
Namba yenye maana zinaongea kwa sababu ya 31 taa inasababisha adabu ya namba, kwa sababu ya taa ya 32 inasababisha adabu ya namba, 0 inasababisha namba za juu, 1 inasababisha namba za chini. Uwanja wa adabu ni -2147483648 hadi 2147483647.
Inafanyika kwa pili kwa sababu ya namba yenye maana za binari, inafanyika kwa sababu ya namba za juu na inafanyika kwa sababu ya namba za chini. Namba za juu zinatangulia kwa sababu ya adabu ya binari, kila kituo kinaadilifu wa 2, kuanzia kituo cha 1 (kituo 0) kinasababisha 20Kituo cha 2 (kituo 1) kinasababisha 21Matukio yenye uwanja hauzisafishwi, yanaingia kwa 0, kama inavyotiririka hapa. Kama inavyotiririka hapa, inaonyesha tabaka la namba 18.
Hii ni kichwa cha 5 kwa 18 katika tabaka la binari, ni matukio yenye maana yake. Kuwaambia namba kwa sababu ya binari, inasababisha kusikitika matukio yenye maana:
var iNum = 18; alert(iNum.toString(2)); //kumkomora '10010'
Hiiwakati hii kwa kumkomora '10010' tu, ingawa kumkomora 32 taa ya 18 hakuna matukio mengi, kwa sababu inaingia kwenye kina 5 tu inasababisha uadilifu hii katika adabu ya kina. Kama inavyotiririka hapa:
负数也存储为二进制代码，不过采用的形式是二进制补码。计算数字二进制补码的步骤有三步：
- 确定该数字的非负版本的二进制表示（例如，要计算 -18的二进制补码，首先要确定 18 的二进制表示）
- 求得二进制反码，即要把 0 替换为 1，把 1 替换为 0
- Kumekadiri kina ya uwanja
Kumekadiri tabia ya kina ya -18, kwanza inahitajika kumekadiri tabia ya kina ya 18, kama iliyotiririka hapa:
0000 0000 0000 0000 0000 0000 0001 0010
Kufikia huko, kumekadiri kina ya uwanja, kama iliyotiririka hapa:
1111 1111 1111 1111 1111 1111 1110 1101
Kufikia huko, kumekadiri kina ya uwanja, kama iliyotiririka hapa:
1111 1111 1111 1111 1111 1111 1110 1101
1
---------------------------------------
1111 1111 1111 1111 1111 1111 1110 1110
Kwa hivyo, tabia ya kina ya -18 inaonekana kama 1111 1111 1111 1111 1111 1111 1110 1110. Tukijua, kumekadiri namba za kina, mtengenezi hauwezi kufikia kina 31.
Inasikitisha, kumekadiri namba nyingi zinaonyesha kwa sababu ya kina bila kina, ECMAScript haitumii muundo wa kina ya kina bila kina, bali inatumia muundo wa kina ya kina na kina. Mfano:
var iNum = -18; alert(iNum.toString(2)); //kutumia "-10010"
Chaguo hicho chichaguliwa kwa sababu ya kina hii, namba za kina zinaonyesha kwa sababu ya kina 31. Kwa ushahidi, ECMAScript inatumia njia rahisi ya kumekadiri namba, inayotaka kwamba mtengenezi hawajafahamiki njia zake.
Mengine, namba za kina bila kina inaonekana kina 32 kama kina nyingine. Kwenye hii msimbo 32 haitukumbusha kina ya ukingo wa namba, bali inaonekana kama uga 2.31Kwa sababu ya kina hii kina, uga wa namba za kina bila kina una wakati wa 0 hadi 4294967295. Kwa namba kubwa kuliko 2147483647, namba za kina bila kina inaona kama namba za kina zina kina 31 (katika namba za kina, kina 31 inaonekana kama 0).
Kumwandaa namba za kina bila kina kwa maneno ya ujenzi, huzingatia tu vipengele vya maadili.
注意：Vivutio vya namba zote zilitumika kwa ukweli zilitumika kama namba za kina. Hata hivyo, algoriti za kumekadiri katika ECMAScript zinafanikisha kumekadiri namba za kina.
Algoriti ya kumekadiri ingawa
Algoriti ya kumekadiri ingawa inaeleza kwa alama ya kusababisha (~), inaonekana kama moja ya kimoja ya muhimu zaidi katika ECMAScript ambayo inashiriki katika hisia ya kilugha ya faragha.
Machache ya NOT inaingia kwa kumaliza tatizo tatu:
- Kubadilika kwa namba za kina za 32 vya machache
- Kubadilika kwa binari wa namba wa matokeo
- Kubadilika kwa namba za kina ya binari
Mfano:
var iNum1 = 25; //25 inadai 00000000000000000000000000011001 var iNum2 = ~iNum1; //kubadilika kwa 11111111111111111111111111100110 alert(iNum2); //kutumia "-26"
Machache ya NOT inaingia kwa kumaliza namba kwa kumaliza kwa namba na kumaliza 1, kwa hivyo 25 inapata -26. Inaweza kufikia hivyo kwa mpangilio hii:
var iNum1 = 25; var iNum2 = -iNum1 -1; alert(iNum2); //kutumia -26
Machache ya AND
Machache ya AND kinaandikwa na heri (&) na inafanya machache kwenye muundo wa binari wa namba. Inapakia kila kitu cha namba kwenye viwango vya hivi, kwa baadhi ya kanuni hizo kwa viwango vya hivi vya namba:
| 第一个数字中的数位 | 第二个数字中的数位 | 结果 |
|---|---|---|
| 1 | 1 | 1 |
| 1 | 0 | 0 |
| 0 | 1 | 0 |
| 0 | 0 | 0 |
Mfano, kumaliza AND kati ya namba 25 na 3, kifaa kidhara ni kama iliyotengenezwa hapa chini:
var iResult = 25 & 3; alert(iResult); //kutumia "1"
Matokeo wa AND kati ya 25 na 3 ni 1. Kwa nini? Tafuta hapa chini:
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
Inasikitika, kwenye 25 na 3, kuna kitu kimoja (kitu cha 0) kinapatikana kwenye 1, kwa hivyo, kila kitu kingine kinapatikana kwenye 0, kwa hivyo matokeo ni 1.
Machache ya OR
Machache ya OR kinaandikwa na simu (|) na inafanya machache kwenye muundo wa binari wa namba. Kwenye uharibifu wa kila kitu, machache ya OR inatumia kanuni hizo:
| 第一个数字中的数位 | 第二个数字中的数位 | 结果 |
|---|---|---|
| 1 | 1 | 1 |
| 1 | 0 | 1 |
| 0 | 1 | 1 |
| 0 | 0 | 0 |
Kuwa na maelezo ya AND kama kinaandika, kumaliza OR kati ya 25 na 3, kifaa kidhara ni kama iliyotengenezwa hapa chini:
var iResult = 25 | 3; alert(iResult); //kutumia "27"
Matokeo wa OR kati ya 25 na 3 ni 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
Inasikitika, kwenye vifaa wengi wili, vifaa 4 vya namba vinapatikana kwenye 1, viwango hivi vinapotea kwenye matokeo. Kifaa kidhara 11011 kinaadili 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 个数位存放的是 1，这些数位被传递给结果。二进制代码 11010 等于 26。
左移运算
左移运算由两个小于号表示（<<）。它把数字中的所有数位向左移动指定的数量。例如，把数字 2（等于二进制中的 10）左移 5 位，结果为 64（等于二进制中的 1000000）：
var iOld = 2; //等于二进制 10 var iNew = iOld << 5; //等于二进制 1000000 十进制 64
注意：在左移数位时，数字右边多出 5 个空位。左移运算用 0 填充这些空位，使结果成为完整的 32 位数字。
注意：左移运算保留数字的符号位。例如，如果把 -2 左移 5 位，得到的是 -64，而不是 64。“符号仍然存储在第 32 位中吗？”是的，不过这在 ECMAScript 后台进行，开发者不能直接访问第 32 个数位。即使输出二进制字符串形式的负数，显示的也是负号形式（例如，-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。
出于这种原因，使用无符号右移运算符要小心。
- Kabla Matukio ya moja pekee
- Pya Matukio ya hisia
