banner
banner
banner
NEWS LETTER

AI 应用知识体系(六):音视频、附录与面试题库

Scroll down

本篇是系列第 6 篇,包含音视频基础、附录和面试题库。

十四、音视频与 FFmpeg 基础

一句话定位:前端做 AI 音视频,90% 的时间不花在「编解码原理」上,而花在「参数放对位置 + 滤镜串对链」上。本章按「概念 → 命令结构 → 高频操作 → 滤镜 → 色彩空间 → 前端落地」六层展开,命令均可直接复制执行。

能力清单

能力 达到什么程度 对应
分清容器 / 编码 / 协议 拿到一个文件能说出「换盒子还是重压」 §14.1
像素格式与色彩参数 看懂 yuv420p、bt709、color_range 并会修偏色 §14.2
命令行结构与参数位置 不再出现「加了参数却没生效」 §14.3
高频操作 转码、切音频、无损切片、压体积、抽帧、GIF、合并、HLS §14.4
滤镜链 能自己写 -filter_complex 做画中画/拼接/混音 §14.5
视觉增强 裁剪、缩放补边、水印、走马灯、字幕、打码 §14.6
色彩空间对接 Canvas 的 RGBA 帧能正确喂给编码器 §14.7
前端与 AI 场景 会选 MediaRecorder / WebCodecs / ffmpeg.wasm §14.8

14.1 三个必须先分清的概念:容器、编码、协议

一句话:容器管「怎么装」,编码管「怎么压」,协议管「怎么传」。

层 职责 例子
容器 Container / Muxer 把视频流、音频流、字幕、元数据打包成一个文件,并写时间戳索引 .mp4 .mkv .flv .webm .ts
编码 Codec 把原始画面与声音压缩成码流 H.264、H.265、VP9、AV1、AAC、Opus
协议 Protocol 决定码流怎么切块、怎么传输 HLS(.m3u8 + .ts)、DASH、RTMP、WebRTC

核心结论:同一个 mp4 里可以放 H.264,也可以放 H.265;同一份 H.264 码流既能装进 mp4,也能装进 flv。容器与编码是两个正交维度——这是这块最常被追问的点。

容器 常见视频编码 常见音频编码 典型场景 浏览器兼容
MP4 H.264 / H.265 / AV1 AAC 通用点播、短视频 全平台(H.265 看终端)
WebM VP8 / VP9 / AV1 Opus / Vorbis Web 端开源方案 Chrome / Firefox;Safari 17+
FLV H.264 AAC / MP3 老直播、HTTP-FLV 需 flv.js
MKV 几乎任意 几乎任意 本地播放、多音轨多字幕 不支持
TS H.264 / H.265 AAC HLS 切片载体 通过 hls.js
MOV H.264 / ProRes AAC / PCM 剪辑中间态、苹果生态 部分
编码 压缩率(相对 H.264) 编码耗时 授权 建议
H.264 / AVC 1x 快 需授权但已普及 默认选它,兼容性最好
H.265 / HEVC 约 1.5~2x 慢 2~5 倍 专利复杂 体积敏感且终端可控时用
VP9 约 1.3~1.5x 慢 免费 WebM 生态
AV1 约 2x 很慢(新硬件改善) 免费 趋势,但编码成本高
AAC — — 需授权 音频默认
Opus 低码率下优于 AAC — 免费 WebM / WebRTC

转封装 ≠ 转码(这块最省钱的一条经验)

  • 转封装:-c copy,只换盒子不重新编码,秒级完成、零画质损失。
  • 转码:-c:v libx264,解码再编码,慢且必然有损。
  • 判断顺序:先 ffprobe 看源编码 → 与目标容器兼容就直接 -c copy。
1
2
3
4
5
# 转封装:mp4 → mkv,秒级、无损
ffmpeg -i in.mp4 -c copy out.mkv

# 反例:本来只是换容器,却写了重编码,白等十分钟还掉画质
ffmpeg -i in.mp4 -c:v libx264 -crf 23 out.mkv

14.2 像素、色彩与压缩参数

像素格式(pixel format)——决定一帧画面在内存里怎么排。

格式 含义 每像素位宽 典型用途
yuv420p 亮度全采样,色度 2×2 下采样 12 bit 通用分发格式,H.264 硬解底线
yuv422p 色度水平减半 16 bit 采集卡、专业中间格式
yuv444p 色度不降采样 24 bit 抠像、色彩处理、无损
nv12 YUV420 的 UV 交错变体 12 bit 硬件编解码 / GPU 纹理
rgba 四通道 8 位,带 alpha 32 bit Canvas / WebGL、需要透明

为什么用 4:2:0:人眼对亮度敏感、对色度迟钝,扔掉 3/4 的色度信息,体积直接砍一半而肉眼几乎无感。

RGB 与 YUV 的换算(BT.601 全范围,前端最常用)

1
2
3
Y =  0.299R + 0.587G + 0.114B
U = -0.169R - 0.331G + 0.500B + 128
V = 0.500R - 0.419G - 0.081B + 128

BT.709 的系数是 0.2126 / 0.7152 / 0.0722——系数用错,就是「偏色」的第一大原因。

色彩四件套

参数 取值 说明
-color_range tv(16–235)/ pc(0–255) 视频默认 tv,Canvas 出来是 pc,不声明就发灰
-colorspace bt709 / bt601 / bt2020nc SD 用 601,HD 用 709,HDR 用 2020
-color_primaries bt709 / bt2020 色域
-color_trc bt709 / smpte2084(PQ) / arib-std-b67(HLG) 传输函数,HDR 的关键
1
2
3
# 显式声明,避免播放器各自猜
ffmpeg -i in.mp4 -c:v libx264 -pix_fmt yuv420p \
-colorspace bt709 -color_primaries bt709 -color_trc bt709 -color_range tv out.mp4

四个压缩参数

参数 含义 常见值 影响
位深 每通道比特数 8bit / 10bit 10bit 减少色带,HDR 必须
码率 每秒数据量 500k / 2.5M / 8M 画质与体积的主开关
帧率 每秒帧数 24 / 25 / 30 / 60 流畅度,同时抬高码率
GOP 两个 I 帧之间的间隔 30 / 48 / 250 越大越省码率,随机 seek 越慢

体积估算(面试爱考)

1
2
体积(Byte) ≈ (视频码率 + 音频码率) × 时长(s) / 8
目标视频码率 ≈ 目标体积(MB) × 8192 / 时长(s) − 音频码率

例:10 分钟视频压到 100 MB → 100 × 8192 / 600 ≈ 1365k,减掉音频 128k → -b:v 1237k。

I / P / B 帧:I 帧独立可解、P 帧参考前面、B 帧双向参考。B 帧越多压缩越好,但延迟越高——**直播要 -bf 0**。

分辨率 场景 H.264 30fps 推荐码率
640×360 移动端预览 500k ~ 800k
1280×720 通用 1.5M ~ 2.5M
1920×1080 主流程 4M ~ 6M
3840×2160 4K 15M ~ 25M
码控模式 参数写法 特点
CRF / CQP -crf 23 恒定质量、码率浮动,点播首选
ABR -b:v 2M 平均码率,体积可控
CBR -b:v -minrate -maxrate 相等 直播推流
两遍编码 -pass 1 / -pass 2 体积精确,耗时翻倍

14.3 命令结构与参数位置

三个可执行程序

程序 职责 典型用法
ffmpeg 转码 / 处理 ffmpeg -i in.mp4 ...
ffprobe 探测元信息 ffprobe -v error -show_streams in.mp4
ffplay 极简播放器 ffplay in.mp4

通用结构

1
ffmpeg [全局参数] [输入参数] -i 输入 [输出参数] 输出

位置决定语义:-ss / -t 放 -i 前是输入参数(快速定位,从关键帧开始读);放 -i 后是输出参数(精确但慢,要解码到指定时间)。

⚠️ 最常见的坑:把 -c:v、-pix_fmt 写在 -i 之前,会被当成输入参数,结果「参数加了却没生效」。

参数 归类 作用
-i 输入 指定输入文件或 -(stdin)
-y / -n 全局 覆盖 / 不覆盖输出文件
-hide_banner 全局 隐藏版本与编译信息
-loglevel error 全局 只打错误,方便脚本抓报错
-nostdin 全局 后台运行时不抢 stdin
-ss 输入/输出 定位
-t 输入/输出 截取时长
-c:v / -c:a 输出 视频 / 音频编码器,copy 表示不重编码
-b:v / -b:a 输出 码率
-crf 输出 恒定质量,0–51,越小越好
-preset 输出 速度档位 ultrafast→veryslow
-pix_fmt 输出 像素格式
-r / -s 输出 帧率 / 分辨率(-s 等价于 scale)
-vf / -af 输出 视频 / 音频简单滤镜
-filter_complex 输出 多输入多输出滤镜图
-map 输出 选择或重排流
-f 输出 强制容器格式
-movflags +faststart 输出 moov 前置,Web 秒开
-progress pipe:1 输出 输出机器可读进度

