Programming with JS: Bitwise Operations - Lee-hyuna/33-js-concepts-kr GitHub Wiki

์ด ์ผ๋ จ์˜ ๊ธฐ์‚ฌ์—์„œ๋Š” JavaScript์˜ prism๊ณผ ๋‹ค๋ฅธ ์ปดํ“จํ„ฐ ๊ณผํ•™ ์ฃผ์ œ๋ฅผ ์‚ดํŽด๋ด…๋‹ˆ๋‹ค. ์šฐ๋ฆฌ๋Š” ์ด๋ฏธ ๋‹ค์–‘ํ•œ ์•Œ๊ณ ๋ฆฌ์ฆ˜์„ ์•Œ๊ณ ์žˆ๊ณ  ๋งŽ์€ ๋ฐฐ์—ด๋“ค์„ ์ •๋ ฌํ–ˆ์Šต๋‹ˆ๋‹ค. ๊ทผ๋ณธ์ ์ธ ๊ฐœ๋…์„ ์žŠ์ง€ ์•Š๋Š” ๊ฒƒ์ด ์ œ์ผ ์ค‘์š”ํ•œ ๊ฒƒ์ž…๋‹ˆ๋‹ค.

๋น„ํŠธ๋กœ ์•Œ๋ ค์ง„ 1๊ณผ 0 ์ค‘ ๊ฐ€์žฅ ๊ทผ๋ณธ์ ์ธ ๊ฒƒ์„ ์˜๋ฏธํ•ฉ๋‹ˆ๋‹ค. ๋งค์ผ ์ฝ”๋”ฉ์„ ํ•  ๋•Œ ์ด ์ž‘์—…์ด ์ค‘์š”ํ•˜์ง€ ์•Š๋‹ค๊ณ  ์ƒ๊ฐํ•ด์™”์ง€๋งŒ ๊ฒฐ๊ตญ์€ ๊ฐ€์žฅ ์ค‘์š”ํ•œ ๊ฐœ๋…์ž„์„ ๊นจ๋‹ซ์Šต๋‹ˆ๋‹ค.

๋น„ํŠธ๋ฅผ ์ดํ•ดํ•˜์ง€ ๋ชปํ•œ๋‹ค๋ฉด ๋” ๋‚˜์€ JavaScript ๊ฐœ๋ฐœ์ž๊ฐ€ ๋˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค. ์ž‘์—… ์ค‘์ธ React ์•ฑ์—๋Š” ๋„์›€์ด ๋˜์ง€ ์•Š์ง€๋งŒ ์ผ๋ฐ˜์ ์œผ๋กœ ๋” ๋‚˜์€ ์†Œํ”„ํŠธ์›จ์–ด ๊ฐœ๋ฐœ์ž๊ฐ€ ๋  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

๋ชจ๋“  ๊ฒƒ์„ ์•Œ ํ•„์š”๋Š” ์—†์œผ๋ฉฐ ์‚ฌ์‹ค ๊ทธ ๋ชจ๋“  ๊ฒƒ์„ ๊ธฐ์–ตํ•˜์ง€ ๋ชปํ•  ๊ฒƒ์ž…๋‹ˆ๋‹ค. ์ด ๊ธ€์—์„œ ์ €์˜ ๋ชฉํ‘œ๋Š” ๋น„ํŠธ์™€ ๋น„ํŠธ ์กฐ์ž‘์— ๋Œ€ํ•ด ์•Œ์•„์•ผ ํ•  ๊ฐ€์žฅ ๊ธฐ๋ณธ์ ์ธ ์ง€์‹์„ ๋‹ค๋ฃจ๋Š” ๊ฒƒ์ž…๋‹ˆ๋‹ค.

๊ทธ๋ ‡๋‹ค๋ฉด, ๋น„ํŠธ๊ฐ€ ๋ญ”๋ฐ?

