Еще несколько вопросов — каковы практические применения побитовых операций? Когда вы могли бы использовать их?

Я читал статью о JavaScript, который, очевидно, поддерживает побитовые операции. Я продолжаю видеть эту операцию упомянутой в некоторых местах, и я попытался прочитать, чтобы выяснить, что именно, но я просто, кажется, не понимаю ее вообще. Так что они? Четкие примеры были бы великолепны! : D

Еще несколько вопросов — каковы практические применения побитовых операций? Когда вы могли бы использовать их?

Поскольку никто не затронул тему, почему они полезны:

Я часто использую побитовые операции при работе с флагами. Например, если вы хотите передать последовательность флагов операции (скажем, File.Open(), когда включены режимы чтения и записи), вы можете передать их как одно значение. Это достигается назначением каждому возможному флагу своего собственного бита в наборе битов (байтов, коротких, целых или длинных). Например:

 Read: 00000001
Write: 00000010

Итак, если вы хотите передать чтение и запись, вы должны передать (READ | WRITE), который затем объединит их в

00000011

, который затем можно расшифровать на другом конце, например:

if ((flag & Read) != 0) { //...

, который проверяет { *}, который возвращает

00000011 &
00000001

, который не равен 0, поэтому флаг указывает READ.

00000001

Вы можете использовать XOR для переключения различных битов. Я использовал это при использовании флага для указания направленных входов (вверх, вниз, влево, вправо). Например, если спрайт движется горизонтально, и я хочу, чтобы он поворачивался:

Я просто XOR текущего значения с помощью (LEFT | RIGHT), который в этом случае выключит LEFT и RIGHT.

     Up: 00000001
   Down: 00000010
   Left: 00000100
  Right: 00001000
Current: 00000100

Сдвиг битов полезен в нескольких случаях.

то же самое, что и

x << y

x * 2

y , если вам нужно быстро умножить на степень два, но следите за смещением 1-бита в верхний бит — это делает число отрицательный, если он не подписан. Это также полезно при работе с данными разных размеров. Например, чтение целого числа из четырех байтов:

Предполагая, что A является самым старшим байтом, а D — наименьшим. В итоге это будет выглядеть так:

int val = (A << 24) | (B << 16) | (C << 8) | D;

Цвета часто сохраняются таким образом (с самым старшим байтом, который игнорируется или используется как альфа):

A = 01000000
B = 00000101
C = 00101011
D = 11100011
val = 01000000 00000101 00101011 11100011

Чтобы снова найти значения, просто сдвиньте биты вправо, пока он не окажется внизу , а затем замаскируйте оставшиеся биты высшего порядка:

A = 255 = 11111111
R = 21 = 00010101
G = 255 = 11111111
B = 0 = 00000000
Color = 11111111 00010101 11111111 00000000

. По сути, для Red вы должны сделать следующее:

Int Alpha = Color >> 24
Int Red = Color >> 16 & 0xFF
Int Green = Color >> 8 & 0xFF
Int Blue = Color & 0xFF

0xFF — то же самое, что и 11111111 Стоит отметить, что одноразрядные таблицы истинности, перечисленные как другие ответы, работают только с одним или двумя входными битами одновременно. Что происходит, когда вы используете целые числа, такие как:

Color >> 16 = (filled in 00000000 00000000)11111111 00010101  (removed 11111111 00000000)
00000000 00000000 11111111 00010101 &
00000000 00000000 00000000 11111111 =
00000000 00000000 00000000 00010101 (The original value)

Ответ заключается в двоичном расширении каждого входа:

int x = 5 & 6;

Каждая пара битов в каждом столбце проходит через функцию «И», чтобы дать соответствующий выходной бит на Нижняя линия. Таким образом, ответ на вышеприведенное выражение — 4. Процессор выполнил (в этом примере) 8 отдельных операций «И» параллельно, по одной для каждого столбца.

  5 = 0 0 0 0 0 1 0 1
& 6 = 0 0 0 0 0 1 1 0
---------------------
      0 0 0 0 0 1 0 0

Я упоминаю об этом, потому что я до сих пор помню, как это «АГА!» момент, когда я узнал об этом много лет назад.

Побитовые операторы — это операторы, работающие по частям одновременно.

И равен 1, только если оба его входа равны 1.

ИЛИ равен 1, если один или несколько его входов равен 1.

XOR равен 1, только если ровно один из его входов равен 1.

NOT равен 1, только если его ввод равен 0.

Их лучше всего описать как таблицы истинности. Возможности входов находятся сверху и слева, результирующий бит — одно из четырех (два в случае НЕ, поскольку он имеет только один вход) значений, показанных на пересечении двух входов.

Один пример: если вам нужны только младшие 4 бита целого числа, вы И это с 15 (двоичный код 1111), поэтому:

AND|0 1      OR|0 1
--- ----    --- ----
  0|0 0       0|0 1
  1|0 1       1|1 1

XOR|0 1     NOT|0 1
--- ----    --- ---
  0|0 1        |1 0
  1|1 0

Это побитовые операторы, все они поддерживаются в JavaScript:

    203: 1100 1011
AND  15: 0000 1111
------------------
 IS  11: 0000 1011

— The { *} оператор сравнивает два бита и генерирует результат 1, если оба бита равны 1 ;, в противном случае он возвращает 0.

  • op1 & op2 — Оператор AND сравнивает два бита и генерирует результат 1, если оба бита равны 1 ;, в противном случае он возвращает 0. Оператор

  • op1 | op2 — Оператор OR сравнивает два бита и генерирует результат 1, если биты дополняют друг друга ;, в противном случае он возвращает 0. Оператор

  • op1 ^ op2 — Оператор EXCLUSIVE-OR сравнивает два бита и возвращает 1, если один из битов равен 1, и дает 0, если оба бита равны 0 или 1. Оператор

  • ~op1 — Оператор COMPLEMENT используется для инвертировать все биты операнда. Оператор

  • op1 << op2 — Оператор SHIFT LEFT перемещает биты влево, отбрасывает крайний левый бит и присваивает крайнему правому биту значение 0. Каждый шаг влево эффективно умножает op1 на 2. Оператор

  • op1 >> op2 — Оператор SHIFT RIGHT перемещает биты вправо, отбрасывает крайний правый бит и присваивает крайнему левому биту значение 0. Каждое движение вправо эффективно делит op1 пополам. Крайний левый бит знака сохраняется. Оператор

  • op1 >>> op2 — Оператор SHIFT RIGHTZERO FILL перемещает биты вправо, отбрасывает крайний правый бит и назначает крайнему левому биту значение 0. Каждое перемещение вправо эффективно делит op1 пополам. Самый левый бит знака сбрасывается.

Чтобы разобрать это немного больше, это имеет непосредственное отношение к двоичному представлению рассматриваемого значения.

For example (in decimal):
x = 8
y = 1

would come out to (in binary):
x = 1000
y = 0001

From there, you can do computational operations such as 'and' or 'or'; in this case:
x | y = 
1000 
0001 |
------
1001

or...9 in decimal

Надеюсь это поможет.

Когда упоминается термин «побитовый», иногда выясняется, что это не «логический» оператор.

Например, в JavaScript побитовые операторы обрабатывают свои операнды как последовательность из 32 битов (нулей и единиц) ;, логические операторы обычно используются с логическими (логическими) значениями , но может работать с небулевыми типами.

Take expr1 & Amp ; & Например, amp ; expr2.

Возвращает expr1, если его можно преобразовать в false ;, в противном случае возвращает expr2. Таким образом, при использовании с логическими значениями & Amp ; & Amp ; возвращает true, если оба операнда имеют значение true, ; в противном случае возвращает false.

a = "Cat" && "Dog"     // t && t returns Dog
a = 2 && 4     // t && t returns 4

Как уже отмечали другие, 2 & Amp ; 4 — это битовое AND, поэтому он возвращает 0.

Вы можете скопировать следующее в test.html или что-то еще и test: В цифровом компьютерном программировании побитовая операция работает с одной или несколькими битовыми комбинациями или двоичными числами на уровне их отдельных битов. Это быстрое примитивное действие, непосредственно поддерживаемое процессором, и используется для манипулирования значениями для сравнения и расчетов.

<html>
<body>
<script>
    alert(""Cat" && "Dog" = "   ("Cat" && "Dog")   "n"
          "2 && 4 = "   (2 && 4)   "n"
          "2 & 4 = "   (2 & 4));
</script>

поразрядно И

Спасибо, :

  • поразрядно ИЛИ

  • поразрядно НЕ

  • поразрядно XOR

  • и т. д.

  • Элемент списка

Операторы сдвига влево и вправо эквивалентны умножению и делению на x * 2

    AND|0 1        OR|0 1 
    --- ----      --- ---- 
      0|0 0         0|0 1 
      1|0 1         1|1 1 

   XOR|0 1        NOT|0 1 
   --- ----       --- --- 
     0|0 1           |1 0 
     1|1 0

напр.

    203: 1100 1011
AND  15: 0000 1111
------------------
  =  11: 0000 1011

использования побитового оператора

  • Быстрый поиск минимальных значений x и y без Мне нужно выполнить метод действия управляемого JSF-компонента с помощью ajax во время события загрузки HTML DOM, аналогично jQuery $ (document) .ready (function () {$ .ajax (…)}). Я могу использовать только сгенерированный JavaScript … соответственно.

напр.

int main()
{
     int x = 19;
     printf ("x << 1 = %dn" , x <<1);
     printf ("x >> 1 = %dn", x >>1);
     return 0;
}
// Output: 38 9
  • Оператор & Amp ; можно использовать для быстрой проверки, является ли число нечетным или четным

напр.

int main()
{
    int x = 19;
    (x & 1)? printf("Odd"): printf("Even");
    return 0;
 }
// Output: Odd
  • знака if else Преобразование десятичных чисел в двоичные

напр.

int min(int x, int y)
{
    return y ^ ((x ^ y) & - (x < y))
}
  • Шифрование на шлюзе XOR является популярным методом, поскольку оно совместимо и повторно используется программистом.

напр.

#include <stdio.h>
int main ()
{
    int n , c , k ;
    printf("Enter an integer in decimal number systemn " ) ;
    scanf( "%d" , & n );
    printf("%d in binary number
    system is: n " , n ) ;
    for ( c = 31; c >= 0 ; c -- )
    {
         k = n >> c ;
         if ( k & 1 )
              printf("1" ) ;
         else
              printf("0" ) ;
      }
      printf(" n " );
      return 0 ;
}
  • побитовый оператор XOR является наиболее полезным оператором с точки зрения технического интервью.
    • побитовое смещение работает только с ве числом

. Также существует широкий спектр использования побитовой логики

. Это может помочь в этом. Вот как работает AND (& Amp ;):

Он в основном говорит, что оба эти числа одно, поэтому, если у вас есть два числа 5 и 3, они будут преобразованы в двоичный код, и компьютер будет думаю, что

оба равны: 000000010 — ложь, 1 — истина

         5: 00000101
         3: 00000011

Так что И 5 и 3 — одно. Оператор OR (|) делает то же самое, за исключением того, что для вывода 1 должно быть только одно из чисел, а не оба.

Я продолжал слышать о том, насколько медленными были битовые операторы JavaScript. Я сделал несколько тестов для

и обнаружил, что они были на 40 % до 80 % быстрее, чем арифметическая альтернатива в нескольких тестах. Возможно, они были медленными. В современных браузерах я их люблю. Можно создать «призрачный» IFrame, который будет действовать так, как будто его там не было , У меня есть один случай в моем коде, который будет быстрее и легче читать из-за этого. Я буду держать глаза открытыми для большего.

Как исправить Array indexOf () в JavaScript для браузеров Internet Explorer — переполнение стека