ffprobe 探信息

1
2
3
4
5
6
7
# 关键视频参数
ffprobe -v error -select_streams v:0 \
-show_entries stream=codec_name,profile,width,height,r_frame_rate,avg_frame_rate,bit_rate,pix_fmt,nb_frames \
-of json in.mp4

# 时长 / 体积 / 总码率
ffprobe -v error -show_entries format=duration,size,bit_rate -of csv=p=0 in.mp4

Node 里统一封装:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
import { execFile } from 'node:child_process'
import { promisify } from 'node:util'

const run = promisify(execFile)

export interface VideoMeta {
duration: number
width: number
height: number
fps: number
codec: string
bitrate: number
}

export async function probe(file: string): Promise<VideoMeta> {
const { stdout } = await run('ffprobe', [
'-v', 'error',
'-select_streams', 'v:0',
'-show_entries', 'stream=codec_name,width,height,avg_frame_rate,bit_rate:format=duration,bit_rate',
'-of', 'json',
file,
])
const j = JSON.parse(stdout)
const s = j.streams?.[0] ?? {}
const [num, den] = String(s.avg_frame_rate ?? '0/1').split('/').map(Number)
return {
duration: Number(j.format?.duration ?? 0),
width: s.width ?? 0,
height: s.height ?? 0,
fps: den ? num / den : 0,
codec: s.codec_name ?? 'unknown',
bitrate: Number(s.bit_rate ?? j.format?.bit_rate ?? 0),
}
}

注意 -show_entries 只用一处,stream=... 与 format=... 之间用冒号连接;写成两个 -show_entries 会互相覆盖。

进度解析——长任务必须给前端反馈。

1
ffmpeg -nostdin -i in.mp4 -c:v libx264 -crf 23 -progress pipe:1 -nostats out.mp4

输出是 key=value 流:frame=、fps=、out_time_ms=、speed=、progress=continue|end。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import { spawn } from 'node:child_process'

const proc = spawn('ffmpeg', [
'-nostdin', '-i', file, '-c:v', 'libx264', '-crf', '23',
'-progress', 'pipe:1', '-nostats', out,
])

let buf = ''
proc.stdout.on('data', (chunk) => {
buf += chunk.toString()
const lines = buf.split('\n')
buf = lines.pop() ?? ''
for (const line of lines) {
const [k, v] = line.split('=')
// out_time_ms 实际单位是微秒(FFmpeg 历史遗留的命名错误)
if (k === 'out_time_ms') onProgress(Math.min(1, Number(v) / 1e6 / duration))
}
})

14.4 高频操作(可直接抄)

# 场景 关键参数 小节
1 通用转码 -c:v libx264 -crf 23 -pix_fmt yuv420p 下
2 提取 / 剥离音频 -vn / -an 下
3 无损切片 -ss + -t + -c copy 下
4 压到目标体积 -b:v 两遍编码 下
5 抽帧 / 封面 / 雪碧图 -vf fps=、tile 下
6 图片序列转视频 -framerate 下
7 转 GIF palettegen + paletteuse 下
8 多段合并 -f concat 下
9 音视频合流 -map + -shortest 下
10 变速 setpts + atempo 下
11 HLS 切片 -f hls 下
12 硬件加速 h264_nvenc / videotoolbox 下

① 通用转码(兼容性拉满的默认档)

1
2
ffmpeg -i in.mov -c:v libx264 -preset medium -crf 23 -profile:v high -level 4.0 \
-pix_fmt yuv420p -c:a aac -b:a 128k -movflags +faststart out.mp4

-pix_fmt yuv420p 是硬解底线,+faststart 让首帧更快到达(moov 前置)。

② 提取 / 剥离音频

1
2
3
ffmpeg -i in.mp4 -vn -c:a copy out.m4a                  # 原样提取,无损且秒级
ffmpeg -i in.mp4 -vn -c:a libmp3lame -q:a 2 out.mp3 # 转 MP3
ffmpeg -i in.mp4 -an -c:v copy out.mp4 # 只去音频

③ 无损切片

1
ffmpeg -ss 00:01:30 -i in.mp4 -t 30 -c copy out.mp4

坑:copy 只能在关键帧处切,实际起点会前移到最近的 I 帧,时长也可能多几帧。要帧级精确,就重编码,或「先精确定位一小段再 copy」。

1
ffmpeg -i in.mp4 -ss 00:01:30.500 -t 30 -c:v libx264 -crf 20 -c:a aac out.mp4

④ 压到目标体积(两遍编码)

1
2
3
# 第一遍只分析,输出丢弃;Windows 用 NUL,Linux / macOS 用 /dev/null
ffmpeg -y -i in.mp4 -c:v libx264 -b:v 1200k -pass 1 -an -f mp4 /dev/null
ffmpeg -i in.mp4 -c:v libx264 -b:v 1200k -pass 2 -c:a aac -b:a 128k out.mp4

⑤ 抽帧 / 封面 / 雪碧图

1
2
3
4
ffmpeg -i in.mp4 -vf fps=1 frames/%05d.jpg                                # 每秒一帧
ffmpeg -i in.mp4 -vf "select='eq(pict_type,I)'" -fps_mode vfr key/%05d.jpg # 只抽关键帧
ffmpeg -ss 3 -i in.mp4 -frames:v 1 -q:v 2 cover.jpg # 封面
ffmpeg -i in.mp4 -vf "fps=1/10,scale=160:-2,tile=5x4" -frames:v 1 sprite.jpg # 雪碧图

⑥ 图片序列转视频

1
ffmpeg -framerate 24 -i frames/%05d.png -c:v libx264 -pix_fmt yuv420p out.mp4

⑦ 转 GIF(必须走调色板)

1
2
3
ffmpeg -i in.mp4 -vf "fps=12,scale=480:-2:flags=lanczos,palettegen=stats_mode=diff" palette.png
ffmpeg -i in.mp4 -i palette.png -filter_complex \
"[0:v]fps=12,scale=480:-2:flags=lanczos[v];[v][1:v]paletteuse=dither=bayer" out.gif

不生成调色板直接转,颜色会脏成 256 色抖动——这是 GIF 清晰度的决定性一步。

⑧ 多段合并

1
2
printf "file '%s'\n" a.mp4 b.mp4 c.mp4 > list.txt
ffmpeg -f concat -safe 0 -i list.txt -c copy out.mp4

前提:编码、分辨率、帧率、像素格式全一致,否则先统一转码再合并。

⑨ 音视频合流

1
ffmpeg -i video.mp4 -i audio.m4a -c:v copy -c:a aac -shortest out.mp4

-shortest 以短的一路为准;不带它就会在流的末尾留下空画面或空音轨。

⑩ 变速

1
2
ffmpeg -i in.mp4 -filter_complex \
"[0:v]setpts=0.5*PTS[v];[0:a]atempo=2.0[a]" -map "[v]" -map "[a]" out.mp4

音频 atempo 单次只支持 0.5–2.0,超过要串联(4 倍速 = atempo=2.0,atempo=2.0)。

⑪ HLS 切片

1
2
3
ffmpeg -i in.mp4 -c:v libx264 -c:a aac -f hls \
-hls_time 6 -hls_playlist_type vod \
-hls_segment_filename "seg_%03d.ts" index.m3u8

⑫ 编码器的两个特例

1
2
3
4
5
# H.265:必须加 -tag:v hvc1,否则苹果生态不认
ffmpeg -i in.mp4 -c:v libx265 -crf 28 -preset medium -tag:v hvc1 -c:a copy out.mp4

# VP9:-b:v 0 让 CRF 生效
ffmpeg -i in.mp4 -c:v libvpx-vp9 -crf 32 -b:v 0 -row-mt 1 -c:a libopus -b:a 96k out.webm

⑬ 清元数据与硬件加速

1
2
3
4
ffmpeg -i in.mp4 -map_metadata -1 -map_chapters -1 -c copy out.mp4

ffmpeg -hwaccel cuda -i in.mp4 -c:v h264_nvenc -preset p5 -rc vbr -cq 23 -c:a copy out.mp4 # NVIDIA
ffmpeg -i in.mp4 -c:v hevc_videotoolbox -q:v 55 -c:a copy out.mp4 # macOS

