我入行前十年都在跟二进制打交道，说得夸张一点，搞懂二进制的那一刻，你会觉得整个计算机世界都透明了一层。这个标题看着基础，但很多人学完就忘，一是没搞明白它到底在解决什么问题，二是没把二进制和日常写代码、排故障联系起来。这篇博文我会从数制原理一路讲到位运算实战，最后给你整理一份避坑清单，适合刚入门的学生、转行程序员，也适合想补基础却一直没时间的从业者。
1. 二进制到底在解决什么问题
1.1 从十进制到二进制，不过是换了一套计数规则
我们从小用十进制，是因为人有十根手指，计数方便。二进制则完全围绕两种状态展开：0 和 1。你只需要接受一个事实：任何进制都只是计数规则的不同表达方式，它们描述的是同一个数量。
十进制的 325 代表什么？3×100 + 2×10 + 5×1。这里的 100、10、1 就是 10 的幂次，从右往左依次是 10⁰、10¹、10²。二进制的 101 呢？1×4 + 0×2 + 1×1 = 5。权重从右往左是 2⁰、2¹、2²，也就是 1、2、4。
理解了“权重”这个概念，你就拿到了理解所有进制的钥匙。八进制、十六进制、任何你自定义的进制，都只是把底数换成对应的值，规则完全一样。这也是为什么在计算机领域里，搞懂二进制后，再去学十六进制几乎不用花时间——十六进制只是方便人阅读二进制的一种缩写罢了。
1.2 为什么计算机偏偏选中二进制
早期也曾有过十进制计算机的尝试，但最终统统败给了二进制，核心原因有三个。
物理实现上的天然优势。一个开关只有两种状态：断开和闭合。一个晶体管只有两种工作状态：导通和截止。二进制的 0 和 1 可以直接映射到高低电平上，不需要去严格区分十个不同的电压等级。区分两种状态只需要一个阈值判断，而区分十种状态就需要很精确的电压区间，这不仅成本高，而且抗干扰能力差。举个例子，你在嘈杂环境里听两个人聊天，一个只说“是和不是”，另一个用十种语气表达不同意见，哪个更不容易听错？
运算规则极其简单。十进制的加法口诀表有 55 条，九九乘法表背过的人都懂。而二进制只有四条加法规则：0+0=0、0+1=1、1+0=1、1+1=10。四条规则就搞定了所有加法，电路实现上可以做得非常简单，运算速度也更快。
逻辑代数和布尔代数天然匹配。计算机的所有行为本质上都可以归结为逻辑判断，而逻辑判断只有真和假，恰好就是 1 和 0。二进制不仅用于表示数值，还用于表示逻辑状态，这让算术运算和逻辑运算可以在同一套电路上实现，架构设计上极其统一。
1.3 一个让数字人瞬间豁然开朗的对照
我早期带新人时最常用的一个类比是：LED 灯开关就像二进制的一位。
你面前有 8 盏灯，每盏灯只有“亮”和“灭”两种状态。如果这个灯组代表一个数字，它最多能表示几个不同的状态？2⁸ = 256 种。这就是 1 字节（8 位）的全部含义。
再看一个实际问题：为什么 IPv4 地址最大是 255？因为 IP 地址的每一段用 1 字节表示，也就是 8 位二进制，最大就是全 1，即 11111111，换算成十进制是 255。你一旦用二进制的视角看待这些数字，很多原来需要死记硬背的知识就直接“通”了：子网掩码、颜色值（#FF0000 就是 255 的红）、文件权限里的 777，全都是二进制在背后起作用。
2. 二进制加减乘除的完整推演
2.1 加法是唯一的基石
如果你真正理解了加法，二进制里就没有你不会的运算了，因为减法和乘法都是拿加法来做的。二进制的加法口诀就四条：
- 0 + 0 = 0
- 0 + 1 = 1
- 1 + 0 = 1
- 1 + 1 = 0，向高位进 1
注意，这个进位规则是二进制的核心。当一个位的结果是 2 时，就“溢出了”，要把 2 变成 0 并向上一位加 1。这和十进制满十进一是同一个逻辑，只是“满”的阈值从 10 变成了 2。
我们算一个实际的例子：0110 + 0101。
0110 (6) + 0101 (5) ------- 1011 (11)从最低位开始看：0+1=1，第一位结果 1。第二位：1+0=1，结果也是 1。第三位：1+1=10，这位写 0，向第四位进 1。第四位：0+0+进位 1 = 1。最终结果 1011，就是十进制的 11。这里特别提醒：中间那一位的进位非常容易漏，多位数加法里“进位和当前位相加”是不可漏掉的步骤，程序员排查二进制计算错误时，一半以上问题都出在进位处理上。
2.2 减法：为什么要发明补码
很多初学者死在补码上，是因为没有理解设计者当年面对的困境。二进制的加法电路做起来很容易，那减法呢？最笨的办法是做一套减法电路，但电路复杂，成本高。于是有人想：能否让减法也通过加法来完成？答案就是补码。
核心问题：如果要算 5 - 3，也就是 5 + (-3)，我们能不能找到一种编码，让“+ 负三”在电路里就等于“- 三”？
这个编码就是补码。发明补码的底层思路是让负数参与模运算。你可以想象一个钟表，12 点过后又是 1 点。假设钟表只有 4 位，能表达 0 到 15，那么 12 就等于 0，在模 16 的体系里，-3 可以表示成 13，因为 +13 和 -3 在模 16 下效果一样（13 = 16 - 3）。
因此，一个负数的补码 = 它的绝对值的二进制取反再加 1。
计算 -3 的 4 位补码：3 的二进制是 0011。取反得 1100。加 1 得 1101。这就是 -3 的补码表示。验证一下：5 + (-3) = 0101 + 1101 = 10010，最高位的进位“溢出”丢掉，剩下 0010，就是 2。结果正确。
我强烈建议你亲手验证几组，感受“取反加一”这个操作在电路上有多简单。这不仅是笔试的必考点，也是理解有符号整数边界值的必经之路。4 位有符号整数为什么范围是 -8 到 7？因为 1000 就是 -8，0111 就是最大值 7，比你想象的直观得多。
2.3 乘法与除法：左移右移的真实含义
计算机里的乘法在硬件层面是“移位 + 加法”的组合。看几条规律：
- 二进制数左移一位，相当于乘以 2
- 二进制数右移一位，相当于除以 2
十进制里有这个规律吗？325 左移一位（后面补一个 0）得到 3250，是原来的 10 倍。二进制里同理，只是倍数是 2。这个性质在编程里极其常用，很多优化技巧都建立在它之上，比如判断一个数是不是 2 的幂，只需要看它二进制里是否只有一个 1；乘以 2 的幂次，直接左移对应的位数。
举个例子：5 × 6 = 5 × (4 + 2) = (5 << 2) + (5 << 1) = 20 + 10 = 30。你看，乘法被拆成了左移和加法，硬件里就是这么干的。当然，现代编译器早就帮你做了这类优化，你不需要在代码里写这种“聪明代码”，但理解这个原理，对你理解 Hash 函数、内存寻址、数据扩容都大有帮助。
3. 位运算：你每天都在用的二进制魔法
3.1 四种基础位运算的直观理解
位运算直接作用于二进制位，一共四种基础操作。
按位与（&）：两个位都是 1，结果才是 1。你可以把它理解成“清零器”——任何位跟 0 做与运算，都被清零了；任何位跟 1 做与运算，保持原来不变。所以 x & 0xFF 就是把 x 的前 24 位清零，只保留后 8 位。
按位或（|）：两个位只要有一个是 1，结果就是 1。它是“置位器”——任何位跟 1 做或运算，都被置 1；跟 0 做或运算，保持原样。所以 x | 0x80 就是把 x 的第 7 位强制变成 1。
按位异或（^）：两个位不一样（一个 0 一个 1）时结果是 1，一样时结果是 0。它的神奇性质是：两次异或同一个数，等于什么都没做。即 x ^ y ^ y = x。这个性质被广泛用在加密、交换变量、校验算法里。
按位取反（~）：0 变 1，1 变 0。注意它有坑，我们后面专门讲。~5 的结果并不是你直觉里的“负 5”，涉及有符号数的补码规则。
3.2 位移操作：左移右移的隐藏陷阱
左移运算符<<：所有位向左移动，右侧补 0。比如 5 << 2，5 是 0101，左移两位变成 10100，即 20，等于 5 × 2²。
无符号右移>>>：所有位向右移动，左侧补 0。有符号右移>>：所有位向右移动，左侧补符号位。大部分编程语言里用的是算术右移，也就是负数右移时，左侧补 1 而非补 0。
这一点很多人踩过坑。比如 -8 在 8 位二进制里是 11111000（补码），-8 >> 1 在算术右移下得到 11111100，也就是 -4。如果按逻辑右移（补 0），就会得到 01111100，是 124，完全不同的结果。在处理有符号负数做右移时，一定要搞清楚语言默认的行为，否则排查半天都不知道哪里出错。
左移也有隐患：当移动位数超过类型本身的位数时，结果是未定义的或按模计算的。在 C/C++ 中这是未定义行为，非常危险；在 Java 中，位移数会先对位宽取模，比如 int 类型位移 33 位实际上只位移 1 位。跨语言开发时千万别想当然。
3.3 一个经典面试题：判断一个数是不是 2 的幂
这个题目我之前招人时必问，最能看出候选人有没有真正理解二进制。解法如下：如果 n 是 2 的幂，那么它的二进制形式中只有一个位是 1，且 n 和 n-1 做按位与的结果一定是 0。
为什么？n = 1000（即 8），n - 1 = 0111（即 7），1000 & 0111 = 0000。因为 2 的幂减 1 后，原来 1 的位置变成 0，低位全部变成 1，两者没有任何一个位同时是 1。
def is_power_of_two(n): return n > 0 and (n & (n - 1)) == 0如果你自己推导过几次，会发现这类二进制技巧不是靠背诵，而是从“位与”的本质规律里自然长出来的。这也是二进制最大的魅力：规则极简，但推导空间极大。
4. 二进制在真实工程项目里的高频应用场景
很多读者会问：明白了二进制的原理，但我平时写业务代码根本碰不到它。这话只说对了一半。你的业务代码是在一套被层层抽象好的平台上运行的，但当性能、存储、权限、网络这些事情出问题时，二进制早晚会出现在你面前。
4.1 权限系统：Linux 777 为什么是 7
Linux 文件权限里，r（读）是 4，w（写）是 2，x（执行）是 1。这三组权限值相加得到 7，但很少有人真正解释为什么是 4、2、1。因为这三个数在二进制里恰好各占一位：
| 权限 | 二进制位 | 十进制值 |
|---|---|---|
| 读 r | 100 | 4 |
| 写 w | 010 | 2 |
| 执行 x | 001 | 1 |
7 = 111，表示三个权限全开。5 = 101，表示读和执行，没有写权限。这就是位标志的核心思想：每个权限占一个独立的位，判断有没有权限，只需要检查对应位是否为 1。
在 Web 开发里，这种位标志权限系统非常常见，比数据库里存字符串列表高效得多。用二进制判断权限，本质上是 O(1) 的位运算，而且多个权限可以共存于一个整数里，存储上非常省。
const PERMISSION_READ = 1 << 0; // 1 const PERMISSION_WRITE = 1 << 1; // 2 const PERMISSION_EXEC = 1 << 2; // 4 let userPermission = PERMISSION_READ | PERMISSION_WRITE; // 3 // 检验是否有写权限 if (userPermission & PERMISSION_WRITE) { console.log("有写权限"); }4.2 位图与内存管理：用 1 个 bit 存储一个状态
位图（Bitmap）是二进制经典应用之一。假设你要在内存里记录一亿个用户是否在线，用布尔值数组的话，一个布尔值占 1 字节，一亿个用户就是 100MB 内存。若用位图，每个用户只占 1 个 bit，一亿个用户大约是 12.5MB，内存直接省 8 倍。
Redis 的 Bitmap 数据结构就是这么设计的，它用 GETBIT/SETBIT 直接操作二进制位，常被用来做用户签到统计、在线状态判断、布隆过滤器的底层实现。布隆过滤器本身也是位数组 + 多个哈希函数的组合，它判断“一个元素一定不在集合里”时，也是通过检查多个位是否全为 1 来完成的。
在很多底层组件里，状态标志也普遍使用位运算。比如给一个对象打多个 Tag，开发人员会定义若干个常量：STATE_A = 1 << 0，STATE_B = 1 << 1，STATE_C = 1 << 2，然后用 | 打标记，用 & 查标记，用 ^ 做切换，用 &^ 做清除。这一套组合拳在高效的 Go、Rust 代码里很常见。
4.3 哈希取模的位运算优化
哈希表扩容时，最常见的一种操作是让 key 找到对应的桶。如果桶的数量是 2 的幂，比如 16、32、64，那取模运算hash % n可以直接优化为hash & (n - 1)。因为 2 的幂减 1 后，低 n 位全是 1，按位与会只保留 hash 的低 n 位，效果等同于对 2^n 取模，但速度更快。
很多语言标准库里的哈希表，比如 Java 的 HashMap 在扩容时，容量都设计成 2 的幂，底层正是这个原因。哈希桶的数量，初始话是 16，扩容翻倍成 32、64，这样设计让取模变成一个位与操作，代码又少又高效。
4.4 IP 与子网掩码：网络工程师每天都在用
看 IP 地址 192.168.1.100 时，如果你只看十进制，很难理解它为什么要配子网掩码。但你把它转成二进制，真相一目了然：
IP: 11000000.10101000.00000001.01100100 Netmask: 11111111.11111111.11111111.00000000子网掩码里 1 的部分是网络位，0 的部分是主机位。IP 地址和子网掩码做按位与，得到的结果就是网络号。192.168.1.100 与 255.255.255.0 做与运算，得到 192.168.1.0，这就是它所在的网络。判断两个 IP 是否在同一个子网，只需要看它们的网络号是否一致。理解了这一点，子网划分、CIDR 表示法（192.168.1.0/24）这些概念理解起来就顺理成章了——/24表示子网掩码有 24 个连续的 1。
4.5 颜色值、协议标志位、状态压缩
前端开发里常见的十六进制颜色值#FF8000，拆成字节看就是：红 FF（255）、绿 80（128）、蓝 00（0）。在做颜色混合或亮度调整时，经常需要提取某个通道的值，这是标准做法：先右移定位到对应字节，再与 0xFF 按位与。
网络协议里的 TCP 标志位也是一样。TCP 头的 9 个标志位，包括 SYN、ACK、FIN、RST 等，各自占一个 bit，封包时用 | 组合，解包时用 & 检查。之前有同事抓包排查连接异常，发现 SYN 和 ACK 同时置位，一眼就看出这是 TCP 握手第二步的 SYN-ACK 报文。如果你不懂这些标志位的二进制表达，排查这类网络问题会非常吃力。
还有一类状态压缩场景：游戏开发里一个角色的 buff 可以叠加多个，比如中毒、减速、无敌。最省内存的做法就是用一个 32 位整数，每个位代表一个 buff 是否存在。判断角色有没有中毒，一行位运算就够了，不需要遍历数组。
5. 二进制运算的常见坑与排查技巧
5.1 有符号和无符号：同样的 0xFF，差别天壤之别
二进制本身没有符号，符号是人定的解读规则。同一个 0xFF，在无符号 8 位整数里值是 255，在带符号 8 位整数里值是 -1。这种“同 bit 不同值”的现象，是跨语言、跨系统调试时非常经典的坑。
比如你从网络流里读到一个字节 0xFF，在 C 语言里如果直接用char接收，它可能就是 -1，但你期望的是 255。解决方式是用unsigned char接收，或者读出来后跟 0xFF 做按位与，强制清零高位。很多用 C/C++ 做网络协议解析的同行，第一年多半都踩过这个坑。
重要提醒：在处理原始字节流时，永远用无符号类型接收数据，并且做按位运算前明确自己的数据是带符号还是不带符号的。这比事后加各种转换要省事得多。
5.2 取反的陷阱：~x 不等于 -x
很多人第一次看到~5时会以为是 -5，实际在多数语言里得到的是 -6。为什么？5 的 8 位二进制是 00000101，取反后得到 11111010，这是 -6 的补码。这个一偏差的原因在于：取反把 0 变成了 -1，把 1 变成了 -2，如果逐位累加，结果自然不是简单的符号翻转。所以你如果需要取相反数，请老老实实用负号或者~x + 1（补码反向推导）。
5.3 位运算优先级：写出“惊悚代码”的根源
&、|、^的优先级普遍低于==和!=，这是一个在多个语言里持续制造 bug 的陷阱。
// 这段代码的实际执行顺序可能会让你意外 if (a & 0xFF == 0x80) { // 注意：这里其实等价于 a & (0xFF == 0x80) }这种问题防不胜防，最好的做法是任何位运算都加上括号，不仅避免优先级错误，也让读代码的人不用回头去查运算符表。不要觉得自己记得住优先级就掉以轻心，代码是写给未来的人读的，包括三个月后的自己。
5.4 位移溢出的边界处理
有符号整数左移，如果移动后最高位从 0 变成 1，正数就可能变成负数。这在二分查找计算中间值、处理哈希值时都很容易碰到。另外，对超过位宽的距离做位移，不同语言的处理不同：Java 会对位移数取模，C/C++ 则行为未定义。凡是自己动手做位移优化时，优先保证位移距离小于类型的位宽。
5.5 排查步骤总结
如果你在代码里看到位运算相关的不明 bug，我一般按下面这个顺序排查：
- 先把参与运算的所有变量打印成二进制形式，确认它们当前的实际位模式，不要凭内存里的十进制值猜测。
- 确认符号类型，是 signed 还是 unsigned，负数的位运算最容易出幻觉。
- 检查运算优先级，补上括号，逐层拆解表达式。
- 检查位移距离和溢出边界，尤其是循环里变动的位移量。
- 对比不同编译器或解释器的行为差异，毕竟语言层面也并非完全一致。
心得：二进制 bug 的一个特征是“看着数值没问题，但结果就是不对”。这时候唯一有效的办法是回到位层面，用二进制打印逐位核对，不要继续在十进制层面上猜。
6. 我的实操心得与练习建议
我个人带项目时最大的体会是：二进制的知识必须亲手演算，光看不练等于白看。有几个练习建议值得坚持。
第一，自己动手写一个十进制转二进制的函数，不调用内置函数，练到能默写出递归和迭代两种写法。第二，把所有常见的位运算技巧整理成一张速查表，包括取末位、清位、置位、翻转位、判断奇偶、交换变量、计算汉明重量。第三，找几个真实场景做练习：实现一个带权限管理的用户系统；用位图写一个整数去重模块；解析一个 TCP 报文头。这些练习做完，二进制才算真正内化。
练习代码不用复杂，我给你一个最简单的汉明重量（一个数二进制里 1 的个数）实现，你可以对比自己的写法：
def hamming_weight(n): count = 0 while n: n &= (n - 1) # 每次都消去最右侧的 1 count += 1 return count核心技巧就一行n &= (n - 1)，每次把最右边的 1 变成 0，循环次数等于 1 的个数，而不需要遍历所有位。这类技巧在网上搜“bit manipulation tricks”能找出一大堆，但我建议你每个都手动推导一遍。
最后分享一个小技巧：看到任何十进制的“奇怪数字”（比如 255、127、128、1024、65535），先条件反射把它转换成十六进制和二进制看看。久而久之你会形成一种直觉——很多数值设计的背后，都有二进制的影子。这种直觉，才是把基础变成生产力的关键。
