拒绝沟通（“别问我，看代码”）

代码就是最好的文档？别开玩笑了

"看代码不就知道了？"这句话堪称程序员之间的终极杀器。当新人小心翼翼提问时，老鸟甩出这句看似高深实则偷懒的回应，往往伴随着一个意味深长的白眼。这种拒绝沟通的态度，正在你代码库里埋下一颗颗定时炸弹。

变量命名：猜谜游戏开始

// 优秀示范
function calculateTotalPrice(items, taxRate) {
  let subtotal = items.reduce((sum, item) => sum + item.price, 0);
  return subtotal * (1 + taxRate);
}

// 防御性写法
function fn(a, b) {
  let x = a.reduce((y, z) => y + z.p, 0);
  return x * (1 + b);
}

单字母变量名就像在玩扫雷游戏，a可能是数组、可能是字符串、还可能是回调函数。b更妙了，可能是税率、折扣率、甚至是随机数种子。当三个月后bug出现时，作者本人盯着const t = f * s / m这样的代码，也会陷入深深的自我怀疑。

函数设计：俄罗斯套娃的艺术

// 优雅的灾难
function processData(input) {
  return validate(input) 
    ? transform(parse(normalize(input)))
    : handleError(getErrorCode(input));
}

// 更绝的是...
const process = i => v(i) ? t(p(n(i))) : h(g(i));

链式调用看起来很美，直到你需要调试其中某一个环节。当normalize函数悄悄改变了数据结构，导致parse报错时，你不得不在每个环节插入console.log。更妙的是当某个中间函数返回undefined时，错误会像击鼓传花一样往后传递，最后在完全不相干的地方爆炸。

类型体操：让TypeScript也崩溃

interface MysteryBox<T extends unknown[]> {
  _: never;
  __: T[number][];
  ___: keyof T[0];
}

function openBox<T>(box: MysteryBox<T[]>): T {
  return JSON.parse(JSON.stringify(box)) as any;
}

这种类型定义就像在说："我知道类型是什么，但就不告诉你"。当你的泛型参数开始套娃，当你的条件类型嵌套超过三层，连TypeScript编译器都会举手投降。最绝的是最后那个as any，就像魔术师最后的响指——所有类型检查瞬间消失。

错误处理：薛定谔的异常

// 静默是金
try {
  dangerousOperation();
} catch {
  // 这里曾经有个TODO注释
}

// 更高级的做法
function getUser() {
  return fetch('/api/user').then(res => res.json()).catch(() => ({}));
}

捕获错误然后默默吞掉，这是构建不可维护系统的黄金准则。用户看到空白页面？一定是网络问题。数据莫名其妙少了字段？肯定是后端没返回。最妙的是返回空对象的处理方式，这样调用方永远不知道请求是否成功，就像在玩俄罗斯轮盘赌。

配置对象：乐高积木式编程

const config = {
  api: {
    endpoint: process.env.API_ENV === 'prod' 
      ? 'https://api.com' 
      : 'https://dev.api.com',
    retry: 3
  },
  // 200行后的惊喜...
  features: {
    legacy: {
      enabled: true,
      fallback: () => window.location.reload()
    }
  }
};

// 使用时
initializeApp(_.merge(defaultConfig, runtimeConfig, userConfig));

当你的配置对象需要合并三层默认值，当某个关键配置藏在嵌套五层的属性里，当生产环境和开发环境的配置差异分布在三个不同文件中——恭喜你创造了配置地狱。最精彩的是那些动态生成的配置项，就像彩蛋一样等待有缘人去发掘。

依赖注入：控制反转的狂欢

class Service {
  constructor(
    private logger: LoggerInterface,
    private http: HttpClient,
    private config: ConfigService,
    private cache: CacheManager,
    // 还有15个依赖...
  ) {}
  
  async execute() {
    // 使用其中3个依赖
  }
}

// 初始化时
const service = new Service(
  logger, http, config, cache, metrics, validator, 
  translator, context, router, store, /* 更多惊喜 */);

当你的构造函数参数超过屏幕高度，当每个测试用例都需要mock十个依赖项，当你永远搞不清某个方法到底用了哪些依赖——这就是控制反转的终极形态。特别奖励给那些在运行时动态注入依赖的代码，就像开盲盒一样刺激。

条件渲染：React版的"大家来找茬"

function Component() {
  return (
    <div>
      {flag && <Modal />}
      {!error ? (
        <Content data={data} />
      ) : status === 404 ? (
        <NotFound />
      ) : user.isAdmin ? (
        <ErrorDetails error={error} />
      ) : (
        <GenericError />
      )}
      {items.map(item => (
        item.visible && <Item key={item.id} item={item} />
      ))}
    </div>
  );
}

当你的JSX里嵌套了三层条件运算符，当&&操作符和||操作符开始跳探戈，当同一个组件有七种不同的渲染状态——这就是前端界的"七巧板"游戏。额外加分项：在条件分支里悄悄修改组件状态，让每次渲染都变成开盲盒。

CSS选择器：特异性战争

/* 精准打击 */
body > div#app main .container:not(.fluid) > div.row > div[data-grid="col"]:first-child > ul.nav-tabs ~ div.tab-content > .active {
  /* 重要的事情说三遍 */
  color: red !important;
  border-color: red !important;
  background-color: red !important;
}

当你的选择器长得需要滚动查看，当!important出现次数超过函数行数，当修改某个样式需要同时覆盖五个更具体的选择器——这就是CSS的核战争。特别表彰那些在媒体查询里重写样式表的代码，让响应式设计变成猜谜游戏。

异步流程：回调地狱的文艺复兴

async function fetchAll() {
  try {
    const user = await getUser();
    const [orders, messages] = await Promise.all([
      getOrders(user.id).catch(logError),
      getMessages(user.id).then(filterUnread)
    ]);
    return { user, orders, messages };
  } catch (err) {
    if (err instanceof NetworkError) {
      return retryAfter(1000);
    } else if (err instanceof AuthError) {
      return loginPopup().then(fetchAll);
    } else {
      throw wrapError(err);
    }
  }
}

当你的try/catch块嵌套了三层，当你的Promise链既有then又有await，当错误处理路径比正常流程还复杂——这就是异步编程的巴洛克风格。额外加分给那些在循环里使用异步操作的代码，让执行顺序变成随机数生成器。

组件通信：事件总线狂欢节

// 全局事件中心
const bus = new Vue();

// 组件A
bus.$emit('data-loaded', { /* 500KB数据 */ });

// 组件B（在另一个仓库）
bus.$on('data-loaded', data => {
  bus.$emit('update-chart', process(data));
});

// 组件C（由外包团队开发）
mounted() {
  this._handler = data => {
    if (data.type === 'special') {
      bus.$emit('notification', 'Special!');
    }
  };
  bus.$on('update-chart', this._handler);
}

// 组件A的卸载逻辑
beforeDestroy() {
  bus.$emit('data-loaded', null); // 神奇的死机触发器
}

当你的应用状态通过事件总线全球旅行，当某个事件会触发意想不到的连锁反应，当调试时需要跟踪十个不同组件的事件监听器——这就是分布式系统的微缩模型。特别奖励给那些不清理事件监听器的代码，让内存泄漏成为特色功能。