-cq / -q:v 是各家的质量档位,与 -crf 不等价,照抄数值会得到不同的画质曲线。

14.5 滤镜系统:线性链与非线性链

两套滤镜入口,先分清再动手:

维度 简单滤镜 -vf / -af 复杂滤镜 -filter_complex
输入数 1 多
输出数 1 多
链内分隔符 逗号 , 逗号 ,
链间分隔符 无(一条链) 分号 ;
典型场景 缩放、裁剪、加字幕、加文字 画中画、多路拼接、混音、多输出

非线性链的语法:[输入标签]滤镜=参数,滤镜=参数[输出标签]

1
2
3
[0:v]scale=1280:-2,format=yuv420p[v0];
[1:v]scale=320:-2[logo];
[v0][logo]overlay=W-w-16:16
  • [0:v] 第 0 个输入的视频流,[0:a] 音频,[0:s] 字幕
  • 每条链 = 输入标签 → 滤镜序列 → 输出标签
  • 没被下游消费的输出标签,由 -map 决定落到哪个输出文件

四条必踩的坑

  1. -vf 与 -filter_complex 同时写,且抢同一条流——会报 Filter ... has an unconnected output。统一用 -filter_complex。
  2. 造了标签却没 -map——输出文件里干脆没有这条流,静默成功。
  3. 表达式里的逗号没转义——被当成滤镜分隔符,报参数错误。写成 \,,即使在双引号内。
  4. scale 的宽高必须偶数(yuv420 要求),用 -2 而不是 -1(-1 可能算出奇数)。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 画中画:右上角小窗,等比缩到主画面 1/3
ffmpeg -i main.mp4 -i pip.mp4 -filter_complex \
"[1:v]scale=iw/3:-2[pip];[0:v][pip]overlay=W-w-16:16" -c:a copy out.mp4

# 横拼两路
ffmpeg -i a.mp4 -i b.mp4 -filter_complex \
"[0:v]scale=640:-2[l];[1:v]scale=640:-2[r];[l][r]hstack=inputs=2" -c:a copy out.mp4

# 音频混音:背景乐压到 0.3,人声保持 1.0
ffmpeg -i bgm.mp3 -i voice.wav -filter_complex \
"[0:a]volume=0.3[b];[1:a]volume=1.0[v];[b][v]amix=inputs=2:duration=longest[a]" \
-map "[a]" out.m4a

# 只在 5~10 秒显示水印
ffmpeg -i in.mp4 -i logo.png -filter_complex \
"[0:v][1:v]overlay=W-w-20:20:enable='between(t,5,10)'" -c:a copy out.mp4

14.6 视觉增强

裁剪 crop:参数顺序是 w:h:x:y。

1
2
3
ffmpeg -i in.mp4 -vf "crop=1280:720:0:0" out.mp4        # 从左上角取 1280x720
ffmpeg -i in.mp4 -vf "crop=in_w:in_h-120:0:0" out.mp4 # 裁掉底部 120px
ffmpeg -i in.mp4 -vf "cropdetect=24:16:0" -f null - # 自动探测黑边,从日志读结果

缩放 scale + 补边 pad

1
2
3
4
5
6
7
8
9
# 等比缩到 1280 宽,高度自适应且保证偶数
ffmpeg -i in.mp4 -vf "scale=1280:-2" out.mp4

# 强制 1280x720 且不变形:先等比缩小再补黑边
ffmpeg -i in.mp4 -vf \
"scale=1280:720:force_original_aspect_ratio=decrease,pad=1280:720:(ow-iw)/2:(oh-ih)/2:color=black" out.mp4

# 只缩不放(大图压小,小图保持原样)
ffmpeg -i in.mp4 -vf "scale=w='min(1920,iw)':h=-2" out.mp4

水印 overlay:位置用表达式,W/h 是主画面尺寸,w/h 是水印尺寸。

1
2
ffmpeg -i in.mp4 -i logo.png -filter_complex \
"[1:v]scale=120:-2[logo];[0:v][logo]overlay=W-w-20:H-h-20" -c:a copy out.mp4
位置 表达式
右下角 W-w-20:H-h-20
居中 (W-w)/2:(H-h)/2
跟随时间 x='if(lt(t,5),20,W-w-20)':y=20

走马灯(滚动文字)——用 drawtext 的 x 表达式做位移,比 overlay 更轻。

1
2
3
ffmpeg -i in.mp4 -vf \
"drawtext=text='内部资料 禁止外传':fontsize=28:fontcolor=white@0.7:x=w-mod(t*200\,w+800):y=h-56" \
-c:a copy out.mp4

要点:t*200 是滚动速度(像素/秒),800 是文字宽度的近似值(超出画面宽度才能滚出视野外);mod() 让位移循环,从右侧画外进入。中文字体要指定 fontfile,Windows 上写 fontfile='C\:/Windows/Fonts/msyh.ttc'——盘符后的冒号必须转义。

打码:局部模糊或纯色遮挡

1
2
3
4
5
6
# 把区域裁出来模糊,再盖回原位置
ffmpeg -i in.mp4 -filter_complex \
"[0:v]crop=200:80:100:60,boxblur=10:1[b];[0:v][b]overlay=100:60" -c:a copy out.mp4

# 纯色遮挡
ffmpeg -i in.mp4 -vf "drawbox=x=100:y=60:w=200:h=80:color=black@0.8:t=fill" out.mp4

字幕:软挂与硬压

1
2
3
4
5
6
# 硬压 srt,顺便指定字体样式
ffmpeg -i in.mp4 -vf \
"subtitles=sub.srt:force_style='FontName=Microsoft YaHei,FontSize=20,PrimaryColour=&H00FFFFFF'" out.mp4

# ass 定位更自由(需要 libass)
ffmpeg -i in.mp4 -vf "ass=sub.ass" out.mp4

坑:subtitles 依赖编译时带 libass,很多精简版 FFmpeg 没有;Windows 路径要写成 C\:/x/sub.srt。

旋转与镜像

1
2
3
ffmpeg -i in.mp4 -vf "transpose=1" out.mp4   # 顺时针 90°
ffmpeg -i in.mp4 -vf "hflip" out.mp4 # 水平镜像
ffmpeg -i in.mp4 -vf "vflip" out.mp4 # 垂直翻转

手机拍摄的旋转信息存在容器元数据里,转码后可能「自动转正」或「反而歪掉」——统一用 -vf transpose 显式处理,别依赖元数据。

14.7 色彩空间:Canvas 帧 → 编码器

背景:Canvas 只给你 RGBA(sRGB,pc range),而视频编码器吃 YUV420P(tv range)。中间有三种对接路线。

方案 怎么拿帧 谁负责转 YUV 适用场景
MediaRecorder + Canvas canvas.captureStream() 浏览器内部 纯录制,无需精修
WebCodecs VideoFrame → VideoEncoder 指定 format: 'I420' 高性能、需要逐帧控制
ffmpeg.wasm / 原生 FFmpeg getImageData() → RGBA 字节 FFmpeg 或自己写 需要滤镜、封装、兼容老浏览器

方案 A:交给 FFmpeg 转(最省事)

1
2
3
# 从 stdin 读 RGBA 原始帧,FFmpeg 自己转 yuv420p
ffmpeg -f rawvideo -pix_fmt rgba -s 1280x720 -r 30 -i - \
-c:v libx264 -pix_fmt yuv420p -crf 20 out.mp4

方案 B:自己算 RGBA → YUV420P(BT.601 全范围,与 14.2 的公式一致)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
const clamp = (v: number) => (v < 0 ? 0 : v > 255 ? 255 : v | 0)

/** RGBA(Uint8ClampedArray) → yuv420p 紧凑布局:Y 平面 + U 平面 + V 平面 */
export function rgbaToYuv420p(rgba: Uint8ClampedArray, w: number, h: number): Uint8Array {
const ySize = w * h
const uvW = w >> 1
const uvH = h >> 1
const out = new Uint8Array(ySize + uvW * uvH * 2)
const uOff = ySize
const vOff = ySize + uvW * uvH

// 亮度:逐像素
for (let j = 0; j < h; j++) {
for (let i = 0; i < w; i++) {
const p = (j * w + i) * 4
const r = rgba[p], g = rgba[p + 1], b = rgba[p + 2]
out[j * w + i] = clamp(0.299 * r + 0.587 * g + 0.114 * b)
}
}

// 色度:2x2 下采样,先把四像素 RGB 平均再换算,避免边缘串色
for (let j = 0; j < uvH; j++) {
for (let i = 0; i < uvW; i++) {
let r = 0, g = 0, b = 0
for (const [dx, dy] of [[0, 0], [1, 0], [0, 1], [1, 1]]) {
const p = ((j * 2 + dy) * w + (i * 2 + dx)) * 4
r += rgba[p]; g += rgba[p + 1]; b += rgba[p + 2]
}
r /= 4; g /= 4; b /= 4
out[uOff + j * uvW + i] = clamp(-0.169 * r - 0.331 * g + 0.5 * b + 128)
out[vOff + j * uvW + i] = clamp(0.5 * r - 0.419 * g - 0.081 * b + 128)
}
}
return out
}

