JavaScript 일반 바이너리 변환 및 비트 연산 인스턴스 해석

앞말
일반적인 코드에서는 진수와 비트 연산을 거의 접하지 못하지만, 이것은 우리가 그것을 배우지 않을 수 있다는 것을 대표하지 않는다.프로그래머로서 이것들은 모두 기초 지식이다.만약 네가 이 방면의 지식을 배운 적이 없다면, 당황하지 마라. 다음 지식은 결코 어렵지 않을 것이다.본문을 당신은 다음과 같이 배울 것입니다.

진법 변환

비트 조작부호

JavaScript 바이너리 변환

수동으로 진법 변환 실현

진수 변환
다음은 흔히 볼 수 있는 10진법과 2진법의 전환을 예로 들면 다른 진법의 전환도 대동소이하기 때문에 흥미가 있으면 스스로 생각해 볼 수 있다.
십진법
'10진일'의 법칙에 따라 계수를 할 때 10개의 같은 단위마다 그와 인접한 비교적 높은 단위를 구성한다. 이런 계수법을 10진법계수법이라고 하는데 약칭 10진법이라고 한다.이런 것은 우리가 가장 자주 사용하는 계수법이다.
정수
정수는'2를 제외한 나머지 역순 배열'을 사용하여 2진법으로 변환합니다. 다음은 18에서 2진법으로 변환하는 예입니다.
//을 제외한 나머지
18/2 = 9...0
9/2 = 4...일
4/2 = 2...0
2/2 = 1...0
1/2 = 0...일
//역순 정렬
10010
이렇게 간단하게 나온 여수를 역순으로 배열하면 18의 2진법 표시를 얻을 수 있다
소수
소수는 곱하기 2를 사용하여 정렬하고 순서 배열을 하는데 방법이 다르기 때문에 따로 계산해야 한다.다음은 16.125에서 2진법으로 전환하는 예입니다.
16/2 = 8...0
8/2 = 4...0
4/2 = 2...0
2/2 = 1...0
1/2 = 0...일
0.125 * 2 = 0.25
0.25 * 2 = 0.5
0.5 * 2 = 1
10000.001
소수를 곱한 결과, 결과의 정수 순서를 배열하여 소수위의 2진법 표시를 얻어낸다
2진법
'이일진일'의 법칙에 따라 계수를 할 때 두 개의 같은 단위마다 그와 인접한 비교적 높은 단위를 구성한다. 이런 계수법을 이진계수법이라고 하는데 약칭 이진법이라고 한다.2진수로 계산할 때, 단지 두 개의 독립된 기호'0'과'1'으로 표시하기만 하면 된다.
정수
정수는'권리에 따라 더하기'법을 사용한다. 즉, 2진수는 먼저 가중 계수 전개식으로 쓴 다음에 10진법 덧셈 규칙에 따라 화합을 구한다.다음은 101010 변환 비트 10진법의 예입니다.
2^5 2^4 2^3 2^2 2^1 2^0
1 0 1 0 1 0
------------------------
32 + 0 + 8 + 0 + 2 + 0 = 42
위에는 오른쪽에서 2의 0번, 2의 1번, 2의 2번...비트가 1인 결과만 취하고 그것들을 더하면 10진법을 얻을 수 있다.
소수
10110.11 바이트 10진수:
2^4 2^3 2^2 2^1 2^0 2^-1 2^-2
1 0 1 1 0 . 1 1
-------------------------------
16 + 0 + 4 + 2 + 0 + 0.5 + 0.25 = 22.75
비트 조작 부호
비트 조작부호(Bitwise operators)는 그 조작수(operands)를 32비트의 비트 서열(0과 1로 구성), 31비트는 정수의 수치, 32비트는 정수의 기호, 0은 정수, 1은 음수를 나타낸다.예를 들어 10진수 18은 2진수로 10010을 나타낸다.비트 조작부호로 숫자의 바이너리 형식을 조작하지만, 반환 값은 여전히 표준 자바스크립트 수치입니다.
And(And)
모든 비트 비트에 대해 두 개의 조작수에 상응하는 비트 비트만 1일 때 결과는 1이고 그렇지 않으면 0이다.
용법: a&b.
9 (base 10) = 00000000000000000000000000001001 (base 2)
14 (base 10) = 00000000000000000000000000001110 (base 2)
--------------------------------
14 & 9 (base 10) = 00000000000000000000000000001000 (base 2) = 8 (base 10)
하나의 숫자 짝을 판단할 때 a&1을 사용할 수 있다
function assert(n) {
return n & 1 ? 홀수: 짝수
}
assert(3)//홀수
홀수의 2진법 마지막 자리는 1이고, 1의 2진법 마지막 자리도 1이기 때문에 & 조작부호를 통해 결과는 1이다
비트 또는 (OR)
각 비트 비트에 대해 두 조작수에 상응하는 비트 비트가 적어도 1개가 있을 때 결과는 1이고 그렇지 않으면 0이다.
사용법: a | b
9 (base 10) = 00000000000000000000000000001001 (base 2)
14 (base 10) = 00000000000000000000000000001110 (base 2)
--------------------------------
14 | 9 (base 10) = 00000000000000000000000000001111 (base 2) = 15 (base 10)
부동 소수점을 아래로 정수로 변환하여 a | 0 사용 가능
12.1 | 0//12
12.9 | 0//12
비트별 또는 (XOR)
각 비트 비트에 대해 두 조작수에 상응하는 비트 비트가 있고 하나밖에 없을 때 결과는 1이고 그렇지 않으면 0이다.
사용법: a^b
9 (base 10) = 00000000000000000000000000001001 (base 2)
14 (base 10) = 00000000000000000000000000001110 (base 2)
--------------------------------
14 ^ 9 (base 10) = 00000000000000000000000000000111 (base 2) = 7 (base 10)
비트별로 없음(NOT)
동작 수의 비트 비트를 반전합니다. 즉, 0이 1이 되고 1이 0이 됩니다.
용법:~a
9 (base 10) = 00000000000000000000000000001001 (base 2)
--------------------------------
~9 (base 10) = 11111111111111111111111111110110 (base 2) = -10 (base 10)
두 번의 반전 작업을 통해 부동 소수점을 아래로 정렬하여 정수로 변환
~~16.125//16
~~16.725//16
왼쪽으로 이동(Left shift)
a의 바이너리 형식을 왼쪽으로 b(<32)비트로 옮기고 오른쪽은 0으로 채웁니다.
사용법: a << b
9 (base 10): 00000000000000000000000000001001 (base 2)
--------------------------------
9 << 2 (base 10): 00000000000000000000000000100100 (base 2) = 36 (base 10)
왼쪽으로 한 자리를 옮기는 것은 원래 숫자를 바탕으로 2를 곱하는 것과 같다. 이 특징을 이용하여 2의 n차방을 실현한다.
function power(n) {
return 1 << n
}
power(3)//8
오른쪽으로 기호 이동
a의 바이너리를 오른쪽으로 b(<32)비트를 이동하고 이동된 비트를 버립니다.
사용법: a > b
9 (base 10): 00000000000000000000000000001001 (base 2)
--------------------------------
9 >> 2 (base 10): 00000000000000000000000000000010 (base 2) = 2 (base 10)
비교해 보면 - 9>>2는 - 3을 얻는다. 기호가 보존되어 있기 때문이다.
-9 (base 10): 11111111111111111111111111110111 (base 2)
--------------------------------
-9 >> 2 (base 10): 11111111111111111111111111111101 (base 2) = -3 (base 10)
왼쪽으로 이동하는 것과 반대로 오른쪽으로 이동하는 것은 원래의 숫자를 바탕으로 2를 나눈다
64 >> 1//32
기호 없이 오른쪽으로 이동
a의 바이너리를 오른쪽으로 b(<32)비트를 이동하고 이동된 비트를 버리고 0을 사용하여 왼쪽에 채웁니다.
사용법: a>>b
비음수로 말하자면, 9>>2와 9>2는 모두 같은 결과이다
9 (base 10): 00000000000000000000000000001001 (base 2)
--------------------------------
9 >>> 2 (base 10): 00000000000000000000000000000010 (base 2) = 2 (base 10)
음수에 대해 말하자면 결과는 크게 다르다. 왜냐하면 >>는 기호를 보존하지 않고 음수가 기호가 오른쪽으로 이동하지 않을 때 0으로 채우기 때문이다.
-9 (base 10): 11111111111111111111111111110111 (base 2)
--------------------------------
-9 >>> 2 (base 10): 00111111111111111111111111111101 (base 2) = 1073741821 (base 10)
기호가 없는 오른쪽으로 이동하여 한 수의 양과 음을 판단할 수 있다