์ปดํ“จํ„ฐ์—์„œ๋Š” ๋ชจ๋“  ๊ฒƒ์ด 1์ดˆ์™€ 0์ดˆ๋กœ ๋‚ด๋ ค๊ฐ‘๋‹ˆ๋‹ค. ์ˆซ์ž, ๋ฌธ์ž ๋˜๋Š” ๋ฌธ์ž์—ด๊ณผ ํ•จ๊ป˜ ์ž‘๋™ํ•˜์ง€ ์•Š์œผ๋ฉฐ ์ด์ง„์ˆ˜(๋น„ํŠธ)๋งŒ ์‚ฌ์šฉํ•ฉ๋‹ˆ๋‹ค. ๋ชจ๋“  ๊ฒƒ์ด ์ด์ง„ ํ˜•์‹์œผ๋กœ ์ €์žฅ๋œ๋‹ค๋Š” ๊ฒƒ์ž…๋‹ˆ๋‹ค. ๊ทธ๋Ÿฐ ๋‹ค์Œ, ์ปดํ“จํ„ฐ๋Š” UTF-8๊ณผ ๊ฐ™์€ ์ธ์ฝ”๋”ฉ์„ ์‚ฌ์šฉํ•˜์—ฌ ์ €์žฅ๋œ ๋น„ํŠธ ์กฐํ•ฉ์„ ๋ฌธ์ž, ์ˆซ์ž ๋˜๋Š” ๋‹ค๋ฅธ ๊ธฐํ˜ธ(ELI5 ๋ฒ„์ „)์— ๋งตํ•‘ํ•ฉ๋‹ˆ๋‹ค.

๋น„ํŠธ๊ฐ€ ๋งŽ์œผ๋ฉด ์น˜ํ™˜์ด ๋งŽ์•„์ง€๊ณ  ๋งŽ์„์ˆ˜๋ก ๋Œ€ํ‘œํ•  ์ˆ˜ ์žˆ๋Š” ๊ฒƒ๋„ ๋งŽ์•„์ง‘๋‹ˆ๋‹ค. (๋ญ” ์˜๋ฏธ์ธ์ง€ ๋ชจ๋ฅด๊ฒ ์Œ)

์˜ˆ๋ฅผ ๋“ค์–ด 113๋ฒˆ์„ ์˜ˆ๋กœ ๋“ค์–ด ๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค. JS์—์„œ ์ด์ง„ ํ˜•์‹์„ ์–ป๋Š” ๊ฐ€์žฅ ์‰ฌ์šด ๋ฐฉ๋ฒ•์€ ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.

Number(113).toString(2) // 1110001

์ด ์˜ˆ์‹œ๋Š” ์ผ๋ถ€๋ถ„์— ๋ถˆ๊ณผํ•ฉ๋‹ˆ๋‹ค. ์ด์ œ ์šฐ๋ฆฌ๊ฐ€ ๊ทธ๊ฒƒ๋“ค์„ ์–ด๋–ป๊ฒŒ ์กฐ์ž‘ํ•  ์ˆ˜ ์žˆ๋Š”์ง€ ์‚ดํŽด๋ณด๋„๋ก ํ•˜๊ฒ ์Šต๋‹ˆ๋‹ค.

๋งŽ์€ ๋ธ”๋กœ๊ทธ์—์„œ 16์ง„์ˆ˜๋ฅผ ๊ฐ€์ง„ ์˜ˆ์‹œ๋ฅผ ๊ฐ€์ง€๊ณ  ์žˆ์Šต๋‹ˆ๋‹ค. ์—ฌ๊ธฐ์„œ๋Š” ์‹ญ์ง„์ˆ˜ ๋ฐ ์ด์ง„์ˆ˜๋งŒ ์‚ดํŽด๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค. ๊ทธ ์ด๋ฉด์˜ ๋…ผ๋ฆฌ๋Š” ์ด๊ฒƒ์ด ๋” ์ง๊ด€์ ์œผ๋กœ ์ดํ•ด๋  ์ˆ˜ ์žˆ๋‹ค๋Š” ๊ฒƒ์ž…๋‹ˆ๋‹ค. ์˜์‹ฌ์Šค๋Ÿฌ์šธ ๋•Œ๋Š” ๊ธฐ๋ณธ์ ์œผ๋กœ ์ข…์ด์— ๋น„ํŠธ ๋ฐ ๋ชจ๋“  ์ž‘์—…์„ ๊ธฐ๋กํ•˜๊ณ  ๋ฌด์Šจ ์ผ์ด ์ผ์–ด๋‚˜๊ณ  ์žˆ๋Š”์ง€ ์ถ”์ ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

