Mari kita bincangkan tentang 7 jenis operator bit dalam JavaScript dan lihat bagaimana ia digunakan dalam pertempuran sebenar?

Artikel ini akan memperkenalkan anda kepada 7 jenis operator bit dalam JavaScript dan melihat cara menggunakan 7 jenis operator bit ini, saya harap ia akan membantu anda!

Operator Bitwise

Pengendali digunakan untuk operasi asas nilai, iaitu pengendalian data diwakili dalam bit ingatan (bit). Semua nilai dalam

ECMAScript disimpan dalam format IEEE 754 64-bit, tetapi operasi bit tidak digunakan secara langsung pada perwakilan 64-bit Sebaliknya, nilai ditukar kepada Integer 32-bit dahulu, dan kemudian operasi bit dan kemudian tukar hasilnya kepada 64 bit.

Bagi pembangun, ia seolah-olah hanya terdapat integer 32-bit, kerana format storan integer 64-bit tidak kelihatan. Sekarang kita tahu ini, kita hanya perlu mempertimbangkan integer 32-bit.

Integer yang ditandatangani menggunakan 31 bit pertama 32 bit untuk mewakili nilai integer. Bit 32 mewakili tanda nilai, seperti 0 menunjukkan positif dan 1 menunjukkan negatif. Bit ini dipanggil bit tanda, dan nilainya menentukan format nilai yang selebihnya. Nilai positif disimpan dalam format binari sebenar, iaitu setiap satu daripada 31 bit mewakili kuasa 2. Bit pertama (dipanggil bit 0) mewakili 20 , bit kedua mewakili 21 , dan seterusnya.

Jika sedikit kosong, ia diisi dengan 0, yang bersamaan dengan mengabaikannya. Sebagai contoh, format binari nilai 18 ialah 000000000000000000000000010010, atau lebih padat 10010. Yang terakhir ialah 5 bit sah yang digunakan untuk menentukan nilai sebenar (seperti yang ditunjukkan dalam rajah di bawah).

Bitwise NOT～

Operator bitwise NOT menggunakan tilde (~) bermaksud bahawa fungsinya adalah untuk mengembalikan pelengkap nilai seseorang. Bitwise NOT ialah salah satu daripada beberapa operator matematik binari dalam ECMAScript. Lihat contoh berikut:

let num1 = 25; //二进制 00000000000000000000000000011001
let num2 = ~num1; // 二进制 11111111111111111111111111100110
console.log(num2); // -26

Di sini, operator NOT bitwise digunakan pada nilai 25, dan hasilnya ialah 26. Dapat dilihat bahawa kesan akhir bitwise not ialah menyongsangkan nilai dan menolak 1, sama seperti hasil daripada melaksanakan operasi berikut:

let num1 = 25;
let num2 = -num1 - 1;
console.log(num2); // "-26"

Malah, walaupun kedua-duanya mengembalikan hasil yang sama, Tetapi operasi bit adalah lebih cepat. Ini kerana operasi bit dilakukan pada perwakilan asas nilai berangka.

Bitwise DAN &

Pengendali bitwise AND diwakili oleh ampersand (&) dan mempunyai dua operan. Pada asasnya, bitwise AND adalah untuk menjajarkan setiap bit dua nombor, dan kemudian melaksanakan operasi AND yang sepadan pada setiap bit berdasarkan peraturan dalam jadual kebenaran.

Operasi bitwise AND mengembalikan 1 jika kedua-dua bit adalah 1 dan 0 jika mana-mana bit adalah 0. Mari lihat contoh di mana kita melakukan operasi DAN pada nilai 25 dan 3 seperti berikut:

let result = 25 & 3;
console.log(result); // 1 25 和 3 的按位与操作的结果是 1。

Kenapa? Lihat proses pengiraan binari di bawah:

Seperti yang ditunjukkan dalam rajah di atas, dalam perwakilan binari 25 dan 3, hanya dua nombor dalam bit ke-0 adalah 1. Semua bit lain nilai hasil kemudiannya diisi dengan 0s, jadi hasilnya ialah 1.

Bitwise ATAU ｜

Pengendali bitwise OR diwakili oleh simbol paip (|) dan juga mempunyai dua operan. Bitwise OR mengikut jadual kebenaran berikut:

Operasi bitwise OR mengembalikan 1 jika sekurang-kurangnya satu bit ialah 1 dan mengembalikan 0 jika kedua-dua bit adalah 0. Masih menggunakan contoh bitwise AND, jika bitwise OR dilakukan pada 25 dan 3, kodnya adalah seperti berikut:

let result = 25 | 3;
console.log(result); // 27

Dapat dilihat bahawa hasil operasi OR bitwise pada 25 dan 3 ialah 27:

Dalam dua nombor yang terlibat dalam pengiraan, 4 digit semuanya 1, jadi ia sepadan secara langsung dengan hasilnya. Kod binari 11011 adalah sama dengan 27.

Bitwise XOR ^

Bitwise XOR diwakili oleh karet (^), yang juga mempunyai dua operan. Berikut ialah jadual kebenaran bitwise XOR:

Perbezaan antara bitwise XOR dan bitwise OR ialah ia hanya mengembalikan 1 apabila satu bit adalah 1 (Jika kedua-dua bit adalah 1 atau 0, 0 dikembalikan). Lakukan operasi XOR bitwise pada nilai 25 dan 3:

let result = 25 ^ 3;
console.log(result); // 26