function isPos(n) {
  return (n === (n >>> 0)) ? true : false;
}

isPos(-1); // false
isPos(1); // true

비록 -1>>>0은 오른쪽 이동이 일어나지 않지만, -1의 2진 코드는 이미 정수의 2진 코드로 변했다. -1>>>0 결과는 4294967295이다
Javascript 바이너리 변환
toString
toString은 변수를 문자열로 바꾸거나 변수의 유형을 판단하는 데 사용됩니다. 예를 들어 다음과 같습니다.
let arr = []
Object.prototype.toString.call(arr)//[object Array]
ToString이 진법 변환에 사용될 수 있다는 생각은 하지 않았을 것입니다. 다음 예를 보십시오.
(18).toString(2)//10010(base 2)
(18).toString(8)//22 (base 8)
(18).toString(16)//12 (base 16)
매개 변수는 숫자의 기수를 표시하도록 규정하고 있으며, 2~36 사이의 정수이며, 이 매개 변수를 생략하면 기수 10을 사용한다.이 매개 변수는 변환된 진수 표시로 이해할 수 있다.
parseInt
parseInt는 숫자 정정에 자주 사용되며, 매개 변수를 바이너리 변환에 전송할 수도 있습니다. 다음 예를 보십시오.
parseInt(10010, 2)//18 (base 10)
parseInt(22, 8)//18 (base 10)
parseInt(12, 16)//18 (base 10)
두 번째 매개 변수는 해석할 숫자의 기수를 나타낸다. 이 값은 2~36 사이이다.매개변수를 생략하거나 값이 0이면 숫자는 10을 기준으로 해석됩니다.매개변수가 2보다 작거나 36보다 크면 parseInt는 NaN으로 돌아갑니다.
면접 문제가 이렇게 된 것을 기억한다.
//질문: 반환된 결과
[1, 2, 3].map(paseInt)
다음은 과정에 무슨 일이 일어났는지 한 걸음 한 걸음 살펴보자.
parseInt(1,0)//기수가 0일 때 10을 기수로 해석한 결과 1
parseInt(2,1)//기수가 2 ~ 36 범위에 맞지 않음, 결과는 NaN
parseInt(3,2)//여기서 2를 기수로 해석하지만 3은 2진법이 아니기 때문에 결과는 NaN
//제목 결과
[1, NaN, NaN]
수동으로 진법 변환을 실현하다
JavaScript는 우리에게 진법 변환의 함수를 내장했지만 수동으로 진법 변환을 실현하는 것은 우리가 과정을 이해하고 논리 능력을 향상시키는 데 도움이 된다.초보자에게도 좋은 연습 예다.다음은 비음정수의 전환만 간단하게 실현한다.
십진법
'제2취여'의 사고방식에 기초하여 실현하다