๋˜ํ•œ JavaScript์—์„œ ์ง์ ‘ ์ด์ง„์ˆ˜๋ฅผ ์ž…๋ ฅํ•  ์ˆ˜ ์žˆ๋Š” ๋ฐฉ๋ฒ•์ด ์—†์Šต๋‹ˆ๋‹ค. ์ด์ง„์ˆ˜๋ฅผ ์‹ญ์ง„์ˆ˜๋กœ ๋ณ€ํ™˜ํ•˜๋ ค๋ฉด ๊ตฌ๋ฌธ์„ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

// function parseInt 
parseInt(1111, 2) //15

& (AND)

์ผ๋ณ„ ํ”„๋กœ๊ทธ๋ž˜๋ฐ ์ž‘์—…์—์„œ ์ด๋ฏธ ์‚ฌ์šฉํ•˜๊ณ  ์žˆ๋Š” && ๋…ผ๋ฆฌ ์—ฐ์‚ฐ์ž์™€ ๋งˆ์ฐฌ๊ฐ€์ง€๋กœ, ์ด ์—ฐ์‚ฐ์ž๋Š” ๋น„๊ต๋œ ๋น„ํŠธ๊ฐ€ ๋ชจ๋‘ 1๊ณผ 0์ด๋ฉด ๋‹ค๋ฅธ ๋ชจ๋“  ๊ฒฝ์šฐ์— 1์„ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค. ์–‘์ชฝ์—์„œ ์ˆซ์ž๋ฅผ ์„ ํƒํ•œ ๋‹ค์Œ(์ด์ง„ ํ˜•์‹์ด ์•„๋‹ˆ๋ผ ์ˆซ์ž) ๋น„ํŠธ๋ฅผ ํ•˜๋‚˜์”ฉ ๋น„๊ตํ•ฉ๋‹ˆ๋‹ค.

๊ทธ๊ฒƒ์„ ์‹œ๊ฐํ™”ํ•ด๋ณด์ฃ . ์ˆซ์ž 12์™€ 15๋Š” 1100๊ณผ 1111์˜ ์ด์ง„์ˆ˜๋ฅผ ๋‚˜ํƒ€๋ƒ…๋‹ˆ๋‹ค. ๊ทธ ์ˆซ์ž์— & ์—ฐ์‚ฐ์ž๋ฅผ ์‚ฌ์šฉํ•ด๋ณด์ฃ . ๋กœ๊ทธ์— ์ฐ์–ด๋ณด๋ฉด 12๋งŒ ๊ฒฐ๊ณผ๋กœ ๋„์ถœ์ด ๋ฉ๋‹ˆ๋‹ค. ๋ญ”๊ฐ€ ์ด์ƒํ•˜์ฃ ?

12์˜ ๋ชจ๋“  ๋น„ํŠธ๋ฅผ 15์™€ ๋น„๊ตํ–ˆ๊ณ  ์šด์˜๋ฐฉ์‹์— ๋”ฐ๋ผ 1100์„ ๋‹ค์‹œ ์–ป์—ˆ์Šต๋‹ˆ๋‹ค. ๊ทธ๋ž˜์„œ 12๊ฐ€ ๋‚˜์˜จ ๊ฒƒ ์ž…๋‹ˆ๋‹ค.

& ์—ฐ์‚ฐ์ž๊ฐ€ ๊ฐ–๊ณ  ์žˆ๋Š” ์žฌ๋ฏธ์žˆ๋Š” ์ž‘์—… ์ค‘ ํ•˜๋‚˜๋Š” ์ˆซ์ž๊ฐ€ ์ง์ˆ˜์ธ์ง€ ํ™€์ˆ˜์ธ์ง€ ์•Œ์•„๋‚ด๋Š” ๊ฒƒ์ž…๋‹ˆ๋‹ค. ์ˆซ์ž๊ฐ€ ํ™€์ˆ˜์ด๋ฉด ์ฒซ ๋ฒˆ์งธ ๋น„ํŠธ๋Š” ํ•ญ์ƒ 1์ด ๋ฉ๋‹ˆ๋‹ค. ๋”ฐ๋ผ์„œ ์ˆซ์ž๋ฅผ ์‚ฌ์šฉํ•˜๊ณ  1๊ณผ ๋น„๊ตํ•  ์ˆ˜ ์žˆ์œผ๋ฏ€๋กœ ์ˆซ์ž๊ฐ€ ํ™€์ˆ˜์ด๋ฉด ๊ฒฐ๊ณผ๋Š” 1์ด ๋ฉ๋‹ˆ๋‹ค. ํ•˜์ง€๋งŒ ์‹ค์ œ ์ฝ”๋“œ๋ฒ ์ด์Šค์— ์ด ์ฝ”๋“œ๋ฅผ ์‚ฌ์šฉํ•˜๋Š” ๊ฒƒ์€ ๊ถŒ์žฅํ•˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค. ํ˜„์žฌ ๋ฌด์—‡์„ ํ•˜๊ณ  ์žˆ๋Š”์ง€ ๋ช…ํ™•ํ•˜์ง€ ์•Š๊ธฐ ๋•Œ๋ฌธ์ž…๋‹ˆ๋‹ค.

