Почему | побитовый оператор OR оценивает обе стороны, когда 1 находится в первой стороне? [Дубликат]

Question

Почему | побитовый оператор OR оценивает обе стороны, когда 1 находится в первой стороне? [Дубликат]

Нет единого межплатформенного API, вам нужно будет проверить наличие ОС. Для использования на основе posix / proc. Для Windows используйте следующий код, чтобы получить список всех pids с соответствующими именами процессов

from win32com.client import GetObject
WMI = GetObject('winmgmts:')
processes = WMI.InstancesOf('Win32_Process')
process_list = [(p.Properties_("ProcessID").Value, p.Properties_("Name").Value) for p in processes]

. Затем вы можете легко отфильтровывать процессы, которые вам нужны. Для получения дополнительной информации о доступных свойствах Win32_Process проверьте класс Win32_Process

115

javascript bitwise-operators

задан meagar 12 April 2016 в 15:31

9 ответов

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

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

Возьмите expr1 & amp; & amp; expr2, например.

Возвращает expr1, если его можно преобразовать в false; в противном случае возвращает expr2. Таким образом, при использовании с булевыми значениями & amp; & amp; возвращает true, если оба операнда истинны; в противном случае возвращает false.
a = "Cat" && "Dog"     // t && t returns Dog
a = 2 && 4     // t && t returns 4
Как отмечали другие, 2 & amp; 4 - побитовое И, поэтому оно вернет 0.

Вы можете скопировать следующее в test.html или что-то еще и проверить:
<html>
<body>
<script>
    alert("\"Cat\" && \"Dog\" = " + ("Cat" && "Dog") + "\n"
        + "2 && 4 = " + (2 && 4) + "\n"
        + "2 & 4 = " + (2 & 4));
</script>

4

ответ дан Eugene Yokota 19 August 2018 в 19:05

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

int x = 5 & 6;

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

  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

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

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

24

ответ дан Greg Hewgill 19 August 2018 в 19:05

1

Вау, теперь это намного больше. Это звучало намного сложнее, чем кажется. Благодарю. Я не уверен, что выбрать правильный ответ, поскольку есть множество хороших, и я не могу выдвигать так. Спасибо – click 10 November 2008 в 01:21

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

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

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

4

ответ дан javamonkey79 19 August 2018 в 19:05

1

| - операция OR? – Si8 3 August 2016 в 20:50
2

По какой-то причине это имело для меня смысл. Все еще не уверен в части x | y = 1000 0001 |, хотя – samayo 17 March 2017 в 11:45

Побитовые операторы - это операторы, которые работают по битам за раз.

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

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

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

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

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

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

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

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

24

ответ дан paxdiablo 19 August 2018 в 19:05

Я слышал о том, насколько медленными были побитовые операторы JavaScript. Я сделал несколько тестов для моего последнего сообщения в блоге и выяснил, что они были на 40-80% быстрее, чем арифметическая альтернатива в нескольких тестах. Возможно, они были медленными. В современных браузерах я их люблю.

У меня есть один случай в моем коде, который будет быстрее и легче читать из-за этого. Я буду держать глаза открытыми для большего.

1

ответ дан Peter Mortensen 19 August 2018 в 19:05

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

побитовое И

побитовое ИЛИ

побитовое NOT

побитовое XOR

и т. Д.

Элемент списка
    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 * 2y соответственно.

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

Например.
int main()
{
    int x = 19;
    (x & 1)? printf("Odd"): printf("Even");
    return 0;
 }
// Output: Odd
Быстрый поиск минимума x и y без if else statment

Например:
int min(int x, int y)
{
    return y ^ ((x ^ y) & - (x < y))
}
Десятичное значение для двоичного преобразования

