同事发来一份设备日志,说“第 12 条记录的序号是 16909060”。你用同一个解析脚本跑,得到 67305985。两个人对着同一份文件,同一个偏移量,读出两个数,还都能自圆其说。把那段十六进制打出来,是 01 02 03 04。按小端读,它确实是 16909060;按大端读,它是 67305985。文件没坏,脚本也没写错,差的是“四个字节按什么顺序拼成一个数”。

字节序(endianness)这个概念,平时写业务代码几乎碰不到,因为同一个进程里读写的规则是自洽的。但一旦跨机器、跨语言、跨文件格式,它就会冒出来。这篇从这四个字节讲起,把大端小端的定义、常见场景、结构体为什么不能直接落盘,以及边界处该怎么转换讲清楚。

现象:同一段字节,两个序号

把 01 02 03 04 四个字节按顺序摆在一张纸上,问它表示什么数,答案取决于你认定哪一头是高位。大端(big-endian)认为最前面的字节是最高有效字节,所以拼出来是 0x01020304,十进制 16909060。小端(little-endian)认为最前面的字节是最低有效字节,拼出来是 0x04030201,十进制 67305985。两者都是合法的拼法,只是约定不同。

这里要强调,字节序说的是“字节在内存地址里的排列顺序”,不是“一个字节内部位的顺序”。一个字节里的 8 个位,编号和顺序由硬件和协议规定,通常不叫字节序。把“位序”和“字节序”混在一起,会越想越乱。看到 01 02 03 04,只需要问:地址最低的那个字节,装的是最高有效字节还是最低有效字节。

很多人第一次遇到会以为“我的机器读错了”。其实机器没错,它只是按自己的规则读。x86 和大多数 ARM 是小端,老式 PowerPC、SPARC 是大端,网络协议统一用大端,部分 ARM 和 RISC-V 支持运行时切换。你在一台小端机器上读大端设备写的数据,读出来的数当然不对。要判断谁对,得看数据是谁写的、按什么规则写的。

抓包工具里也常看到这个差八倍的现象。同一个 TCP 报文,Wireshark 把源端口显示成 12345,你自己写脚本按小端解析却得到 13881,因为线上的两个字节是大端。Wireshark 知道协议规范,你没有按规范读。这类“工具对、脚本错”的情况,多半不是工具做了特殊处理,而是工具遵守了协议,脚本想当然。

场景走查:地址、字节和两种排法

假设内存从地址 0x100 开始,依次存放四个字节。小端机器写入 32 位整数 0x01020304 时,最低有效字节 0x04 放在 0x100,0x03 放在 0x101,0x02 放在 0x102,最高有效字节 0x01 放在 0x103。大端机器反过来,0x01 放在 0x100,0x04 放在 0x103。两种机器都认为这个整数是 0x01020304,只是内部摆放方向不同。

这个定义有一个容易混淆的点:大端和小端描述的是“多字节数据”的排列。单个字节没有字节序,两个字节的 16 位整数、四个字节的 32 位整数、八个字节的浮点数才有。字符串也不需要讨论字节序,因为字符的先后顺序由编码规定,UTF-8 的字节顺序是固定的。只有把多个字节当成一个整体数值时,才需要问哪头是高位。

为什么会有两种设计?历史上不同的处理器厂商各自选了不同的方案,没有谁在数学上更正确。小端的好处是,从低地址开始就能读到低位,做地址运算和类型转换时某些操作更自然;大端的好处是,高位在前,和人类书写数字的顺序一致,比较大小、打印调试时更直观。两者的性能差异在现代处理器上很小,真正的成本在“跨越边界时的转换和约定”。

在同一个进程内部,字节序几乎不会造成问题。编译器、操作系统、库都用同一套规则,你读自己写的变量,永远读到正确的值。问题只在“把内存原样交给外部”时出现:写文件、发网络、共享内存、跨语言调用。所以判断要不要处理字节序,只需要问一句:这段字节会不会离开当前这台机器、这个进程、这个运行时。

有些处理器支持双端模式,可以在启动时或运行中切换大小端,常见于 ARM 和部分 MIPS、RISC-V 核。双端模式增加了灵活性,也增加了复杂度:同一份代码在不同配置下行为不同,调试时先确认芯片当前运行在哪种模式。嵌入式开发里,启动脚本、链接器配置、编译器选项都可能影响这一点,别只看芯片手册的默认值。

大端

最高有效字节放在最低地址。网络协议、部分嵌入式设备和老式服务器常用。读十六进制时和人写数字的顺序一致。

小端

最低有效字节放在最低地址。x86、多数 ARM 和移动设备常用。取低位、做指针运算时比较顺手。

