05 · 终端与伪终端:同一串字节,三种活法
咱们这些天敲过的命令,回车一按结果就出来了。可要是把程序丢到后台去跑,它跟键盘就断了:敲键它收不到,被人按了一下 Ctrl-C 它也无从知道。这些看着平常的待遇,全是从一个东西那儿领的:控制终端。
这一篇咱们讲的就是它。终端这东西的年纪比 Unix 还大,当年它是一台真的打字机:咱们在键盘上敲一个字节,它就在纸上打一个字节。后来那些终端都披着键盘和屏幕的样子,可干活的早不是当年那副机器了。内核里有一个叫终端驱动的小子系统,一头连着键盘屏幕这侧,一头连着程序,字节在中间过一趟,身份就可能变了:回车被翻译成换行,回显被添上去,Ctrl-C 那个字节半路被截下来换成信号。这一趟的处理方式,行话叫行规(line discipline)。
这是咱们自己画的一张流水线图:
键盘/屏幕 -> 输入侧开关 -> 按行交付的缓冲 -> 程序的 read()
^ |
+-- 回显 ----------+ (输出侧开关管着出去的那一路)
^C / ^D 这类字节在中间被认出来,换成信号送给前台进程组咱们今天要回答的问题就落在这段流水线上:同一个字节为什么能走出好几种结果,一路上是谁在经手、改乱了又怎么收场。图上那些方框,咱们接下来一个个换成能跑的命令。
咱们手里的机器上,得现开一个终端
这一篇的实验全都在咱们跟前这个系统里跑,下面引的每一屏也都是它跑出来的,您那边会是不一样的数,咱们会逐处说清。眼下它有三条看得见的限制,不交代清楚,您照着敲就会对不上。
咱们在这个系统里的身份是 uid=1000,没有 root,/ 挂成了只读。凡是需要改系统设置、写 / 根目录的动作,这一篇一次都不会出现。真要用到,只能照书上的例子说,咱们会说明白。
它的进程表短得出奇。ps -e 数出来只有几条,进程号都是个位到三位数。跟您自己机器上的进程表一比,它短得不像话——它有一套独立的进程号。咱们在下面数出来的号,您那边一定不一样。
还有一条更要紧的:它没有控制终端。tty 这个命令直接回一句 not a tty,退出码是 1。ps 报出来的那几列里,进程组和会话两个号都被压成了 0,前台终端的那一列是 -1。这不算知识,是笔者跟前这个环境本机此刻的样子。
终端相关的实验,得有一个终端才跑得起来——这儿没有,那就现开一个。后面的命令里会出现 script,咱们拿它把要跑的东西包起来:
script -qec "stty -a" /dev/nullscript 会当场给咱们那段命令配一个伪终端。您敲进这个窗口的那一行,和您在真正的终端窗口里敲的效果一样。下面那一屏里还有 stty -a | wc -l 和 stty size 两条,是在同一个伪终端里接着敲的,也这么来。
伪终端是一对虚拟字符设备:一头叫主端,一头叫从端。从端对外表现得和一台古典终端毫无区别,往主端写进去的东西,从端那边的程序收到的,就像有人在键盘上敲的一样。
script就是这么把从端接到您敲的那条命令上的。
一屏终端参数,四个局面
现开出来的那个终端上,stty 能把它此刻的全部设置一次报出来。stty -a 那一屏在本机是 10 行,咱们整屏看一次:
$ stty -a
speed 38400 baud; rows 0; columns 0; line = 0;
intr = ^C; quit = ^\; erase = ^?; kill = ^U; eof = ^D; eol = <undef>;
eol2 = <undef>; swtch = <undef>; start = ^Q; stop = ^S; susp = ^Z; rprnt = ^R;
werase = ^W; lnext = ^V; discard = ^O; min = 1; time = 0;
-parenb -parodd -cmspar cs8 -hupcl -cstopb cread -clocal -crtscts
-ignbrk -brkint -ignpar -parmrk -inpck -istrip -inlcr -igncr icrnl ixon -ixoff
-iuclc -ixany -imaxbel -iutf8
opost -olcuc -ocrnl onlcr -onocr -onlret -ofill -ofdel nl0 cr0 tab0 bs0 vt0 ff0
isig icanon iexten echo echoe echok -echonl -noflsh -xcase -tostop -echoprt
echoctl echoke -flusho -extproc
$ stty -a | wc -l
10
$ stty size
0 0咱们跟着这一屏往下走。头一行报的是速率和窗口大小。rows 0; columns 0 说的是 script 给出来的伪终端没告诉内核自己有多大,stty size 同样报 0 0。您在真正的终端窗口里敲同一条命令,那里一般是 24 80 一类的真值。
接下来那三行是特殊字符表。左边那一串等号认的是键盘上哪个字节该被当成什么:intr = ^C 是打断,quit = ^\ 是退出,erase = ^? 是后退一格,kill = ^U 是把这一行抹掉,eof = ^D 是输入到此结束,susp = ^Z 是挂起。您要是拿别的工具改过键盘映射,这几格也会跟着变。
再往下那三行又是一片,管的是输入侧:从终端进来的字节要不要被改动。紧跟着的三行是最后一片,输出侧开关加上本地开关,管的是出去的那一路怎么排,以及回显、按行、认不认特殊字符这些事。名字太多,咱们只认五个,一个一个给您用出来。icanon 管按行交付,开着的时候程序要等到整行才拿到,关掉它,敲一个字节程序就拿到一个。echo 管回显,您敲的字自己出现在屏幕上就是它办的,关掉它,字还在往里走,只是屏幕不响了。isig 管要不要认特殊字符,把它关掉,^C 就只是一个普通字节。icrnl 管进来那一路的回车翻译,onlcr 管出去那一路的换行翻译。本机这一屏里,五个都是开着的。
stty sane:把终端设坏了怎么救
咱们在一台临时的伪终端上试,不动您现在这个窗口。stty -echo 一敲,接下来敲的字自己就看不见了,可在另一头等着的程序照样收得到:
$ stty -echo; echo "这一行你敲的时候看不见"; stty echo; echo "回显回来了"
这一行你敲的时候看不见
回显回来了两行提示文字是 echo 命令打出来的,不走回显那一趟,所以照出。真正藏起来的是您手指敲下去的字符。
咱们把按行和回车翻译也关掉,屏幕上就更不像话了:
$ stty -icanon -echo; printf "abc\n"; stty sane; echo; echo "stty sane 之后回来了"
abc
stty sane 之后回来了
$ stty -a | head -1
speed 38400 baud; rows 0; columns 0; line = 0;abc 打出来之后照样换了行 —— 输出的那一路开关咱们没动,\n 出去的时候它照旧补上回车。下面空出来的那一行是后面那个 echo 自己打的光换行。真正变的是输入那一侧:按行的等待关掉了,回显也没了。
要是您在自己的终端窗口里把这几样关乱了,救回来的那一手是 stty sane:它把这一整套参数恢复成一套正常的默认值。您想不起来具体坏在哪一项,直接来这么一条就行。咱们上面那两段能顺顺当当收场,靠的也是它。
同一串字节,三种活法
行规这一层听着虚,拿一串字节喂进去就实了。咱们写一个短程序,开伪终端靠 Python 标准库里的 pty,设模式靠 termios,把同一串字节按三种设置各喂一遍。造件 57 行,只用到 Python 标准库,除了 python3 本身什么都不用装。python3 得您手边有。存成 ldisc.py,跑 python3 ldisc.py:
展开代码收起代码共 57 行
#!/usr/bin/env python3
"""用 Python 的 pty 模块开一个真的伪终端,喂同一串字节,看终端驱动把它变成什么。
三个开关各跑一遍:默认(回显+规范模式)/ -echo / -echo -icanon(raw)。"""
import os
import pty
import select
import sys
import termios
import time
PAYLOAD = b"hi\rthere\bx\niy\n"
def run(label: str, raw: bool, echo: bool) -> list[bytes]:
pid, fd = pty.fork()
if pid == 0:
# 孩子:挂在从端上,配好想要的模式,然后把主端喂进来的字节原样吐回去
attrs = termios.tcgetattr(0)
if raw:
attrs[3] &= ~(termios.ICANON | termios.ECHO | termios.ISIG)
attrs[6][termios.VMIN] = 1
attrs[6][termios.VTIME] = 0
elif not echo:
attrs[3] &= ~termios.ECHO
termios.tcsetattr(0, termios.TCSANOW, attrs)
os.write(1, b"\nREADY\n")
data = os.read(0, 4096)
os.write(1, b"\nGOT[")
os.write(1, data)
os.write(1, b"]\n")
os._exit(0)
# 父:读掉孩子的 READY,再把同一串字节喂进去,把它自己的回显与回吐都收集起来
buf = b""
deadline = time.time() + 3
while b"READY" not in buf and time.time() < deadline:
if select.select([fd], [], [], 0.2)[0]:
buf += os.read(fd, 4096)
out = b""
os.write(fd, PAYLOAD)
deadline = time.time() + 3
while b"GOT[" not in out and time.time() < deadline:
if select.select([fd], [], [], 0.2)[0]:
out += os.read(fd, 4096)
os.close(fd)
os.waitpid(pid, 0)
return [PAYLOAD, buf, out]
for label, raw, echo in [("默认(回显 + 规范模式)", False, True),
("stty -echo(只关回显)", False, False),
("stty -echo -icanon(raw)", True, False)]:
sent, ready, out = run(label, raw, echo)
print("=" * 60)
print(label)
print(f" 喂进去 : {sent!r}")
print(f" 收到的回显 + 回吐: {out!r}")
print(f" 不喂东西时的握手: {ready!r}")孩子那一头是直接改终端参数的,没走 stty。三格里改的东西,和 stty 几个开关是同一批。run() 里那个孩子往从端写一句 READY,父端读到之后才喂字节,这样喂进去的那一刻孩子一定已经坐好了。那串字节是 hi,一个回车,there,一个退格,x,一个换行,iy,又一个换行 —— 里面故意放了一个回车和一个退格,因为终端驱动最爱管的就是这两样。喂完收回来的是三行,咱们分段看:
$ python3 ldisc.py
============================================================
默认(回显 + 规范模式)
喂进去 : b'hi\rthere\x08x\niy\n'
收到的回显 + 回吐: b'hi\r\nthere^Hx\r\niy\r\n\r\nGOT[hi\r\n]\r\n'
不喂东西时的握手: b'\r\nREADY\r\n'
============================================================
stty -echo(只关回显)
喂进去 : b'hi\rthere\x08x\niy\n'
收到的回显 + 回吐: b'\r\nGOT[hi\r\n]\r\n'
不喂东西时的握手: b'\r\nREADY\r\n'
============================================================
stty -echo -icanon(raw)
喂进去 : b'hi\rthere\x08x\niy\n'
收到的回显 + 回吐: b'\r\nGOT[hi\r\nthere\x08x\r\niy\r\n]\r\n'
不喂东西时的握手: b'\r\nREADY\r\n'那一屏是 Python 把字节原样印出来的,b'…' 是它的写法,\r、\n、\x08 都是字节本身,不是屏幕上长这样。GOT[…] 那一对括号里装的就是程序真正读到的东西,它是这一屏里最该看的一处。咱们把三段摊开对照:
| 模式 | 屏幕上回来的那一份 | 程序真正读到的 |
|---|---|---|
| 默认(回显 + 规范) | hi 换行 there^Hx 换行 iy 换行 | 只有 hi 和它后面那个换行 |
| 关掉回显 | 一个字节都没有 | 还是 hi 和换行,数据照到 |
| 回显与按行都关掉 | 没有 | 整串原样,there、退格、x、iy 全在里面 |
咱们从默认的一格看起,程序读到的东西为什么这么少? icanon 开着,程序得等到整行才被叫醒,iy\n 那一行还在缓冲里躺着。回显那一栏里怎么多出来一个 ^H? echoctl 开着,控制字符不直接吐回屏幕,而是画成 ^H 这个样子给咱们看。
最该琢磨的是第三格。there\x08x 原样进了程序,一个字符都没被擦掉。咱们容易顺口说成“退格不归驱动管了”,可您回头看这一屏开头的特殊字符表,上面写的是 erase = ^? —— 这个终端上的擦除键是 ^?,也就是键盘上那个 Delete,\x08(键盘上的 Backspace)本来就不在表里。所以它到哪儿都没被擦过。icanon 关掉之后真正变的是:整串字节不再等到换行才交付,\x08 连同前后的字节,敲一个交一个。
回车那一路也容易说反。hi\r 里那个回车确实变成了换行交给了程序,可那是 icrnl 一层办的:进来的回车翻成换行,程序读到的是 hi\n,不是 hi\r\n。屏上那个 \r 是程序把 \n 打出去的时候,出去的 onlcr 一层补上的 —— 一进一出两层合起来,才有了咱们看到的这一串。同一串字节,三种设置读到三种结果。您那个程序没写错,差出来的是中间那趟处理。
驱动替您做的那点事
咱们再换一个角度,看驱动到底伸手改了哪些字节。屏幕上打一个 a,敲一个退格,再打一个 c,咱们看到的是一格被擦掉、换成了 c。真正从键盘过去的那串字节,得摆出来才看得见 —— 头一屏是笔者照同一串字节另跑的一次,加了一道 cat -v 把控制字符画出来。不加它的时候,肉眼看到的是擦掉以后那个 ac:
$ printf "a\bc\r\n" | cat -v
a^Hc^M
$ printf "a\bc\r\n" | od -c | head -2
0000000 a \b c \r \n
0000005cat -v 和 od -c 把同一串字节摆出来给咱们看。cat -v 把印不出来的字节画成看得见的记号,^H 是那个退格,^M 是那个回车。od -c 则把五个字节一个一个报出名字,里面 a、\b、c、\r、\n 一个都没少。擦掉这个动作发生在屏幕上,不在字节里 —— 屏幕上少掉的那个 a,字节里一个都没丢。
同一个 \003,两种身份
行规露出真章的一处,是一个字节的两副面孔。咱们把 x、一个 \003、y 写进文件,再用 od -c 看:
$ printf "x\003y\n" > ctl.txt; od -c ctl.txt
0000000 x 003 y \n
0000004
$ cat ctl.txt | od -c | head -2
0000000 x 003 y \n
0000004这两次看下来,咱们手上只有一个普普通通的 003。文件里它是数据,从管道里过一趟它还是数据。
咱们现在换一条路,让同一个字节从伪终端的主端进去。这一屏得有支跑得住、又能出声的脚本当靶子。它报出自己的进程号和进程组,然后每秒留一个记号,没人打断就一路数下去。存成 loud.sh:
#!/bin/bash
export LC_ALL=C
echo "开始:pid=$$ 组=$(ps -o pgid= -p $$ | tr -d ' ') 前台组=$(ps -o tpgid= -p $$ | tr -d ' ')"
for i in 1 2 3 4 5 6 7 8; do
echo "第 $i 秒:还在跑 $(ps -o stat= -p $$ | tr -d ' ')"
sleep 1
done
echo "整整八秒都没人打断我"咱们把脚本放进 script 现开的伪终端里跑,半秒之后从主端送进去一个 \003:
$ (sleep 0.4; printf "\003") | script -qec "bash loud.sh" /dev/null
开始:pid=332 组=332 前台组=332
第 1 秒:还在跑 Ss+
^C那个 \003 没有送到任何程序手里。驱动在中间就把它认了出来,换成 SIGINT,投给这个终端的前台进程组。进程在“第 1 秒”那个记号之后就没有了:脚本本来要数到第八秒,还要打一句收场话,这里一句都没等到。同一串字节,写进文件是三个字符,送进主端是一次中断 —— 分界不在字节,在它走的是哪条路。屏幕上多出来的 ^C,就是驱动顺手回显给咱们看的。您在真正的终端窗口里按 Ctrl-C,不用管道,走的也是这一路。同一张靶子屏在讲信号那一篇里已经引过一次,那里读的是信号那一侧。
这一屏三个号还是跑它的机器留下的(您那边会是自己的号)。Ss+ 读的是状态:这个进程在等、它是这个会话的领头者、它坐在前台。
一个坐在终端前的程序,/proc 里是什么样
终端这边的事,从进程那一头也能看到。咱们让一段程序坐在现开的伪终端里,看它自己的文件描述符表:
$ script -qec "ls -l /proc/\$\$/fd" /dev/null
lrwx------ 1 user user 64 Oct 2 16:10 0 -> /dev/pts/0
lrwx------ 1 user user 64 Oct 2 16:10 1 -> /dev/pts/0
lrwx------ 1 user user 64 Oct 2 16:10 2 -> /dev/pts/0这一屏是摘出来的,咱们把摘法说全。原屏是连着记下来的:顶上那行小标题,和开头那句“我在一个 pty 上:号”,都是跑它的脚本自己打的标签,不是命令的输出,咱们没搬。ls 那一行原本写在一个脚本文件里,上面那行命令行是咱们按那个配方重写给您看的。输出里咱们只留了 0、1、2 三格,原有的 total 0 那一行,以及多出来的那行,都不在这儿。原屏里多出来的那行,是那个脚本文件被 bash 打开时留下的描述符,落点是一整条绝对路径。您按上面那行命令行跑,$$ 认的是 script 现拉起来的那个 shell,多出来的那行是那个 shell 自己的(落点是 /proc/<号>/fd 一类),跟原屏里那行不是同一个东西。再往下,原屏还连着一段 status 读数,cat /proc/$$/status | grep -E "^(Pid|PPid|SigIgn)" 加上 Pid、PPid、SigIgn 三行,跟这里要看的格子无关,也没搬。两列用户名印的是属主和属组,咱们都替成了 user 这个占位符,原屏上印的本来是跑这一屏的机器上的用户名。连起来看会像两个同名的东西,它们是两列。时间戳和 /dev/pts/0 是跑这一屏的机器留下的原样。您那边 /dev/pts/N 的 N 是自己这次开出来的号,时间戳也是您那一刻的。
0、1、2 三格指向同一个 /dev/pts/0。咱们再从孩子那一头确认一次:让一段程序自己开一对伪终端,把孩子的 0、1、2 全接到从端上,再回过头把从端接到的那几条路径读出来。存成 child.py。这里省掉了开头的 shebang 和那句自述,末尾那句 print 另外接了一道 .replace("\r", ""),其余与笔者跑的版本一致:
展开代码收起代码共 27 行
import os
import pty
import subprocess
import sys
master, slave = pty.openpty()
print("父端(master)fd =", master, "; 从端(slave)fd =", slave)
code = (
"import os;"
"print('ttyname(0) =', os.ttyname(0));"
"print('0/1/2 ->', ', '.join(os.readlink(f'/proc/self/fd/{i}') for i in (0,1,2)))"
)
proc = subprocess.Popen([sys.executable, "-c", code], stdin=slave, stdout=slave, stderr=slave, close_fds=True)
os.close(slave)
out = b""
while True:
try:
chunk = os.read(master, 4096)
except OSError:
break
if not chunk:
break
out += chunk
proc.wait()
os.close(master)
print("父亲从主端读到孩子写的东西:")
print(out.decode(errors="replace").replace("\r", ""), end="")咱们跑一遍,看到的还是那几格:
$ python3 child.py
父端(master)fd = 3 ; 从端(slave)fd = 4
父亲从主端读到孩子写的东西:
ttyname(0) = /dev/pts/0
0/1/2 -> /dev/pts/0, /dev/pts/0, /dev/pts/0三格一致,指向的就是伪终端的从端。底下那几行都出自孩子的手:它写进从端,父端再从主端把它们读回来,不是父端自己印的。头一行是父端开出来的两格号。中间那一行是父端说“我从主端读到东西了”,底下两行才是孩子的话:孩子开口问“我是谁”,从 ttyname 和 /proc/self/fd 两处问出来的都是同一个从端。/dev/pts/N 里的 N 是这次开出来的编号,您那边每次都不一样,咱们要读的只是“三个标准 fd 都落在同一个从端上”这一点。至于父端和从端那一对,从端是给孩子用的,父端是给外面握着键盘屏幕的程序用的。还有一处得说清:孩子写出去的换行,到了从端那边又被 onlcr 补上一个回车,父端读回来的那两行末尾本来各多一个 \r。child.py 里那句 .replace("\r", "") 就是把它抹掉的,抹掉之后才是您在上面看到的样子。
这件事在 ps 上也留了一行。下面两屏是一次运行读下来的:咱们把屏里那些 $ 打头的行按次序存成一支脚本 —— 存成 ptyshow.sh,那个 $ 只是记号,别抄进文件里 —— 让 script 现开一个伪终端、交给 bash 跑一遍:script -qec "bash ptyshow.sh" /dev/null。得走非交互的那一路,作业控制那个开关才是关着的。交互式 shell 里它的默认值不同,一行一行敲会读到另一个状态:
$ ps -o pid,ppid,pgid,sid,tpgid,stat,comm -p $$
PID PPID PGID SID TPGID STAT COMMAND
246 245 246 246 246 Ss+ bash进程组、会话、前台终端三列都是它自己的号。这一屏和讲进程生命周期那一篇里现开伪终端的那一屏是同一次运行读下来的,连号都一样。这两屏里的号都是跑它的机器留下的,您那边是您自己那一刻的号。咱们看这个 shell 自己是组长,自己领头开了这个会话,眼下坐在前台。同样这几个号放在没有终端的地方问,就都被压成了 0 和 -1,那一屏在讲进程生命周期的那一篇里。挂一个后台作业上去,它跟 shell 分在同一个组里,前台坐着的还是 shell:
$ sleep 30 & jobs; ps -e -o pid,ppid,pgid,sid,tpgid,stat,comm | grep -w sleep | grep -v grep
[1]+ Running sleep 30 &
251 246 246 246 246 S+ sleep会不会另开一个进程组来放后台作业,归 shell 的作业控制开关管。这里咱们没做实验,把它记在后面的欠条里。
屏幕上只有一半东西的时候
要是您照着敲完,发现哪一步跟自己那边对不上,按这几个去处看看。
**stty -a 报 Inappropriate ioctl for device。**这十有八九是因为您没在终端上敲它。stty 问的是“我这个终端此刻什么设置”,它的输入得是一个终端。您把它接在管道后面、或者放进脚本里喂着跑,它就没有终端可问。回到您的终端窗口里,或者拿 script 包一层。
**tty 说 not a tty。**这是咱们跟前这个系统默认的样子,不是您敲错了。要终端就得现开一个,咱们上面用的都是这一手。
**stty -a 报出来的开关跟这里不一样。**那一屏报的是某一个终端此刻的状态,内核版本不同、发行版不同,多几个名字、少几个名字都正常。咱们要认的只有五个,按行、回显、认特殊字符、进来的回车翻译、出去的回车翻译。
**敲完 stty -echo 看不见自己打的字了。**别慌,程序那边照收。您把您想敲的命令敲完按回车,它照样执行。执行完记得打一条 stty sane。
**rows 0; columns 0。**这是 script 给出来的伪终端没设窗口大小,stty size 也报 0 0。您在真正的终端窗口里看到的是 24 80 一类真值。
没敢动的 ^C,和没等来的那次挂断
改中断键这一拍咱们没做,这次只改了回显和按行两项。改 intr 的收场得格外小心 —— 把 ^C 换成别的键之后,得再用 stty intr ^C 换回来,中间那一段是没有打断键可用的。这一项留着,等哪次真要用到再补。
nohup 咱们只验证了它起得来,ps 能看到那个 sleep 在跑。它到底怎么对待挂断信号,得有一个真能断掉的控制终端才试得出来。咱们跟前这个系统里没有那样的过程,所以这一篇不给判断。跟它常被并排提起的 disown,这次一轮都没跑,连起得来这一句也谈不上,一并记在这里。
上面那一屏只说了“它和 shell 同组”这个结果,没说 monitor 那个开关前后各是什么样 —— set -o 里那一项就叫 monitor,script 起的那个 shell 里它是关着的。讲进程生命周期那一篇留过来的欠条,记的就是咱们这一篇要交代的事。
终端窗口大小怎么影响正在跑的程序,SIGWINCH 信号什么时候来,这一篇一个字都没进。窗口一变就通知程序这件事,咱们连现场都没搭。
还剩两笔没交代。《UNIX/Linux 系统编程手册》第 62 章里有开关定义表,咱们没摘到逐字,手头的书只给了页号,所以上面五个名字的解释是按 stty 自己的说法写的,没有引书上的定义。ssh、telnet 这一类跨机器的终端是怎么回事,咱们也没碰。
双视角锚点:按下去的那一下,两边看到的不同
您按了一下 Ctrl-C。在您手底下,这是一次按键,是“停下”的意思,天经地义。
在驱动程序这边,进来的却是一个字节 \003。咱们看它怎么处置:它查了一下特殊字符表,发现配着 intr 的是这个字节,于是它不把它交给程序,而是换成 SIGINT,查一下前台进程组是谁,把信号投过去。程序从头到尾没见过 \003。
同一件事,您那边看到的是按键和结果,这边看到的是一个字节被换成了信号。咱们前面把 \003 写进文件的那次实验,就是这套说法的反面:路走错了,同样的字节从头到尾都只是数据。
字节进来之后谁负责翻译、翻译完了交给谁,等您往后写代码的时候,这一段还是这几个人在办。