| (OR)

์ด๊ฒƒ์€ ||๊ณผ ๋งค์šฐ ์œ ์‚ฌํ•ฉ๋‹ˆ๋‹ค. ๋น„๊ต๋œ ์ด์ง„์ˆ˜๊ฐ€ ๋ชจ๋‘ 0์ผ ๋•Œ ์ ์–ด๋„ 1๊ณผ 0์ด ์žˆ๋Š” ๊ฐ ๋น„๊ต์— ๋Œ€ํ•ด 1์„ ๋ฐ˜ํ™˜ํ•˜์—ฌ ๋‘ ๊ฐœ์˜ ์ด์ง„์ˆ˜๋ฅผ ์ด์ง„์ˆ˜ ๋ณ„๋กœ ๋น„๊ตํ•˜๋Š” ๋ฐ ์‚ฌ์šฉ๋ฉ๋‹ˆ๋‹ค. ์•ž์˜ ์˜ˆ๋ฅผ ๋“ค์–ด ์ด ์—ฐ์‚ฐ์ž๋ฅผ ์‚ฌ์šฉํ•˜๋ฉด 12 | 15๊ฐ€ 15๊ฐ€ ๋ฐ˜ํ™˜๋ฉ๋‹ˆ๋‹ค. ์™œ๊ทธ๋Ÿด๊นŒ์š”?

1100 | 1111์€ ๋‹ค์‹œ 1111 ๋˜๋Š” 15์™€ ๋™์ผํ•œ ๊ฐ ๋น„๊ต์— ๋Œ€ํ•ด 1์„ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.

~ (NOT)

์ด ๊ฒƒ์€ ์กฐ๊ธˆ ๋” ํ˜„๋ช…ํ•œ NOT์ž…๋‹ˆ๋‹ค. ๊ฒฐ๊ณผ๋Š” 2์˜ ์นญ์ฐฌ ์‚ฐ์ˆ ์—์„œ e ์Œ์ˆ˜์ž…๋‹ˆ๋‹ค. ์ฆ‰, 1์ดˆ์—์„œ 0์ดˆ๋กœ ๋ชจ๋“  ๋น„ํŠธ๋ฅผ ๋˜๋Œ๋ฆฌ๊ณ  ๊ทธ ๋ฐ˜๋Œ€์˜ ๊ฒฝ์šฐ๋„ ๋งˆ์ฐฌ๊ฐ€์ง€์ž…๋‹ˆ๋‹ค.

๊ทธ๋Ÿฌ๋‚˜ ~15๋ฅผ ๋กœ๊ทธ์— ์ฐ๋Š”๋‹ค๋ฉด ๋น„ํŠธ๊ฐ€ ์˜ฌ๋ฐ”๋ฅด๋”๋ผ๋„ ๊ฒฐ๊ณผ๊ฐ€ -16์ด ๋ฉ๋‹ˆ๋‹ค. ์ด๋Š” ๋‘ ๊ฐœ์˜ ๋ณด์™„ ์‚ฐ์ˆ ์—์„œ ์ˆซ์ž์˜ ์Œ์ˆ˜๋ฅผ ํ‘œ์‹œํ•˜๋ ค๋ฉด ๋จผ์ € ์ˆซ์ž์˜ ๋น„ํŠธ๋ฅผ ๋ฐ”๊พผ ๋‹ค์Œ 1์„ ์ถ”๊ฐ€ํ•ด์•ผ ํ•˜๊ธฐ ๋•Œ๋ฌธ์ž…๋‹ˆ๋‹ค.