把帧写进编码器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import { spawn } from 'node:child_process'

export function createEncoder(out: string, w: number, h: number, fps = 30) {
const ff = spawn('ffmpeg', [
'-f', 'rawvideo', '-pix_fmt', 'yuv420p', '-s', `${w}x${h}`, '-r', String(fps), '-i', '-',
'-c:v', 'libx264', '-preset', 'veryfast', '-crf', '20',
'-pix_fmt', 'yuv420p', '-colorspace', 'bt709', '-color_range', 'tv',
out,
])
return {
write: (plane: Uint8Array) => ff.stdin.write(plane),
end: () =>
new Promise<void>((resolve) => {
ff.on('close', () => resolve())
ff.stdin.end()
}),
}
}

背压要点:ff.stdin.write() 返回 false 时说明管道满了,必须等 drain 再写下一帧,否则内存会被帧数据堆爆。

偏色的三个根因

现象 根因 修法
整体发灰、黑色不黑 range 不一致(把 pc 当 tv 解码) 声明 -color_range,或用 scale=in_range=full:out_range=tv
肤色偏绿 / 偏紫 矩阵用错(把 601 当 709 解码) 统一 -colorspace bt709,或 scale=in_color_matrix=bt709:out_color_matrix=bt709
大面积色带、渐变断裂 8bit + 高压缩 + 无抖动 降低 CRF、用 10bit 中间格式、加 dither

一句话:Canvas 出来是「pc range + sRGB」,H.264 分发一般是「tv range + BT.709」,两头必须显式对齐,靠播放器猜一定偏色。

14.8 前端与 AI 场景落地

浏览器能力对照

能力 API 能做什么 限制
录制 MediaRecorder 摄像头 / 屏幕 / Canvas → WebM 码率控制粗,格式受限
逐帧编解码 WebCodecs VideoEncoder / VideoDecoder Chrome 94+,Safari 覆盖不全
播放 MSE + hls.js 拉 HLS / DASH 低延迟需 LL-HLS
转码 ffmpeg.wasm 浏览器内跑 FFmpeg 慢、吃内存,需要 COOP/COEP 响应头
采集 getUserMedia / getDisplayMedia 摄像头 / 屏幕 需权限,移动端限制多

四类真实场景

  1. 上传前压缩:弱网下先在本地降码率(WebCodecs 或 ffmpeg.wasm),服务端再统一转标准档,减少带宽也减少排队。
  2. AI 视频理解:抽帧 → 多模态模型。不要按固定 fps 猛抽,先做场景切换检测再抽,帧数能降一个量级。
  3. AI 视频生产的后处理:模型返回的分片 → concat 拼接 → 统一转码 → 生成封面与字幕。
  4. 录屏 / 会议回放:MediaRecorder 出 WebM → 服务端转 HLS 切片 → CDN 分发。

给多模态模型抽帧的两条命令

1
2
3
4
5
# 每 2 秒一帧,缩到 512 宽(控制 token 成本)
ffmpeg -i in.mp4 -vf "fps=1/2,scale=512:-2" -q:v 3 frames/%04d.jpg

# 按场景变化抽帧,去除大量重复画面
ffmpeg -i in.mp4 -vf "select='gt(scene,0.4)',scale=512:-2" -fps_mode vfr frames/%04d.jpg

14.9 踩坑与经验

  1. 参数位置错 → 静默失效:输出参数写在 -i 之前会被当成输入参数,命令照样成功,结果完全不对。
  2. copy 切片起点不准:只能在关键帧切,起点会前移;要精确就重编码。
  3. 压完反而更大:源已是高压缩低码率,再压只会更差;或根本是 -b:v 设得比源码率还高。
  4. 奇数分辨率报错:yuv420p 要求偶数,用 scale=1280:-2,必要时补 pad=ceil(iw/2)*2:ceil(ih/2)*2。
  5. Web 上拖进度条很久才出画:缺 -movflags +faststart,moov 在文件末尾。
  6. Windows 下滤镜报参数错:路径冒号写 C\:/,表达式逗号写 \,。
  7. 批量任务不要拼 shell 字符串:用 execFile('ffmpeg', [...]) 传数组,避免空格与注入。
  8. 并发要限流:x264 默认吃满所有核,N 个并发必须 -threads 或队列串行,否则整机卡死。
  9. 失败了先看 stderr 末尾:-loglevel error 只留关键报错,比翻几百行 banner 快得多。
  10. 转码是 IO + CPU 双高:容器里要限 CPU、给足临时盘、设超时,避免僵尸任务堆积。

一句话总结:换不换容器看 -c copy,画质好坏看 -crf 与 -pix_fmt,复杂效果看 -filter_complex,偏色看 color_range 与 colorspace。


十五、附录

15.1 学习资源索引

平台与产品

模型与部署

协同与编辑器

数字孪生与三维

工程化

LangChain 生态

音视频与 FFmpeg

15.2 本机案例路径索引

主题 路径
AI 引擎全栈 E:/practice/demo/1.ai-engine
服务端 AI 编排 E:/practice/demo/1.ai-engine/apps/server
Prompt / 结构化输出 E:/practice/demo/1.ai-engine/1.prompt.js、E:/practice/demo/1.ai-engine/9.structure.js
TS / Zod 示例 E:/practice/demo/1.ai-engine/10.typescript.ts、E:/practice/demo/1.ai-engine/11.zod.ts
多模态 Agent E:/practice/demo/1.ai-engine/12.agent-image.ts
服务型工作流引擎 E:/practice/demo/1.ai-engine/13.flow-engine.ts
监控 SDK 单体 E:/practice/demo/案例/ai-monitor
监控 monorepo 全栈 E:/practice/demo/案例/ai-monitor-ful
监控 AI 分析服务 E:/practice/demo/案例/ai-monitor-ful/packages/ai
监控 + AI 巡检 E:/practice/demo/案例/ai-inspect
编辑器三路线 E:/practice/demo/案例/simple-editor/{contenteditable,execCommand,selection}.html

十六、面试题库

用法:先看题干自测,能说出「骨架」再看要点。每题后附 → §x.x 指向正文的详细展开。
题目按 初中级 → 中高级 → 专业级 → 专家级 递增排列,共 48 题。

16.1 初中级(16 题)

Q1|说说你对生成式 AI 应用引擎的整体理解和业务流程

  • 本质:把 LLM、Agent、插件、工作流、触发器、知识库、记忆整合成一个平台。
  • 六大模块:插件化抽象复用逻辑 → 工作流自动化编排 → 触发器驱动 → 知识库检索 → 记忆维持上下文 → 输入输出闭环。
  • 业务流程:用户输入 → 引擎编排 → 模型 / 知识库 / 插件协同 → 流式输出。
  • 三种前端集成方式:iframe、API、Agent 商城式发布。
    → §3.4、§2.2

Q2|是否有过自动化、批处理或生成式 AI 相关业务?说说对流程引擎的理解和整体方案

  • 自动化 / 批处理核心:重复性任务、抽象层次高,把期望的任务列成步骤逐步执行。
  • 生成式 AI 的区别:用户控制整个流程,AI 去具体实现(搜索 → 提关键字 → 清洗 → 给模型分析 → RAG 优化 → 循环 → 判断)。
  • 流程引擎三要素:流程建模(编辑器)、任务调度(异步 / 依赖 / 变量上下文)、插件化集成外部系统。
  • 实现分型:内存型(前端全量执行)、服务端型(OA 审批、低代码、大数据平台)、生成式 AI 引擎(调模型、参数召回、上下文缓存、向量库操作)。
    → §6.1、§6.6

Q3|开发一个类似飞书文档的知识库,文档编辑如何设计?重点说原理与技术实现

  • 核心清单:基础编辑、文本格式化、多媒体插入、undo/redo、跨浏览器兼容、协同、AI 赋能。
  • 三条技术路线:contenteditable 裸做 → execCommand(过时)→ Selection + Range + Compiler(推荐)。
  • Compiler 解决的核心问题:反复点击导致标签无限嵌套,需要判断已有修饰并做「加强 / 还原」。
  • 数据层:Markdown 路线性能好约束强;JSONContent 路线更灵活,自定义节点方便(TipTap custom node)。
  • 通用协议:Schema / DSL 承载物料体系(BlockSuite)。
  • 个性化:/ 命令、@ 提及、协同光标、力导向图谱、命令栈 undo/redo。
    → §7.2、§7.3