“网络字节序”是一个约定,不是某种硬件特性。TCP/IP 协议族规定,IP 地址、端口号、报文里的多字节字段统一按大端传输。所以抓包工具里看到的端口 80,字节是 00 50,前面是高字节 0x00,后面是低字节 0x50。如果你在小端机器上直接把这两个字节当成本地整数读,得到的是 0x5000,也就是 20480。这个数字看起来也像个端口,但完全不是 80。

场景走查:四个容易出问题的边界

第一个边界是文件。程序把内存里的整数直接写进文件,换一台机器读,字节序不同就会读错。更麻烦的是,结构体里还有对齐填充,字段之间可能有空洞,直接按结构体写文件,等于把编译器的布局细节也写进去了。换个编译器、换个平台,字段偏移和总大小都可能变。二进制文件格式必须逐字段定义类型、宽度和字节序,不能靠“把结构体 memcpy 出去”。

第二个边界是网络。协议规定了字节序,程序在发送前要把本地整数转成网络序,接收后再转回本地序。C 里用 htons、htonl、ntohs、ntohl 这组函数,名字里的 h 是 host,n 是 network,s 是 short,l 是 long。它们在小端机器上真的会交换字节,在大端机器上可能是空操作。写代码时不要假设“我的机器是小端,手动反转就行”,用标准函数或库的序列化接口更稳。

第三个边界是设备协议。很多工业设备、传感器、PLC 的寄存器是 16 位或 32 位,手册会写明“高字在前”还是“低字在前”。32 位数据可能被拆成两个 16 位寄存器,除了字节序,还有“字序”问题:先发高 16 位还是低 16 位。两个寄存器各自按大端排,组合起来可能是“大端字节序加小端字序”的混合形态。只看字节顺序不够,要把寄存器映射一起看。

第四个边界是序列化格式。JSON、XML、YAML 这些文本格式不涉及字节序,因为数字被写成十进制字符串,解析器按文本规则读。Protobuf、MessagePack、CBOR 这类二进制格式则在规范里写死了字节序,通常是大端或按字段声明。用库的时候一般不用自己管,但自己实现解析器时,必须按规范逐字节处理,不能想当然。

文件头也值得单独说。很多二进制格式会在开头放几个固定字节的魔数(magic number),再放版本号、字段偏移和字节序标记。魔数不只是“认格式”,还常常用来判断对方写的是大端还是小端:同一个魔数按两种顺序读,只有一种能对上,另一种明显不像。读文件前先验证魔数和长度字段,能挡掉大部分“格式不对”的错误,而不是等到解析到一半才发现。

实测:本机是小端,两种打包结果相反

先用 Python 看本机的字节序,再把同一个整数按两种规则打包:

import sys, struct

print(sys.byteorder)                       # little
print(struct.pack('<I', 0x01020304))      # b'\x04\x03\x02\x01'
print(struct.pack('>I', 0x01020304))      # b'\x01\x02\x03\x04'
print(int.from_bytes(b'\x01\x02\x03\x04', 'little'))  # 67305985
print(int.from_bytes(b'\x01\x02\x03\x04', 'big'))     # 16909060

本机 Python 3.15 的实际输出:little、b'\x04\x03\x02\x01'、b'\x01\x02\x03\x04'、67305985、16909060。格式字符串里的 < 表示小端,> 表示大端,不带符号时用本机默认。注意打包出来的字节顺序和读出来的数值正好互相印证:小端打包 0x01020304 得到 04 03 02 01,再用小端读回就是原值。

浮点数也一样。1.5 的 double 位模式是 3ff8000000000000,小端打包后字节顺序反过来:

print(struct.pack('<d', 1.5).hex())   # 000000000000f83f
print(struct.pack('>d', 1.5).hex())   # 3ff8000000000000

这说明字节序不只影响整数,也影响浮点、指针和任何多字节类型。有人以为“浮点是 IEEE 754 标准,应该跨平台一致”,标准只规定了位模式的含义,没规定这些位在内存地址里的排列顺序。跨平台交换浮点数据,同样要转换。

再看 C 里用 union 直接观察内存布局。下面这段代码在本机 gcc 16.2 上编译运行:

union { unsigned int i; unsigned char c[4]; } u;
u.i = 0x01020304u;
printf("bytes = %02x %02x %02x %02x\n", u.c[0], u.c[1], u.c[2], u.c[3]);

实际输出:bytes = 04 03 02 01。最低地址的 u.c[0] 是 0x04,说明本机是小端。这段代码依赖 union 的类型双关,在 C 里是常见技巧,但严格说也有实现相关的成分。生产代码里判断字节序,更稳妥的是用编译器的宏或系统提供的接口,而不是自己玩 union。

顺便记一下本机的类型宽度:同一段代码打印 sizeof(long) 得到 4,因为 Windows 用 LLP64 模型,long 保持 32 位,指针才是 64 位。这意味着“按 long 写文件”在 Windows 和 Linux 上写出的字节数都可能不同,加上字节序差异,跨平台读写的坑会叠在一起。二进制格式里一律用写死宽度的类型,能少一类问题。