^ (XOR)

์ด ์—ฐ์‚ฐ์ž๋Š” XOR ์—ฐ์‚ฐ์ž ๋˜๋Š” ๋…์ ์ ์ธ OR๋กœ ์•Œ๋ ค์ ธ ์žˆ์Šต๋‹ˆ๋‹ค. &, | ์—ฐ์‚ฐ์ž์™€ ๋™์ผํ•˜๊ฒŒ ๋น„๊ต๋ฅผ ํ•˜๋Š” ๋ฐฉ์‹์„ ์ฐจ๋ณ„ํ™”ํ•˜๋ฉด์„œ ์–‘์ชฝ์˜ ์ˆซ์ž๋ฅผ ์ทจํ•ฉ๋‹ˆ๋‹ค.

ํ•ด๋‹นํ•˜๋Š” ๋น„ํŠธ๋ฅผ ๋น„๊ตํ•˜๊ณ  1๊ฐœ๋งŒ ์žˆ์„ ๋•Œ๋งŒ 1์„ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค. ์ด ๋น„ํŠธ์˜ ๊ฒฝ์šฐ ์„ค๋ช…ํ•˜๊ธฐ์— ๊ทธ๋‹ค์ง€ ์ข‹์ง€ ์•Š์„ ๊ฒƒ์ž…๋‹ˆ๋‹ค. ๊ทธ๋Ÿฌ๋‹ˆ ์ข€ ๋” ์‹œ๊ฐ์ ์œผ๋กœ ์„ค๋ช…ํ•˜๋Š” ๊ฒƒ์ด ์ข‹๊ฒ ๊ตฐ์š”, 1 ^ 0์ด 1์„ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค. ๊ทธ๋Ÿฌ๋‚˜ 1 ^ 1์€ 0์„ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.

^ ์—ฐ์‚ฐ์ž๋Š” 1๊ณผ 0์„ ๋น„๊ตํ•˜๋Š” ํŠน์ • ๊ฒฝ์šฐ์—๋งŒ 1์„ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.

Shifting ์—ฐ์‚ฐ์ž

์ด๋™ ๋น„ํŠธ๋ฅผ ์ฒ˜๋ฆฌํ•˜๋Š” >>, << ์—ฐ์‚ฐ์ž๊ฐ€ ์žˆ์Šต๋‹ˆ๋‹ค. ์—ฌ๋Ÿฌ๋ถ„์ด ์ถ”์ธกํ•  ์ˆ˜ ์žˆ๋“ฏ์ด ์ฐจ์ด๋Š” ์ˆซ์ž์˜ ๋น„ํŠธ๋ฅผ ์ด๋™ํ•˜๋Š” ์œ„์น˜์ž…๋‹ˆ๋‹ค.

<< ์—ฐ์‚ฐ์ž๋Š” ์ˆซ์ž์˜ ๋ชจ๋“  ๋น„ํŠธ๋ฅผ n๋ฒˆ ๋ฐ”๊ฟ‰๋‹ˆ๋‹ค. ์—ฌ๊ธฐ์„œ ์œ ์˜ํ•ด์•ผ ํ•  ๊ฒƒ์€ ๋ฒˆํ˜ธ๋ฅผ ์˜ฎ๊ธธ ๋•Œ ๋ฐœ์ƒํ•˜๋Š” ๋นˆ ๊ณต๊ฐ„์€ ๋ชจ๋‘ 0์œผ๋กœ ์ฑ„์›Œ์ ธ ์žˆ๋‹ค๋Š” ์ ์ž…๋‹ˆ๋‹ค.

๋ฐ˜๋ฉด์— >> ์—ฐ์‚ฐ์ž๋Š” ์˜ค๋ฅธ์ชฝ์œผ๋กœ ์ด๋™ํ•ฉ๋‹ˆ๋‹ค. ์ด ๋ณ€ํ™˜ ์—ฐ์‚ฐ์ž์™€ ์ด์ „ ๋ณ€ํ™˜ ์—ฐ์‚ฐ์ž์˜ ์ฐจ์ด์ ์€ ์ด ์—ฐ์‚ฐ์ž๊ฐ€ ์–‘์˜ ์ˆซ์ž์˜ ๋น„ํŠธ๋ฅผ 0์ดˆ๋กœ ์ฑ„์šฐ๊ณ  ์Œ์˜ ์ˆซ์ž์˜ ๋น„ํŠธ๋ฅผ 1์ดˆ๋กœ ์ฑ„์šฐ๋Š” ๊ฒƒ์ž…๋‹ˆ๋‹ค.