Q4|了解过服务端渲染吗?为什么当下 AI 辅助编程首选服务端渲染方案?

  • 先讲演进:EJS/JSP → SPA → SSR + SPA 结合。
  • 再讲 AI 特殊性:追求短平快(全栈一体)、隐私与安全(token 不能落前端,否则可被任意调用)、动态与个性化。
  • 三点优势:体验(首屏)、减轻客户端压力、降低维护成本。
  • 补充类比项目:Coze、Dify 这类平台,以及 v0、bolt 这类生成式产品。
    → §8.1、§8.2、§8.3

Q5|简单描述协同文档编辑器的方案和核心实现

  • 分层:编辑器内核(TipTap / ProseMirror)+ 协同算法(CRDT / OT)+ 具体实现(Yjs / Automerge)+ 传输(WS / WebRTC)+ 服务层(Node / NestJS / Redis / Kafka)+ 存储(PostgreSQL + pgvector)。
  • 关键判断:CRDT 分布式友好,OT 依赖集中式;Yjs 是当前首选。
  • 实现五步:建 Y.Doc → 绑定编辑器 → 实时通信 → 光标同步(Awareness)→ 后端接入。
  • 依赖清单要能报出来:@tiptap/extension-collaboration 是绑定层。
    → §7.4、§7.5

Q6|有没有做过 AI 相关业务?说说 AI 大模型应用开发的核心方向和重要技术点

  • 三个方向:AI 原生应用、AI 赋能已有业务、AI 应用开发平台。
  • 四大技术:LLM(概率预测、涌现、上下文依赖;基础模型 vs 微调模型)、Prompt 工程(角色 / 思维链 / 结构化输出 / 指令数据分离)、RAG(索引 + 查询两阶段)、Agent(ReAct + 工具 + 过程可视化 + 交互干预)。
  • 选型三关注:上下文窗口、成本(token 计费)、响应速度。
  • 前端两个黄金点:流式渲染、引用溯源。
    → §3.2、§2.3、§2.4、§4.1、§4.2

Q7|做过前端监控?性能与异常监控指标是怎么算的?

  • 性能:PLT、FP/FCP、FMP、LCP、TTI、CLS(≤0.1 良好)、INP。
  • 异常:JS 运行时、Promise unhandled rejection、资源加载、接口请求、React/Vue 框架异常。
  • 行为:PV、UV、点击/操作、停留时间;新老用户用 Cookie 标记。
  • 上报:fetch/XHR(CORS 解决跨域)、图片打点、sendBeacon。
  • 工程化指标:构建时间、缓存利用率。
    → §9.1、§9.2

Q8|前端 AI 这块做过什么?了解过私有化 AI 平台部署和应用吗?

  • 回答框架:技术广度 + 工程化能力(私有化部署)+ 业务思考。
  • 硬前置:CPU ≥ 2 核、内存 ≥ 4G,装 Docker。
  • 两条路:Coze Studio(Docker Compose 拉源码部署 + 配豆包 API Key/Endpoint);Ollama + Dify(本地模型 + 向量库)。
  • 关键坑:容器里的模型 URL 不能写 localhost,要用局域网 IP。
  • 收尾升华:从「平台构建者视角」讲清人设、插件、知识库、工作流如何协作。
    → §3.5

Q9|对 LangChain.js 这类框架有了解吗?用它搭过 Agent 吗?怎么看它降低门槛?

  • 先答「不用框架的七个坑」:模型适配、tool calling、ReAct 循环、输出形态、MCP 远程工具、提示词优化(compact + skills)、生态。
  • 框架的价值:把这七件事封装成标准抽象。
  • 小 Demo 技术栈:TS + Node(脚本 → 服务化)+ Ollama + LangChain.js。
  • 方法论:问题分析 → 方案设计(MVP,抓主要矛盾)。
    → §5.1

Q10|你 TS 掌握得怎么样?TS 与 Zod 为什么在 Agent 开发中应用广泛?前端往 Agent 能有哪些沉淀?

  • TS:编译时静态检查,约束框架契约与协议数据结构。
  • Zod:运行时校验,做入参标准、输出结构化、参数提取 schema、工具入参防护。
  • TS 重点:基础类型/别名/接口、联合与交叉(面向协议编程)、类型守卫(类型收敛)、工具类型(Omit/Pick/Partial)、泛型与类型体操。
  • 前端三点沉淀:TS AI SDK 工程化、Node/Nest/Nuxt 服务化、Prisma + PostgreSQL 持久化。
    → §13

Q11|有没有参与过工作流编辑器开发?简述工作流类型、技术选型与实现细节

  • 三种类型:线性流、DAG(AI 最常用,严禁环路)、状态机流。
  • 选型:SVG(React-Flow/X6,首选)vs Canvas(LogicFlow/LiteGraph,超大规模)vs 纯 DOM(上手快但连线难写)。
  • 四个细节:数据协议(兜底/降级/拓展/升级)、引擎实现三选一、节点边物料体系(插件化/微内核)、协同 + 执行(建图、遍历、异步、日志、错误收集)。
  • 面试建议:以 React-Flow / AntV X6 切入,强调可定制插件系统。
    → §6.2、§6.5

Q12|了解过什么服务端框架?最快实现 AI 全栈 POC,技术栈怎么选?

  • 先分清 POC 与 MVP:POC 验证可行性、低成本试错、用于演示立项;MVP 在 POC 上补登录/页面/异常处理/打包 Docker,能交付测试。
  • 前端:HTML/CSS(Tailwind)/TS + Zod/React/Next.js。
  • AI:LangChain.js / LangGraph.js / DeepAgent.js。
  • 数据:PostgreSQL + Prisma。
  • 部署:Docker,脱离平台绑定。
  • 四层架构图:前端交互层 → AI 核心能力层 → 数据持久化层 → 部署环境层。
    → §5.6、§12

Q13|了解 monorepo 架构?为什么大厂和开源项目都青睐这种架构?

  • 定义 + 四特点:单一仓库、多项目共存、统一依赖、原子化提交。
  • 解决四痛点:复用、依赖管理、跨项目原子性、规范分散。
  • 对比 Polyrepo:改库要发 npm 包,调试链路长。
  • 例子:Google、Vue 3、React、字节/美团/阿里的中台。
    → §10.1、§10.2

Q14|基于 Node.js + TypeScript 以及 monorepo 的架构设计思路

  • 先讲必备知识点:monorepo 组织、规范(eslint/stylelint/cspell/commitlint)、构建(vite/esbuild/webpack)、测试(jest/vitest/playwright)。
  • 再讲优势四条(对应四个痛点)。
  • 搭建三步:定 pnpm-workspace.yaml → 分子包(apps / packages)→ 配 tsc 编译与 dev 启动脚本。
  • 强调「里层包共享外层包依赖」可省依赖声明。
    → §10.6、§10.5

Q15|对 AI 智能体的理解:Coze 类工作流智能体、Manus 通用智能体、垂类智能体的区别

  • 本质公式:Agent = LLM + Planning + Memory + Tool (+ MCP/Skills)。
  • Coze 类:DAG 确定性编排,人定规则 AI 填充,可控无风险。
  • Manus 类:LLM Planning 主导,人定目标 AI 定规则,路径不确定。
  • 垂类:特定 Schema/场景优化,领域知识 + 专用工具 + 场景交互。
  • 选型决策树:流程是否固定 → 是否需强可控 → 是否跨多场景。
    → §4.2、§4.4

Q16|尝试过 Vibe Coding 吗?了解哪些模型和工具?怎么解决 AI 生成代码混乱?

  • 一句话答案:上下文清晰控制策略。
  • 两个抓手:开发手册(含 eslint/prettier 约束)+ 清晰规划(方案、步骤、风险、测试用例、反思)。
  • SOP:Plan → Coding → Lint → 开发隔离(新特性、设计文档、实施文档分开)。
  • 工具:Claude + Codex。
    → §12.1

16.2 中高级(16 题)

Q17|对智能体与生成式 AI 应用引擎业务的理解,以及具体落地实现

  • 答题结构必须是:业务流程 → 核心架构 → 核心实现方案。
  • 核心模块五项:插件、工作流、触发器、知识库、记忆 + 输入输出。
  • 落地重难点五项:编排编辑器、节点执行沙箱、日志系统、错误处理、服务化。
  • 学习捷径:Coze 生态更健全(功能与插件),Dify 模型选择更多。
    → §3.4、§3.4 重难点