现象对照表

现象真实原因第一步查什么
同一份日志在两个工具里解析出两个序号写入端和读取端的字节序约定不同看文件格式或协议有没有声明字节序
TCP 端口 80 被读成 20480网络字段是大端,本地按小端解析确认是否用了网络序转换函数
结构体直接写文件,换平台读错字节序不同,且结构体还有对齐填充检查是否按字段序列化,是否写死了宽度
double 读出来是一个奇怪的小数浮点的 8 个字节也被按错误顺序拼接确认浮点字段的字节序和宽度
读大端设备的数据全错设备按大端写,程序按小端读查设备手册的字节序和寄存器映射
32 位值高低 16 位颠倒除了字节序,还有字序或寄存器顺序问题看协议是“高字在前”还是“低字在前”
同一进程内读写正常,跨进程错边界处没有统一表示,各自用本地序在边界处显式转换,别传裸内存
位域结构体在不同编译器上布局不同位域的分配顺序和对齐规则由实现决定别用位域定义协议字段,改用掩码和移位

边界与代价

字节序本身没有“对错”,代价在于约定不统一。两个系统交换数据,只要双方都按同一规则读写,大端小端都能工作。真正的问题是,很多格式没有明确声明,靠默认值或实现细节,换一个库、换一个语言就变了。工程上的原则是:在边界处选一个规范表示,通常是网络序或格式规范指定的序,进入程序后立刻转成本地序,内部逻辑不再关心字节排列。

第二个代价是结构体布局。C 的结构体不保证字段顺序、不保证没有填充、不保证总大小,这些都由 ABI 和对齐规则决定。把结构体直接写文件或发网络,看起来省事,实际上把编译器的实现细节当成了协议。正确的做法是逐字段序列化,每个字段写明确的宽度和字节序,读的时候也逐字段解析。多写几行代码,换来的是跨平台可移植。

第三个代价是性能和可读性。逐字段序列化比 memcpy 慢,尤其是大数组和高频传输;但 memcpy 省下的时间,往往会在排查跨平台问题时加倍还回去。对性能极端的场景,可以用批量转换、SIMD 或专门的序列化库,但仍然要保证格式明确。不要为了省一次转换,把裸内存直接扔到网络上。

第四个代价是“字节序”和“位序”的混淆。协议里经常同时出现“第 0 位是最低位”“字段按大端传输”这样的描述。位序影响掩码和移位,字节序影响多字节拼接,两者是不同层面。调试时先把字节序确认清楚,再按位操作展开,别在一个层面里找另一个层面的问题。

第五个代价是历史遗留。老设备、老协议、老文件可能用混合字节序,比如 32 位值的高 16 位按大端、低 16 位按小端,或者寄存器顺序和字节顺序相反。遇到这种格式,不能靠“通用转换函数”一把梭,要按字段逐个对照手册,写测试用例固定住行为。没有测试用例的字节序代码,改一次错一次。

最后是安全层面的代价。解析不可信数据时,字节序错误可能导致长度字段被读成一个巨大的值,进而触发越界分配或拒绝服务。解析器要在转换后做范围检查,不能假设“对面写的是对的”。这类问题在协议实现、文件解析器、物联网网关里都出现过,和字节序本身无关,但常常由字节序混淆引发。

当天能自己验证的练习

  1. 用 Python 打印 sys.byteorder,再把 0x01020304 分别按小端和大端打包,打印字节,确认和本机类型一致。
  2. 写一个 C 程序,用 union 把 0x01020304 写进 4 字节数组,打印每个字节;再换成本机默认写入方式对比。
  3. 用 struct.pack('<I', n) 写一个 4 字节文件,再用 '>I' 读回来,观察数值变化,算一算两者之间的关系。
  4. 写一个字节交换函数,把 0x12345678 变成 0x78563412,再用 struct 验证;思考为什么它不能直接替代协议里的字节序转换。
  5. 手工构造一个 20 字节的 TCP 头,用 struct.pack('>HHII', ...) 填入源端口 12345、目的端口 80,再按小端解析端口字段,观察读出的两个数。本机没有真实抓包环境,这一条只用构造数据验证,未做实际抓包。

小结与下一篇

字节序是多字节数据在内存地址里的排列约定。大端把最高有效字节放最低地址,小端把最低有效字节放最低地址。x86 和多数 ARM 是小端,网络协议用大端,设备手册要单独确认。跨文件、跨网络、跨设备时,必须在边界处显式转换;结构体不能直接落盘,位域不能拿来定义协议。本机是 x86 小端,纯大端硬件上的行为未在本机实测。

字节序解决的是“多个字节怎么拼成一个数”,但很多时候我们根本不关心整个数,只想看某一位是否为 1、某几位组合成什么值。下一篇讲权限、标志位和掩码:位运算在真实代码里干什么,把与、或、异或、移位放回权限系统和配置开关里。