์—ฌ๊ธฐ์„œ ์งš๊ณ  ๋„˜์–ด๊ฐ€์•ผ ํ•  ๋ถ€๋ถ„์ด ์žˆ์Šต๋‹ˆ๋‹ค. ๋ณดํ†ต ์ˆซ์ž์˜ ์ฒซ ๋ฒˆ์งธ ๋ถ€๋ถ„์€ ํ‘œ์ง€๋ฅผ ๋‚˜ํƒ€๋‚ด๊ธฐ ์œ„ํ•ด ์‚ฌ์šฉ๋ฉ๋‹ˆ๋‹ค. 1์ด๋ฉด ์Œ์ˆ˜์ด๊ณ , 0์ด๋ฉด ์–‘์ˆ˜์ž…๋‹ˆ๋‹ค. ๋”ฐ๋ผ์„œ ์šฐํŒŒ์˜ ์ด๋ฉด์— ์žˆ๋Š” ์ถ”๋ก ์€ ์šฐ๋ฆฌ๊ฐ€ ์›€์ง์ด๊ณ  ์žˆ๋Š” ์ˆซ์ž์˜ ํ‘œ์‹์„ ์ง€ํ‚ค๊ธฐ ์œ„ํ•œ ๊ฒƒ์ž…๋‹ˆ๋‹ค.

๋น„ํŠธ์—ฐ์‚ฐ์ž ์‘์šฉํ•ด๋ณด๊ธฐ

์ด์ œ ๋ฌด์—‡์„ ํ•˜๋Š”์ง€ ์•Œ๊ฒŒ ๋˜์—ˆ์œผ๋‹ˆ ๋น„ํŠธ๋ฅผ ์กฐ์ž‘ํ•˜๋Š” ๋ฐ ์–ด๋–ป๊ฒŒ ํ™œ์šฉํ•  ์ˆ˜ ์žˆ๋Š”์ง€ ์‚ดํŽด๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค.

์ž, ์ด์ œ ์œ„์น˜๋ฅผ ์˜ฎ๊ธฐ๋„๋ก ํ•ฉ์‹œ๋‹ค. ์˜ค๋ฅธ์ชฝ์˜ ๋‘ ๋ฒˆ์งธ ๋น„ํŠธ๋ฅผ ์„ค์ •ํ•ฉ๋‹ˆ๋‹ค(1). ์ด๊ฒƒ์€ ์šฐ๋ฆฌ์—๊ฒŒ masks ๊ฐœ๋…์„ ๊ฐ€์ ธ๋‹ค ์ค๋‹ˆ๋‹ค. masks๋Š” ๋‹ฌ์„ฑํ•˜๋ ค๋Š” ํ•ญ๋ชฉ์— ๋”ฐ๋ผ 1 ๋˜๋Š” 0์œผ๋กœ ์„ค์ •ํ•  ๋น„ํŠธ๋งŒ ์žˆ๋Š” ์ด์ง„ ํ˜•์‹์˜ ์ˆซ์ž์ž…๋‹ˆ๋‹ค. ๋˜ํ•œ ๋ณ€๊ฒฝํ•  ๋น„ํŠธ๋ฅผ ์ •์˜ํ•˜๋Š” ํ”Œ๋ž˜๊ทธ๋กœ๋„ ์‚ฌ์šฉ๋œ๋‹ค๊ณ  ๋งํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

์ฒซ ๋ฒˆ์งธ ๋น„ํŠธ๋ฅผ ์„ค์ •ํ•˜๋ ค๋ฉด ๋งˆ์Šคํฌ๊ฐ€ 0001์ด ๋ฉ๋‹ˆ๋‹ค. ๋‘ ๋ฒˆ์งธ ์„ค์ •์„ ์›ํ•˜๋Š” ๊ฒฝ์šฐ 0010 ๋“ฑ์ด ๋ฉ๋‹ˆ๋‹ค.