Q18|有低代码 / AI 应用引擎经验,说说流程引擎编辑器和执行的具体实现

  • 编辑器定义:图形化界面 + 可视化操作(拖拽、配节点)+ 产出工作流蓝图;选型 React:xyflow / x6,Vue:vue-flow。
  • 执行器定义:按蓝图实际运行,负责节点执行(含异步节点)、异步正确性与回调、流程监控与反馈。
  • 内存型实现三步:约定协议(节点+边)→ 编辑器编排 → 执行器按序执行(链表串联上下文)。
  • 三项生产级增强:异步日志系统、全局上下文变量池、四级错误处理(全局捕获 / 节点级 / 通知 / 恢复重试)。
    → §6.5、§6.7

Q19|很多工具类产品都有协同编辑,说说协同编辑器的核心架构与方案

  • 总纲:协同前置,协议先行。
  • 盘点产品:富文本、可视化图表、白板、视频剪辑、AI 应用引擎、多维表格。
  • 传输协议:WS、Socket.IO。
  • 数据分两类:交互式(头像/光标,业务无关)、核心业务数据。
  • 冲突方案:CRDT(面向状态 / 面向操作)与 OT。
  • Yjs 代码要能讲:Y.Doc + WebsocketProvider + yText 的删增同步;后端 setupWSConnection。
  • 落地五步:协议统一 → 存 Yjs Doc → 增量同步 → 传输选型 → 双通道协同。
    → §7.4、§7.5

Q20|详细说说 SSR、SSG 以及前后端同构,有没有了解过 Next / Nuxt,简述原理

  • 三者概念 + 特性对比(首屏、SEO、内容变动频率)。
  • Next 请求五步:请求 → 服务端渲染(getServerSideProps)→ 返回 HTML → React 水合 → 前端渲染接管。
  • App Router:约定式路由(文件夹 + page.tsx)、Server Component 优先、Hook 只能在 "use client" 组件里用。
  • 动态路由 [id] + useParams / useSearchParams。
  • API:app/api/route.ts 按 HTTP 方法导出具名函数。
    → §8.2、§8.4

Q21|协同业务很多,文档、代码、数字孪生低代码编辑器的协同如何架构并落地?

  • 统一公式:视图层 + 数据模型(Yjs)+ 绑定层 + 通信层。
  • 文档:TipTap + Yjs + y-websocket。
  • 代码:CodeMirror + Yjs + y-codemirror.next + y-websocket。
  • 数字孪生:Vue3 + WASM + VanillaJS;核心是结构化数据(组件树、场景图、节点属性)。
  • 数字孪生四重难点:坐标变换、吸附算法性能、状态双向同步、内存与渲染性能。
  • 设计模式:观察者、策略、工厂。
  • 算法:智能吸附 + 网格吸附。
    → §7.6

Q22|AI 大模型应用开发的完整流程?如果要架构设计一个 AI 应用,你的思路?

  • 四步:本地模型部署(Ollama + Qwen3)→ LangChain 三件套 → Node 脚本化(Prompt / RAG / Agent)→ 服务化。
  • 架构图四层:用户端 → BFF/API → AI 编排层 → 模型服务 + 数据访问层。
  • 数据层选型:PGVector / Milvus。
  • 强调「脚本先跑通,再服务化」的开发节奏。
    → §5.6

Q23|设计过大型实时数据流系统?详细说明监控平台的方案设计与落地

  • 开场只讲核心方案概览(一句话覆盖全链路)。
  • 五段:端侧采集 → 接入缓冲(Nginx → NestJS → Kafka)→ 流式计算(Flink/Spark)→ ClickHouse → 可视化与预警。
  • 上报分级:fetch 批量(HTTP/2 多路复用)、sendBeacon(页面关闭不丢)、WebSocket(低延迟双向)。
  • Monorepo 拆分:apps/demo、packages/metrics(tsup 打包)、packages/ai,用 workspace:* 引用。
  • Kafka:按热度拆 Topic、按 session_id Hash 分区保时序。
  • ClickHouse:MergeTree、按月分区、LowCardinality、Map 扩展字段、TTL;禁止单条插入,5000 条或 5 秒批量。
    → §9.3、§9.4

Q24|基于 TypeScript 落地 AI 大模型应用开发的最佳实践与核心重难点

  • 四件套:TS + LangChain.js + Ollama 私有化 + pgvector。
  • 依赖要说准:langchain、@langchain/community、@langchain/core、@langchain/ollama、pg。
  • 三类踩坑:ESM("type": "module" + nodenext)、@types/node 不生效(配 types: ["node"])、MemoryVectorStore 迁到 @langchain/classic。
  • 结论:TS 生态已足够承载 AI 应用,前端可直接全栈。
    → §5.6、§13.3

Q25|聊聊 LangChain 标准化模型接口对避免供应商锁定的价值,以及 LangChain 与 LangGraph 如何选型、如何做可解耦可演进的 Agent 分层架构

  • 标准化:BaseLLM / ChatModel 抹平协议、参数、返回结构差异;换模型只换实例化,不动业务代码;支持多供应商混合调用。
  • 选型:线性轻量 → LangChain;非线性、多角色、状态持久化 → LangGraph。
  • 分层四层:接口层 → 原子能力层(Zod 校验)→ 编排层 → 业务层,依赖倒置。
  • 补充沙箱两层:微前端沙箱(legacy/proxy/snapshot)解决样式与 JS 隔离;系统级沙箱解决环境隔离。
    → §5.2、§5.3、§5.4、§6.10

Q26|基于 TypeScript 搭建 AI Agents 基础框架(参考 LangGraph 核心能力),说核心设计与关键代码

  • 先定能力边界:文生文/图/视频、图生图/视频、文生 PPT、文生 UI。
  • 模型选型要能报出国内外对照。
  • 智能体类型三分 + 是否私有化(Ollama、Whisper)。
  • 框架核心:状态(State)+ 节点(Node)+ 边(Edge),Zod 做入参与输出结构化。
  • 生态事实:主流框架都同时提供 Python 与 TS 版本。
    → §2.5、§4.4、§13

Q27|怎么实现通用工作流编辑器与工作流执行引擎?说说内存型与服务型的顶层设计

  • 对比四维度:执行环境、状态存储、适用场景、核心挑战。
  • 内存型:事件驱动,加载整图进内存,递归/循环消费任务队列;关键在快照同步与轻量化。
  • 服务型:任务队列 + 状态机持久化(类 Temporal/Camunda);三步走——任务解耦(MQ)、Worker 消费、状态脱水与复活(挂起时序列化上下文入库,触发后 Hydrate)。
  • 必须处理分布式事务与超时重试。
    → §6.6

Q28|基于 Next.js、Docker、Prisma、LangChain.js 快速实现 AI Agents 应用基础架构

  • 三条主线:基础交互层架构、前后端联调打通、容器化。
  • 命令链:pnpm create next-app@latest → 装 langchain/prisma/dotenv → npx prisma init → 配 docker.compose.yml → prisma generate。
  • Docker 安装注意:--accept-license、--installation-dir、--wsl-default-data-root,默认安装需重启。
  • 收尾:.env 配置、建表、起服务。
    → §8.4、§5.6

Q29|设计一个 AI 前端驱动的全栈应用,pnpm monorepo 的架构细节

  • 结构:apps/web + apps/server + packages/{configs, ai-engine, utils, types, shared}。
  • 子包被引用四前提:入口文件、导出模块、入口导出方法、package.json 的 module 指向入口。
  • 引用写法:"@monorepo-project/configs": "workspace:*"。
  • 每个子包都要打包(tsup)。
  • 收益:前后端共享数据契约,改完立刻生效。
    → §10.5、§10.6

Q30|主导公司 AI 应用赋能部分产品的全栈开发,说详细结构与核心流程拆解

  • 先盘点可被 AI 协助的模块:CRM 数据分析、开发提效(自动审查)、Code Review 自动化、BI 报表(ChatDB + RAG)、后台管理与客服助手。
  • 五条设计原则:业务目标对齐、最小化侵入、可观测性、迭代式演进、模型无关性与数据隐私。
  • 宏观架构:前端 → BFF/API → AI 核心编排(LangChain.js)→ 数据访问(PG + pgvector)→ 模型服务(Ollama)。
  • 流程四阶段:业务定义与场景选择 → 技术选型与 POC → 智能体编排 → 服务化接入。
  • 交互两种:blocking / streaming。
    → §3.2、§5.6

