[javascript] 부울에서 비트 단위 연산은 어떻게 작동합니까?

비트 연산자는 항상 피연산자를 정수로 변환합니다. 따라서 한 위치만큼 비트 시프트를 수행하는 4 >> true것과 동일합니다.4 >> 1

(decimal) 4 = (binary) 100

(binary) 100 >> 1 = (binary) 010

(binary) 010 = (decimal) 2

console.log(4 >> true);

그래서, 사용 true또는 것은 false사용에 단지 로터리 방법 1나 0.

이 notNotNot기능은 전체적으로 매우 간단한 작업을 수행합니다.

1. a%2첫 번째 숫자 0를 짝수 또는 1홀수 로 변환합니다 .
2. >> b두 0위치 중 하나를 오른쪽으로 이동false 또는 1위치 합니다 true.
   • a 홀수 (1) b이다 false=1
     • 오른쪽으로 0의 시프트가 있으므로 숫자는 동일하게 유지됩니다.
   • a 홀수 (1) b이다 true=0
     • 유일하게 설정된 비트 1 오른쪽으로 이동하여 버립니다.
   • a 짝수 (0)이고 b인 false=0
     • 오른쪽으로 0의 시프트가 있으므로 숫자는 동일하게 유지됩니다.
   • a 짝수 (0)이고 b인 true=0
     • 기본 번호는 0비트가 설정되어 있지 않으므로 금액을 오른쪽으로 이동해도 변경되지 않습니다.
3. !!() 결과를 부울로 변환합니다.

그렇게 말 때문에, 여기에 해결책은, 잘못 notNotNot(2, true)생성 할 것이다 false– a도하고 b있다 true. 기대는 그것이 true이후 생산 될 것이라는 것입니다!!true = true . 짝수와에 동일한 문제가 true있습니다.

오른쪽 시프트 대신 비트 XOR을 사용하여 쉽게 수정할 수 있습니다.

• a홀수 (1)이다 b이다 false=1
  • 둘 다 일치하므로 0
• a홀수 (1)이다 b이다 true=0
  • 일치하지 않기 때문에 1
• a심지어 (0)이고, b인 false=0
  • 둘 다 일치하므로 0
• a심지어 (0)이고, b인 true=1
  • 일치하지 않기 때문에 1

notNotNot = (a,b) => !!(a%2 ^ b);

console.log("!!true = ", notNotNot(2, true))
console.log("!!!true =", notNotNot(3, true))
console.log("!!false = ", notNotNot(2, false))
console.log("!!!false = ", notNotNot(3, false))

//bonus
console.log("true = ", notNotNot(0, true))
console.log("false = ", notNotNot(0, false))

완전한 비트 단위 연산을 원할 경우 완전성을 위해 다음을 수행하십시오.

모듈로 연산 %2을 비트 단위로 변경 &1하고 가장 낮은 비트를 얻을 수 있습니다 . 짝수의 0경우 컴퓨팅을 시작한 이후로

xxx0
&
0001

이것은 0입니다. 홀수에 대해서도 동일하지만 결과는 1입니다.

xxx1
&
0001

결과 지금 a&1과는 a%2동일하다. 또한 비트 단위 연산 은 숫자를 32 비트 부호있는 정수로 변환 하지만 패리티 가 유지 되므로 중요하지 않습니다 .

//larger than 31 bits
const largeValue = 2**31 + 1;
//larger than 32 bits
const veryLargeValue = 2**32 + 1

console.log("2**31 + 1 =", largeValue);
console.log("2**32 + 1 =", veryLargeValue);

console.log("2**31 + 1 to 32-bit signed integer =", largeValue | 0);
console.log("2**32 + 1 to 32-bit signed integer = ", veryLargeValue | 0);

const isOddModulo = number =>
  console.log(`(${number} % 2) can detect an odd number: ${(number % 2) === 1}`);

const isOddBitwise = number =>
  console.log(`(${number} & 1) can detect an odd number: ${(number & 1) === 1}`);

isOddModulo(largeValue);
isOddBitwise(largeValue);

isOddModulo(veryLargeValue);
isOddBitwise(veryLargeValue);

답변

(a%2)  //ignore all but the least significant bit (LSB)
(a%2 >> b )  //if TRUE,  shifts right, resolves to 0
               //if FALSE, no shift,     resolves to LSB

// 0 and LSB are both integers so convert to boolean by using logical/boolean NOT
!(a%2 >> b ) //resolves to the boolean which it is NOT
!!(a%2 >> b ) //resolves to the boolean which it is NOT NOT

/* Create a function where given n number of "not",
   evaluate whether it's true or false.*/

function not(n) {
  return Boolean(n - n - 1);
}

function not(n) {
  return Boolean(bool ^ (bool - 1));
}

function not(n) {
  return Boolean(n % 2);
}

function not(n) {
  return Boolean(n & 1);
}

not(0)
//> false 
not(1)
//> true
not(2)
//> false
not(515)
//> true

notNotNot(oddNumber, true)  ➞ false
notNotNot(evenNumber, true) ➞ true

notNotNot(oddNumber, false)  ➞ true
notNotNot(evenNumber, false) ➞ false

a%2 == 0 ➞ even number
a%2 == 1 ➞ odd number

// For a%2 == 0

a%2 >> b ➞ if b is true  ➞ 0 >> 1 ➞ 0   // Not working
a%2 >> b ➞ if b is false ➞ 0 >> 0 ➞ 0


// For a%2 == 1

a%2 >> b ➞ if b is true  ➞ 1 >> 1 ➞ 0
a%2 >> b ➞ if b is false ➞ 1 >> 0 ➞ 1

a%2 == 0 ➞ even number
a%2 == 1 ➞ odd number

// For a%2 == 0

a%2 ^ b ➞ if b is true  ➞ 0 ^ 1 ➞ 1   // Now working
a%2 ^ b ➞ if b is false ➞ 0 ^ 0 ➞ 0


// For a%2 == 1

a%2 ^ b ➞ if b is true  ➞ 1 ^ 1 ➞ 0
a%2 ^ b ➞ if b is false ➞ 1 ^ 0 ➞ 1

!(a%2 ^ b) use `!` to make int as boolean but solution result will reversed then
!!(a%2 ^ b) use `!` again to reversed it again and make it correct.

notNotNot = (a,b) => !!(a%2 ^ b);

console.log("!!!!true = ", notNotNot(4, true))
console.log("!!!!false = ", notNotNot(4, false))
console.log("!!!true =", notNotNot(3, true))
console.log("!!!false = ", notNotNot(3, false))