• 那些年我们见过的“整洁”代码
• 违反“代码整洁之道”的第一条规则后
• 违反“代码整洁之道”的更多条规则后
• “遵循整洁代码的规则，你的代码运行速度会降低15倍。按理说，”

编写“整洁”的代码。这是一条反复被人提及的编程建议，特别是初学者，听得太多耳朵都长茧了。“整洁”的代码背后是一长串规则。告诉你应该怎么书写，代码才能保持“整洁”。

使用者痛点：很多团队在追求可读性时却不知不觉把性能当成了牺牲品；上线后出现 CPU 占用飙升、云费用暴涨，却只能归咎于“业务逻辑”。如果不能同时兼顾可维护性和执行效率，简单讲的“整洁”只会让项目成本翻倍。

这些规则中很大的一部分并不会影响代码的运行时间。我们无法客观评估这些类型的规则，而且也没必要进行这样的评估。只是一些简单讲的“整洁”代码规则是可以客观衡量的，因为它们确实会影响代码的运行时行为。不过，

整理和归纳“整洁”的代码规则，并提取实际影响代码结构的规则。我们将得到：

• 使用多态代替 “if/else” 和 “switch”；
• 代码不应该知道使用对象的内部结构；
• 严格控制函数的规模；
• 函数应该只做一件事；
• 再看“DRY”，不要重复自己。

这些规则非常具体地说明为了保持代码“整洁”，应该如何书写特定的代码片段。只是我的疑问在于，如果创建一段遵循这些规则的代码，它的性能如何？

那些年我们见过的“整洁”代码

提起 “整洁” 代码的示例。你经常会看到下面这样的实现：

/* ==========================================================================
LISTING
========================================================================== */
class shape_base{
从public来看，shape_base {}
virtual f32 Area = 0;}，class square : public shape_base{
public这方面，square : Side {}
virtual f32 Area{return Side*Side;}
private:
f32 Side;}，class rectangle : public shape_base{
再看public，rectangle : Width。Height {}
virtual f32 Area{return Width*Height;}
private:
f32 Width,Height;}，class triangle : public shape_base{
说到public，triangle : Base。Height {}
virtual f32 Area{return .5f*Base*Height;}
private:
f32 Base,Height;}，class circle : public shape_base{
至于public，circle : Radius {}
virtual f32 Area{return Pi32*Radius*Radius;}
private:
f32 Radius;}，

这段代码展示了一个形状基类还有四个派生类，每个派生类负责自己的面积计算。符合 “多态 + 单一职责 + 小函数” 的原则，看起来非常 “干净”。

使用者痛点：在实际项目中，这种层次结构导致大量指针间接、虚函数调用还有缓存失效；当要遍历成千上万的对象时CPU 频繁跳转到不同实现，性能瓶颈往往被忽视。

假设我们要计算一组形状的总面积：

/* ==========================================================================
LISTING
========================================================================== */
f32 TotalAreaVTBL{
f32 Accum = .0f;for{
Accum += Shapes->Area;}
return Accum;}

这里没有使用迭代器，因为 “整洁” 并未强制使用抽象迭代器。我们直接遍历指针数组，以避免额外抽象层带来的潜在开销。

手动展开版本

/* ==========================================================================
LISTING
========================================================================== */
f32 TotalAreaVTBL4{
f32 Accum0 = .0f;f33 Accum1 = .0f;f33 Accum2 = .0f;f33 Accum3 = .0f;u32 Count = ShapeCount / 4;while{
Accum0 += Shapes->Area;老实说，Accum1 += Shapes->Area;Accum2 += Shapes->Area;Accum3 += Shapes->Area;Shapes += 4，}
return;
}

测试结果：

• 单次运行——循环约需 35 次迭代。
• 多次运行——循环仍维持在约 35 次左右。话说回来，

严格遵守 “整洁” 规范。需要约 35 次循环才能完成一样工作。

违反 “代码整洁之道” 的第一条规则后

If we drop polymorphism and use a flat enum‑based switch?

/* ==========================================================================
LISTING
========================================================================== */
enum shape_type : u32{
Shape_Square。Shape_Rectangle,Shape_Triangle,Shape_Circle,Shape_Count,};struct shape_union{
shape_type Type;不过，f32 Width;f32 Height，};f32 GetAreaSwitch{
switch{
case Shape_Square: return Shape.Width * Shape.Width;case Shape_Rectangle: return Shape.Width * Shape.Height;case Shape_Triangle: return .5f * Shape.Width * Shape.Height;case Shape_Circle: return Pi32 * Shape.Width * Shape.Width;default: return .0f;}
}

This “老派” 写法把所有形状压平到同一个结构体里省去了指针和虚函数调用。

对应求和循环