Q31|用类似 Claude 的工具,如何实现一个系统级 AI 智能体?基于 LangChain + Commander 说思路

  • 前置:ReAct 闭环(Thought → Action → Observation → 循环)+ 工具调用机制。
  • 工具三要素:Name、Description(决策依据)、Args Schema。
  • 技术栈五件:Commander.js(CLI)、Node.js(运行时)、NestJS(服务层)、Next.js(可视化)、LangChain.js(编排)。
  • 分层架构五层:前端交互层 → 服务编排层(API + WS)→ Agent 核心层(Agent / Memory / Tool Registry)→ 工具执行层(FS / 系统命令 / 代码执行 / 三方 API)→ 存储层(SQL + 向量库)。
    → §4.2、§4.3、§5.4

Q32|基于 Vibe Coding 完成亿级协同表格全栈开发,怎么搞定性能瓶颈与代码质量?

  • 三层约束:全局约束 → .clauderules → .plan。
  • .plan 用 STAR-L 法则(需求、方案、步骤、性能瓶颈、优化细节)+ 顶层数据协议抽象。
  • 按特性拆:渲染引擎(千万行流畅)、公式引擎、WebWorker 多线程、协同(Yjs/OT + 协同服务 + 传输协议)、界面(登录 + 渲染)。
  • SOP 六步 + MCP 配套(deepwiki 查资料、context7 查上下文、playwright 集成测试、zcf 管模型与 MCP)。
    → §12.2、§12.3

16.3 专业级(13 题)

Q33|开发一个类似 Coze 的企业内部 AI 开发平台,整体架构设计与核心点

  • 核心点五项:LLM 接入、流程引擎编辑器(@xyflow/react)、工作流节点抽象、执行沙箱(Python)、业务侧服务端。
  • 技术架构五条:模型接入(DeepSeek)、模型配置(复杂表单 react-hook-form)、上下文维持(PostgreSQL 向量)、流程编排(xyflow)、双端沙箱(前端 JS 低代码 + 服务端)。
  • 一句话主线:编辑器 + 协议 + 执行器 + 沙箱 + 服务化。
    → §6.5、§6.7、§6.8

Q34|要构建一个完整的生成式 AI 应用引擎,平台生态体系如何实现?

  • 六大模块 + 六类节点 + 执行流程 + 三项优化(缓存、错误处理、并发执行)。
  • 节点清单要完整:开始 / 模型 / 插件 / 业务逻辑 / 子工作流 / 结束。
  • 执行流程:输入接收 → 节点顺序执行 → 数据传递 → 结束节点返回。
  • 优化三条:高频插件加缓存、节点级错误兜底、可并行节点并发执行。
    → §3.4、§6.3

Q35|从零到一将已有产品 AI 智能化,详细说明架构与实践流程

  • 先做场景盘点:AI 应用引擎、文档 AI 助手、表格助手、低代码托管、智能客服、销售运营链、AIGC 产品。
  • 六步开发流程:梳理业务关键节点 → 匹配模型 → 智能体/复合智能体搭建 → 技术实现(LangChain / LlamaIndex 或类扣子平台)→ 能力服务化 → 能力接入。
  • 智能体编排两条路:低代码编排式 / 代码式(LangChain、LlamaIndex)。
  • 交互方式:blocking / streaming。
    → §3.2、§5.6

Q36|作为前端 Leader,从零到一设计服务端渲染体系,并完成老 SPA 重构,详述设计与实践

  • 四要素:路由系统、SSR/SSG 选择、数据获取与传递、客户端水合;配 React hydrate / renderToString。
  • 技术要点:Vite + React + Express + renderToString + hydrate。
  • 重构路径五步:路由收敛 → 数据预取层上移 → 样式提取 → 状态序列化注入 → 灰度切流。
  • 加分:能说出自研框架(类 Next)的目录与职责。
    → §8.5

Q37|作为前端 Leader,设计类 Dify AI 应用引擎平台的完整闭环;公司 AI 项目从立项到落地你参与了多少?

  • 用「立项阶段 + 研发落地阶段」双段式,每段分业务产出与技术产出。
  • 业务产出用数字说话:审查时间 45 min → 15 min、满意度 95%、V2 Roadmap。
  • 技术产出要具体:文档-视图-控制器分层、虚拟滚动、文本坐标体系做像素级高亮、流式解析与错误恢复。
  • 沉淀:react-ai-stream-parser 组件库 + 《前端 AI 应用开发规范》。
    → §16.6 案例 A(完整模板)

Q38|中大厂的前端 AI 化:基于 LangChain.js 与 Qwen-VL 的多模态根因分析引擎如何实现?

  • 链路:监控数据 + 录屏/截图(rrweb)→ 多模态模型(qwen3-vl:2b)→ 根因定位 → 定位到代码 → 自动修复提 PR。
  • 关键设计:把团队开发规范与流程投喂给模型;历史故障做 RAG;多模态输入按「文本 + 图像 + 视频」三类设计。
  • 本地调试闭环:Ollama 起模型,先跑通再上服务。
    → §9.6

Q39|如果让你负责 Coze 开发,说架构思路、微服务架构、关键业务流程与插件生态

  • 起点:coze-studio 是「单体作坊」(Docker Compose 打包),面向企业/公有云必须转「工业化生产线」(云原生 + 微服务)。
  • 理念:一个中心,四大体系(编排执行引擎;应用构建、插件生态、多租户数据、可观测运维)。
  • 六个微服务:API 网关、用户租户中心、Bot 配置中心、插件市场、数据与向量服务、AI 编排执行引擎(gRPC 内部通信)。
  • 两大重难点:前端 DAG 编排(状态管理、序列化、实时调试);后端流式执行引擎(拓扑排序、异步非阻塞、流式处理、安全沙箱)。
    → §6.8、§6.9

Q40|基于 openclaw 的分层架构理念,实现含 Agent Loop(工具调用 + 流式输出)的最小可运行骨架

  • 五层表要能背:集成层(Ollama + 流式协议)、知识层(内存 + 文本拆分,预留 PG)、工具层(d3-dsv + Zod)、Agent 编排层(Agent Loop)、UI 层(Express SSE)。
  • 三条核心逻辑:SSE 流式对接模型 stream、AgentExecutor 闭环、最小依赖可运行。
  • 强调「预留接口但不实现」的克制,这是 POC 的正确形态。
    → §5.5

Q41|实现一个对标 LangGraph 的 TypeScript AI Agents 框架,说架构、模块划分与源码级难点

  • 前置:图论基础(节点、边、有向图)。
  • 六要素:状态机驱动、图执行引擎、异步安全与竞态避免、状态持久化与 Checkpoint、子图嵌套、执行监控与调试。
  • 难点按序展开:拓扑排序与并发调度、状态快照与恢复、断点续跑的幂等性、错误重规划。
    → §5.5

Q42|如果你是 n8n / Dify / 扣子平台的作者,说工程化架构与编辑器执行器落地的完整链路

  • 五步:定义 DSL → 编辑层(状态管理 + 插件化)→ 执行器(拓扑排序、动态调度、沙箱隔离)→ AI 特化(变量提取、上下文流转、流式输出)→ 工程化闭环(测试)。
  • 每步都要能补一句「为什么这一步不能省」。
    → §6.4、§6.9

Q43|假如你是 LangChain.js 框架,从零到一设计一个 AI Agent 开发框架,说架构与核心实现

  • 分层:接口层(Model / Tool 抽象)→ 原子能力层(Prompt、Splitter、Parser、Retriever)→ 编排层(Chain / Graph 执行器)→ 扩展层(插件、MCP、Skills)。
  • 关键决策:为什么要标准化接口(换供应商不动业务)、为什么要有两种编排(线性 vs 图)、如何做流式与回调(Callback + Stream)。
    → §5.2、§5.5

Q44|字节、阿里等中大厂基于 monorepo 的 AI 全栈工程架构最佳实践,做多模态应用有哪些关键节点?

  • 四步:确定业务(文生文/图/视频、text2sql、text2code、混排、自动剪辑、数字人)→ 选模型(自部署 / SaaS)→ 规划链路(workflow or agent)→ 选技术栈(前端框架、服务框架、PG + ORM、容器编排、AI 层)。
  • monorepo 收益要落到「数据契约不失联」上。
  • 加分:能说出 Turborepo 的增量构建与远程缓存机制。
    → §10.4、§10.5、§2.5