function toBinary(value) {
  if (isNaN(Number(value))) {
    throw `${value} is not a number` 
  }
  let bits = []
  while (value >= 1) {
    bits.unshift(value % 2)
    value = Math.floor(value / 2)
  }
  return bits.join('')
}

활용단어참조
toBinary(36)//100100
toBinary(12)//1100
2진법
'멱을 취하고 덧붙이는'사고방식에 기초하여 실현하다

function toDecimal(value) {
 let bits = value.toString().split('')
 let res = 0
 while (bits.length) {
  let bit = bits.shift()
  if (bit == 1) {
   // **  ， ：2**3   8
   res += 2 ** bits.length
  }
 }
 return res
}

활용단어참조
toDecimal(10011)//19
toDecimal(11111)//33
마지막에 쓰다
본고는 모두에게 진법과 비트 연산에 관한 지식을 소개하였는데, 온고지신을 목적으로 한다.우리는 대충 알기만 하면 된다. 왜냐하면 개발에서 정말 적게 사용되기 때문이다. 적어도 나는 ~~로 정리한 적이 있기 때문이다.이와 유사하게 ~~와 같은 정정 작업은 가능한 한 적게 사용하는 것이 좋으며 다른 개발자에게는 코드의 가독성에 영향을 줄 수 있다.
이상은 본문의 전체 내용입니다. 여러분의 학습에 도움이 되고 저희를 많이 응원해 주십시오.