Dapat dilihat bahawa hasil operasi XOR bitwise bagi 25 dan 3 ialah 26, seperti ditunjukkan di bawah:

两个数在 4 位上都是 1，但两个数的第 0 位都是 1，因此那一位在结果中就变成了 0。其余位上的 1 在另一个数上没有对应的 1，因此会直接传递到结果中。二进制码 11010 等于 26。（注意，这比对同样 两个值执行按位或操作得到的结果小 1。）

左移

左移操作符用两个小于号（

let oldValue = 2; // 等于二进制 10
let newValue = oldValue << 5; // 等于二进制 1000000，即十进制 64

注意在移位后，数值右端会空出 5 位。左移会以 0 填充这些空位，让结果是完整的 32 位数值（见下图）。

注意，左移会保留它所操作数值的符号。比如，如果-2 左移 5 位，将得到-64，而不是正 64。

有符号右移

有符号右移由两个大于号（>>）表示，会将数值的所有 32 位都向右移，同时保留符号（正或负）。 有符号右移实际上是左移的逆运算。比如，如果将 64 右移 5 位，那就是 2：

let oldValue = 64; // 等于二进制 1000000
let newValue = oldValue >> 5; // 等于二进制 10，即十进制 2

同样，移位后就会出现空位。不过，右移后空位会出现在左侧，且在符号位之后（见图 3-3）。 ECMAScript 会用符号位的值来填充这些空位，以得到完整的数值。

无符号右移

无符号右移用 3 个大于号表示（>>>），会将数值的所有 32 位都向右移。对于正数，无符号右移与 有符号右移结果相同。仍然以前面有符号右移的例子为例，64 向右移动 5 位，会变成 2：

let oldValue = 64; // 等于二进制 1000000 
let newValue = oldValue >>> 5; // 等于二进制 10，即十进制 2

对于负数，有时候差异会非常大。与有符号右移不同，无符号右移会给空位补 0，而不管符号位是 什么。对正数来说，这跟有符号右移效果相同。但对负数来说，结果就差太多了。无符号右移操作符将负数的二进制表示当成正数的二进制表示来处理。因为负数是其绝对值的二补数，所以右移之后结果变 得非常之大，如下面的例子所示：

let oldValue = -64; // 等于二进制 11111111111111111111111111000000
let newValue = oldValue >>> 5; // 等于十进制 134217726

在对-64 无符号右移 5 位后，结果是 134 217 726。这是因为-64 的二进制表示是 1111111111111111111 1111111000000，无符号右移却将它当成正值，也就是 4 294 967 232。把这个值右移 5 位后，结果是 00000111111111111111111111111110，即 134 217 726。

实战中的妙用

1.判断奇偶数

// 偶数 & 1 = 0
// 奇数 & 1 = 1
console.log(2 & 1) // 0
console.log(3 & 1) // 1

2. 使用<span style="font-size: 16px;">^</span><span style="font-size: 16px;"></span>来完成值的交换

let a = 2
let b = 5
a ^= b
b ^= a
a ^= b
console.log(a) // 5
console.log(b) // 2

3. 使用<span style="font-size: 16px;">~</span><span style="font-size: 16px;"></span>进行判断

// 常用判断
if (arr.indexOf(item) > -1) {
    // code
}
// 按位非    ~-1 = -(-1) - 1 取反再 -1
if (~arr.indexOf(item)) {
    // code
}

4. 使用&<span style="font-weight: bold; font-size: 16px;"></span><span style="font-family:Microsoft Yahei, Hiragino Sans GB, Helvetica, Helvetica Neue, 微软雅黑, Tahoma, Arial, sans-serif">、</span>、<strong><span style="font-size: 16px;">|</span></strong><span style="font-size: 16px;"></span>来完成rgb值和16进制颜色值之间的转换

/**
 * 16进制颜色值转RGB
 * @param  {String} hex 16进制颜色字符串
 * @return {String}     RGB颜色字符串
 */
  function hexToRGB(hex) {
    var hexx = hex.replace('#', '0x')
    var r = hexx >> 16
    var g = hexx >> 8 & 0xff
    var b = hexx & 0xff
    return `rgb(${r}, ${g}, ${b})`
}

/**
 * RGB颜色转16进制颜色
 * @param  {String} rgb RGB进制颜色字符串
 * @return {String}     16进制颜色字符串
 */
function RGBToHex(rgb) {
    var rgbArr = rgb.split(/[^\d]+/)
    var color = rgbArr[1]<<16 | rgbArr[2]<<8 | rgbArr[3]
    return '#'+ color.toString(16)
}
// -------------------------------------------------
hexToRGB('#ffffff')               // 'rgb(255,255,255)'
RGBToHex('rgb(255,255,255)')      // '#ffffff'

5. 使用<span style="font-size: 16px;">|</span>、<span style="font-size: 16px;">~</span>、、<span style="font-size: 16px;"></span>、来取整

console.log(~~ 3.1415)    // 3
console.log(3.1415 >> 0)  // 3
console.log(3.1415 << 0)  // 3
console.log(3.1415 | 0)   // 3
// >>>不可对负数取整
console.log(3.1415 >>> 0)   // 3

【相关推荐：javascript学习教程】

Atas ialah kandungan terperinci Mari kita bincangkan tentang 7 jenis operator bit dalam JavaScript dan lihat bagaimana ia digunakan dalam pertempuran sebenar?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!