Q45|给你一个小时,用 Vibe Coding 从零交付一个类飞书亿级协同在线表格应用

  • 三份文档递进:项目规划 → 新特性开发规范 → 核心功能计划(指明技术实现)。
  • 核心功能要具体:Canvas 底层绘制 + 遮罩 div 借用滚动条做可视区渲染 + 单元格插件化协议;Next.js + shadcn + Tailwind;Prisma + PostgreSQL;docker compose 起基础设施。
  • 收尾:测试 + lint + 检查规划执行偏差。
    → §12.3、§12.4

16.4 专家级(3 题)

Q46|站在前端架构师角度,说明协同编辑器原理、Yjs 实现,以及 CRDT / OT 的概念与实现

  • 从「一致性」这个目标切入,再讲两大理论。
  • OT:中心服务器 + 版本校验 + Transform(OpC, OpA) 转换(要能画出时序图)。
  • CRDT:生成 Update → 中转 → 本地合并;面向状态 vs 面向操作。
  • Yjs 五特性:Item + 双向链表、全局唯一 ID + 逻辑时钟、确定性排序、Tombstone、Struct 二进制编码。
  • 优缺点各两条(元数据开销、意图保留问题)。
  • 结论:首选 CRDT,OT 在敏捷、高可用、离线体验面前已不合时宜。
  • 附带技术储备:算法、3D 数字孪生(WebGL/WASM、正射影像与倾斜摄影、Tile 与模型处理、PBR 与粒子)、全面性能优化(打包构建、资源、应用、缓存四层)。
    → §7.4、§7.5

Q47|假设你是架构师,实现企业内部类 Coze / Dify 垂直业务 AI 应用开发平台,说明需求及实现

  • 需求侧:先讲清业务痛点与角色(业务方、开发者、运维),再落到功能清单。
  • 平台侧:插件机制(统一接口 + 协议生态)、工作流机制(节点顺序执行)、触发器机制、知识库节点。
  • 节点体系与「如何选节点」四原则:任务类型、模块化、依赖关系、性能考虑。
  • 编辑器三能力:拖拽节点、设置属性、连接节点。
  • 最后用完整项目案例收尾(立项 → 研发 → 沉淀)。
    → §3.4、§6.3、§16.6 案例 A

Q48|开发类似 openclaw 的系统级 AI 智能体,有明确实现方案吗?怎样让 AI 在企业工作流真正落地?

  • 模块化:monorepo(shared / plugins / web / cli / core),core 内含 agent、plugin-system、utils。
  • 五模块职责与扩展点:cli(多命令、交互配置)、core(沙箱、权限、长程记忆、可观测)、plugins(市场、权限分级、MCP 适配)、shared(统一 Schema、错误码、通信协议)、web(任务看板、执行追踪、人机干预、多租户)。
  • 插件三件事:定义规范、扫描加载注册、动态注入。
  • 企业级升级六项:权限管控(RBAC/ABAC)、安全沙箱(vm2/isolated-vm)、长程记忆(向量库)、可观测(日志/追踪/监控)、多模态感知(视觉/文档解析)、API 网关。
  • 标准演进:MCP(统一工具与上下文协议,插件系统既可是 Client 也可是 Server)+ Skills(预定义多步流程与 Prompt 模板组合,含 SKILL.md + scripts + references)。
  • 落地四条能力:脚手架、服务端、前端界面、AI 应用引擎层。
    → §4.6、§5.4、§5.5

16.5 高频追问速答表

追问 一句话答案
CRDT 还是 OT? 首选 CRDT:去中心化、支持离线、服务端轻;OT 转换函数太复杂且强依赖中心服务器
内存型还是服务型工作流? 前者快、无持久化,适合前端预览;后者可断点续传、能人工审批,适合长链路业务
SSE 还是 WebSocket? 单向流式推送用 SSE(简单、自动重连);需要双向或低延迟交互用 WS
pnpm 为什么快? 硬链接只存一份 + 非扁平结构屏蔽幽灵依赖
Turborepo 凭什么快? 任务管线 + 本地/远程缓存命中,只重跑受影响的包
ClickHouse 为什么适合监控? 写多读少、按时间聚合;列存 + 向量化执行,亿级 Group By 秒级出结果
为什么要 Kafka? 解耦生产与消费速度,削峰填谷;按 session 分区保时序
为什么选 SSR 做 AI 应用? token 不能落前端 + 首屏与 SEO + 全栈一体提效
沙箱怎么选? 强隔离用 Docker(慢)、轻隔离用 WASM(快)、进程内用 vm2/isolated-vm(需谨慎)
前端在 Agent 里的不可替代性? 过程可视化、人机干预、流式渲染、引用溯源——全是前端活
LCP / CLS / INP 分别衡量什么? 加载性能 / 视觉稳定性(≤0.1)/ 交互响应速度
LangChain 和 LangGraph 怎么选? 线性简单用 LangChain,有状态、分支、循环、可恢复用 LangGraph
为什么提示词要结构化输出? 免去字符串解析,直接绑定状态,前端最实用的一招
低代码为什么能约束 AI? DSL 相当于给 AI 加一层枷锁,生成物可被编译器校验后再执行

16.6 案例 A:项目介绍模板(可直接背)

适用于「公司 AI 项目从立项到落地你参与了多少」这类题。结构固定:立项阶段(业务产出 + 技术产出)→ 研发落地阶段(业务产出 + 技术产出)→ 技术资产沉淀。

作为前端 Leader,我深度参与了公司级 AI 项目「智能合同分析助手」的全链路过程,主要产出如下:

立项阶段(参与度 80%)

  • 业务产出:
    • 与法务、销售团队共同做需求访谈,识别核心痛点:审查效率低、风险点易遗漏。
    • 主导编写产品原型与交互设计稿,通过可交互 Demo 向管理层展示核心价值与体验,成功推动立项;强调「信息高亮」「风险可视化」「人机协同修订」等前端交互价值点。
  • 技术产出:
    • 技术预研(PoC),与后端架构师共同验证「RAG + 少量微调模型」方案的可行性。
    • 输出《前端技术选型报告》,确定 React + SSE 技术栈,并预估人力成本与时间线。

研发与落地阶段(参与度 100%)

  • 业务产出:
    • V1 上线后,法务团队单份合同平均审查时间从约 45 分钟缩短至约 15 分钟。
    • 上线「风险条款一键定位与解释」功能,用户满意度约 95%。
    • 与产品经理共同制定 V2 Roadmap,规划「多版本合同对比分析」等高级功能。
  • 技术产出:
    • 主导前端架构:采用「文档 - 视图 - 控制器」分离。文档层负责与后端流式接口通信并管理原始数据;视图层高效渲染长篇合同文本与 AI 高亮结果;控制器层处理复杂交互逻辑。
    • 攻克三个难点:
      • 长文档渲染性能:虚拟滚动,100 页以上 PDF 秒级加载与流畅滚动。
      • 高精度文本定位:与后端协作定义文本坐标体系,实现风险条款的像素级高亮。
      • 高并发流式解析:设计稳健的解析与错误恢复机制,网络抖动或响应缺失时前端平滑回退并提示。
  • 技术资产沉淀:
    • 封装内部 react-ai-stream-parser 组件库,统一处理各类 LLM 流式响应,已在公司另外两个项目复用。
    • 编写《前端 AI 应用开发规范》,统一状态管理、API 调用、错误处理的最佳实践。

收尾句:通过这个项目,不仅交付了高价值业务产品,更在团队内部建立了可复用的前端 AI 工程化体系与方法论,为后续 AI 项目打下基础。

其他文章
目录导航 置顶
  1. 1. 十四、音视频与 FFmpeg 基础
    1. 1.1. 14.1 三个必须先分清的概念:容器、编码、协议
    2. 1.2. 14.2 像素、色彩与压缩参数
    3. 1.3. 14.3 命令结构与参数位置
    4. 1.4. 14.4 高频操作(可直接抄)
    5. 1.5. 14.5 滤镜系统:线性链与非线性链
    6. 1.6. 14.6 视觉增强
    7. 1.7. 14.7 色彩空间:Canvas 帧 → 编码器
    8. 1.8. 14.8 前端与 AI 场景落地
    9. 1.9. 14.9 踩坑与经验
  2. 2. 十五、附录
    1. 2.1. 15.1 学习资源索引
    2. 2.2. 15.2 本机案例路径索引
  3. 3. 十六、面试题库
    1. 3.1. 16.1 初中级(16 题)
    2. 3.2. 16.2 中高级(16 题)
    3. 3.3. 16.3 专业级(13 题)
    4. 3.4. 16.4 专家级(3 题)
    5. 3.5. 16.5 高频追问速答表
    6. 3.6. 16.6 案例 A:项目介绍模板(可直接背)
请输入关键词进行搜索