Например.
#include <stdio.h>
int main ()
{
    int n , c , k ;
    printf("Enter an integer in decimal number system\n " ) ;
    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 является популярным методом, благодаря его усложнению и повторному использованию программистом. побитовый оператор XOR является наиболее полезным оператором с точки зрения технического интервью.

смещение битвуза работает только с + ve числом

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

2

ответ дан Prashant Kumar 19 August 2018 в 19:05

1

«сложность и редкая ...» ? – Jonathan Cross 24 September 2017 в 13:35

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

op1 & op2 - Оператор AND сравнивает два бита и генерирует результат 1, если оба бита равны 1; в противном случае он возвращает 0.
op1 | op2 - Оператор OR сравнивает два бита и генерирует результат 1, если биты являются дополнительными; в противном случае он возвращает 0.
op1^ op2 - оператор EXCLUSIVE-OR сравнивает два бита и возвращает 1, если один из битов равен 1, и он дает 0, если оба бита равны 0 или 1.
~op1 - Оператор C OMPLEMENT используется для инвертирования всех бит операнда.
op1 << op2 - Оператор SHIFT LEFT перемещает биты в left, отбрасывает крайний левый бит и присваивает самый правый бит значение 0. Каждое перемещение влево эффективно умножает op1 на 2.
op1 >> op2 - The SHIFT RIGHT оператор перемещает биты в right, отбрасывает крайний правый бит и назначает крайний левый бит значением 0. Каждое перемещение вправо эффективно делит op1 пополам. Значок бит слева сохраняется.
op1 >>> op2 - The SHIFT RIGHT - оператор ZERO FILL перемещает биты вправо, отбрасывает правый правый бит и назначает крайний левый бит значение 0. Каждое движение вправо эффективно делит op1 пополам. Самый старший бит бит отбрасывается.

14

ответ дан samayo 19 August 2018 в 19:05

1

Не на всех языках. – Jason Jackson 10 November 2008 в 01:07

1

ответ дан Peter Mortensen 31 October 2018 в 05:19

Другие вопросы по тегам:

javascript bitwise-operators

Похожие вопросы:

Вау, теперь это намного больше. Это звучало намного сложнее, чем кажется. Благодарю. Я не уверен, что выбрать правильный ответ, поскольку есть множество хороших, и я не могу выдвигать так. Спасибо — click, 10 November 2008 в 01:21
По какой-то причине это имело для меня смысл. Все еще не уверен в части x | y = 1000 0001 |, хотя — samayo, 17 March 2017 в 11:45

score 170 · Accepted Answer

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

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

 Read: 00000001
Write: 00000010

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

00000011

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

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

, который проверяет

00000011 &
00000001

, который возвращает

00000001

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

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

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

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

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

x << y

совпадает с

x * 2y
< / blockquote>
, если вам нужно быстро умножить на мощность в два, но следите за переходом 1-битного в верхний бит - это делает число отрицательным, если оно не указано. Это также полезно при работе с различными размерами данных. Например, чтение целого числа из четырех байтов:
int val = (A << 24) | (B << 16) | (C << 8) | D;
Предполагая, что A является наиболее значимым байтом, а D - наименьшим. Это будет выглядеть так:
A = 01000000
B = 00000101
C = 00101011
D = 11100011
val = 01000000 00000101 00101011 11100011
Цвета часто сохраняются таким образом (с самым значительным байтом, который игнорируется или используется как Alpha):
A = 255 = 11111111
R = 21 = 00010101
G = 255 = 11111111
B = 0 = 00000000
Color = 11111111 00010101 11111111 00000000
Чтобы найти значения снова, просто сдвиньте биты вправо до тех пор, пока он не окажется внизу, затем замаскируйте оставшиеся разряды более высокого порядка:
Int Alpha = Color >> 24
Int Red = Color >> 16 & 0xFF
Int Green = Color >> 8 & 0xFF
Int Blue = Color & 0xFF
0xFF - это то же самое, что и 11111111. Так что, по сути, для Red вы бы сделайте это:
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)

+1 это единственный хороший ответ — TrojanName, 13 July 2011 в 13:38
TrojanName не является комментарием будущего доказательства! — Ben Taliadoros, 26 October 2016 в 10:01