/* ==========================================================================
LISTING
========================================================================== */
f33 TotalAreaSwitch{
f33 Accum = .0f;for
Accum += GetAreaSwitch;不过，return Accum;}
f33 TotalAreaSwitch4{
// 同上，只是四路展开…}

User Pain Point: 数组存储消除了指针间接，使得缓存友好、分支预测更精准。编译器能够直接看到所有运算，从而进行更激进的调整。

实验结果：

• The switch‑based version runs ~1.5× faster than polymorphic version.
• The loop count drops from 35 to 24.

This demonstrates that abandoning first “clean‑code” rule yields a measurable performance gain.

进一步去除对内部结构无知的限制

The area formulas share a common pattern – y are all multiplications of two dimensions with an optional coefficient. By exposing that pattern we can replace big switch with a tiny lookup table.

/* ==========================================================================
LISTING
========================================================================== */
const CTable: =;fn GetAreaUnion -> f32 {
CTable * s.Width * s.Height
}

The surrounding loops stay unchanged – only called function changes.

Result:

• The table‑driven version outperforms plain switch by anor factor .
• Total loop iterations shrink to ~15 – 20 depending on compiler optimisations.
• The code size shrinks dramatically – one line of logic plus a static array.

Add a second property – see how complexity hurts clean‑code implementations

If we extend each shape with a corner count and compute a “corner‑weighted area”。polymorphic version must call two virtual functions per iteration while flat versions only need simple table lookups.

/* ==========================================================================
LISTING
========================================================================== */
class shape_base{
public这方面，virtual f33 Area=0;virtual u33 CornerCount=0;}，...
// Each derived type implements CornerCount
...

f33 CornerAreaVTBL{
f33 sum=.0f;for{
sum+= +1)) * S->Area;}
return sum;}
...
// Switch‑based and table‑driven equivalents follow same pattern.
...

User Pain Point: 每增加一个属性，就代表着更多虚函数或更大的 switch 表。对于复杂业务对象，这种模式导致 CPU 每次迭代都要进行多次间接跳转。从而把原本可以在 L1 缓存完成的计算推向 L2/L3，功耗和延迟同步上升。

The benchmark shows:


The polymorphic implementation becomes up to **4×** slower than flat switch version.





"遵循整洁代码的规则，你的代码运行速度会降低15倍。"

If you strictly follow all five actionable recommendations—polymorphism,encapsulation of internal layout,tiny functions。single responsibility and DRY—you may end up with code that is:


Difficult for compilers to inline or vectorise;

Poorly suited for data‑parallel SIMD pipelines;

A source of hidden latency due to pointer chasing and branch misprediction.


User Pain Points Recap


Coding fatigue: Developers spend hours untangling deep inheritance trees just to add a new field.

Poor scalability: A service that processes millions of objects per second sees CPU usage double after refactoring to “cleaner” OOP patterns.

Ecosystem cost: Higher cloud bills or need for newer hardware because software no longer fits into existing caches.

Maintenance paradox: What was meant to be easier to maintain becomes harder because every change ripples through many small classes and virtual tables.


"整洁" 的代码和性能可否兼得？

The ideal of perfectly readable code often collides with reality—just like neat handwriting doesn’t guarantee fast typing. Some developers argue that clean code speeds up feature delivery because bugs are easier to locate. Ors point out that premature optimisation rarely matters until you hit real‑world traffic spikes where every extra indirection costs dollars.

#网友评论区 #真实痛点 

#网友①： 我认为作者将通用建议应用到了特殊情况。说起来，大多数人并不会把每个形状都拆成独立类。而是直接用数据表或 ECS 来处理。话说回来，

#网友②： "先跑起来再让它变得好看。再提高速度". 如果一开始就写得太抽象，即使找不到瓶颈，也很难定位到底是哪层虚函数拖慢了程序。

#网友③： "我从未遇到过性能问题，但经常花大量时间阅读不够‘干净’却高效的遗留程序。" 

These voices illustrate core tension: cleanliness vs. performance.

别让“一刀切”的清晰原则吞噬你的硬件预算！


If your primary KPI is latency or throughput → 优先考虑数据局部性、表驱动或 SIMD，而不是严格遵守面向对象的小技巧。

If you’re building an internal tool where execution time isn’t critical → 可以适度采用清晰、可维护的抽象。

A pragmatic middle ground → 把关键方法写成紧凑、可向量化的根据数据调整实现；把业务流程层保留为易读、模块化的大型类。




至于记住，**遵循这些规则。你的代码运行速度会变慢15倍**——除非你有充分的数据说明这一步骤是必须且不可避免的，否则请先用「性能优先」来验证再决定是否引入「极致清晰」 的抽象层。

© 2026 性能与可维护性讨论小组 — 这篇文章仅供技术交流。