์˜ˆ๋ฅผ ๋“ค์–ด ๋‹ค์Œ๊ณผ ๊ฐ™์€ ์‚ฌํ•ญ์„ ๋ณด๋‹ค ๋ช…ํ™•ํ•˜๊ฒŒ ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

const setBit = (num, position) => {
  let mask = 1 << position
  return num | mask
}

// Set the bit at position 1
setBit(12, 1) // return 14 -> 1110

์ž, ์ง€๊ธˆ๊นŒ์ง€๋Š” ์ข‹์Šต๋‹ˆ๋‹ค. ์–ด๋–ป๊ฒŒ ํ•˜๋ฉด ์ข€ ๋” ์ •๋ฆฌํ•  ์ˆ˜ ์žˆ๋Š”์ง€ ์•Œ์•„๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค. ๋น„ํŠธ๋ฅผ 0์œผ๋กœ ์„ค์ •ํ•ด๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค. ๋‹ค๋ฅธ ๋ชจ๋“  ๋น„ํŠธ๋Š” ๊ทธ๋Œ€๋กœ ์œ ์ง€ํ•ด์•ผ ํ•˜๊ธฐ ๋•Œ๋ฌธ์— ์ด์ „ ์˜ˆ์ฒ˜๋Ÿผ ์‰ฝ์ง€ ์•Š์Šต๋‹ˆ๋‹ค.

const clearBit = (num, position) => {
  // We use the ~/NOT operator after placing the bit
  // We want 1s everywhere and 0 only where we want to modify
  let mask = ~(1 << position)
  
  // We use AND which will modify only the bits compared to 0
  return num & mask
}

clearBit(15, 1) // 12 -> 1100

์—ฌ๊ธฐ์„œ ๋‹ค๋ฅธ ์ ์€ mask๊ฐ€ 1s๋กœ ๊ฐ€๋“ ์ฐจ ์žˆ๊ณ  ์ง€์šฐ๋ ค๋Š” ์œ„์น˜์—์„œ๋งŒ 0์„ ๊ฐ–๊ธฐ๋ฅผ ์›ํ•œ๋‹ค๋Š” ์ ์ž…๋‹ˆ๋‹ค. ๊ทธ๋Ÿฐ ๋‹ค์Œ ํ•„์š”ํ•œ ์œ„์น˜๋งŒ 0์œผ๋กœ ์„ค์ •ํ•˜๋Š” & ์—ฐ์‚ฐ์ž๋ฅผ ์‚ฌ์šฉํ•ฉ๋‹ˆ๋‹ค.

์ด์ œ ๋น„ํŠธ ์„ค์ • ๋ฐ ์‚ญ์ œ ๋ฐฉ๋ฒ•์„ ์•Œ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ํ•˜์ง€๋งŒ ๋’ค์ง‘์œผ๋ ค๋ฉด ์–ด๋–ป๊ฒŒ ํ•ด์•ผ ํ• ๊นŒ์š”? ์šฐ๋ฆฌ๋Š” ๊ทธ ๋น„ํŠธ๊ฐ€ ์„ค์ •๋˜์—ˆ๋Š”์ง€ ์•„๋‹Œ์ง€ ์•Œ ์ˆ˜ ์—†์ง€๋งŒ, ์šฐ๋ฆฌ๋Š” ์ •๋ง๋กœ ๊ทธ๊ฒƒ์˜ ํ˜„์žฌ ์ƒํƒœ๋ฅผ ๋ฐ”๊พธ๊ธฐ๋ฅผ ์›ํ•ฉ๋‹ˆ๋‹ค. ์ด๊ฑด XOR์˜ ์ผ์ž…๋‹ˆ๋‹ค.

const flipBit = (num, position) => {
  let mask = 1 << position
  // If the current state of the bit is 0, XOR will return 1
  // If the bit is 1, XOR will set it to 0
  return num ^ mask
}

flipBit(15, 1) // 13 -> 1101

์ด ๊ฒฝ์šฐ XOR๋Š” 1์— 1์„ ์‚ฌ์šฉํ•˜๋Š” ๊ฒƒ์ด ๋น„ํŠธ์˜ ๊ฐ’์„ ๋’ค์ง‘์„ ์ˆ˜ ์žˆ๊ธฐ ๋•Œ๋ฌธ์— ์‚ฌ์šฉ๋ฉ๋‹ˆ๋‹ค.