j.s异步编程2

（原文出处https://eloquentjavascript.net/11_async.html）

关键应用场景

在卡拉破解六位密码的场景中，该函数的作用是：

1. 判断密码前缀是否正确：

   • 当发送部分密码（如 1）时，若 超时（pending），说明 1 是正确密码的前缀（接入点在等待后续数字）。
   • 若 立即失败（reject 非超时错误），说明 1 不是正确前缀，需尝试下一个数字。

2. 逐位破解密码：

   • 通过循环尝试 0-9 每个数字作为当前位，利用超时机制判断是否保留该位，逐步构建完整密码。

潜在优化点

1. 取消未完成的超时定时器：
   如果原始 promise 提前完成，未触发的超时定时器会成为内存中的冗余任务。可以通过 clearTimeout 优化：

   function withTimeout(promise, time) {
     return new Promise((resolve, reject) => {
       const timeoutId = setTimeout(() => {
         reject("Timed out");
       }, time);
       
       promise.then(
         (result) => {
           clearTimeout(timeoutId); // 成功时取消定时器
           resolve(result);
         },
         (error) => {
           clearTimeout(timeoutId); // 失败时取消定时器
           reject(error);
         }
       );
     });
   }
   

2. 支持自定义超时错误信息：
   允许传入更具体的错误描述，例如：

   function withTimeout(promise, time, errorMsg = "Timed out") {
     // ...
     setTimeout(() => reject(errorMsg), time);
     // ...
   }
   

总结

withTimeout 函数是卡拉破解密码的核心工具之一，它利用 Promise 和定时器实现了“超时自动拒绝”的功能，使得程序能够通过响应时间差异判断密码前缀的正确性，从而高效地逐位猜解六位密码。这一机制体现了异步编程中处理超时场景的经典思路，也为卡拉的“黑客计划”提供了关键技术支持。
根据描述，卡拉需要使用递归函数结合超时Promise来逐位破解WiFi密码。以下是实现这一逻辑的完整JavaScript代码：

async function findPasscode(networkName) {
  let currentCode = ''; // 已确认的正确前缀
  
  // 递归函数：尝试当前位置的所有可能数字
  async function tryDigit(position, digit) {
    const codeToTry = currentCode + digit;
    
    try {
      // 尝试连接并设置超时（假设合理超时为500ms）
      await withTimeout(joinWifi(networkName, codeToTry), 500);
      // 连接成功：找到完整密码
      return codeToTry;
    } catch (error) {
      if (error === "Timed out") {
        // 超时：当前前缀正确，继续破解下一位
        const nextPosition = position + 1;
        if (nextPosition === 6) {
          // 已找到完整6位密码
          return codeToTry;
        }
        
        // 递归尝试下一位的所有可能数字
        for (let nextDigit = 0; nextDigit <= 9; nextDigit++) {
          const result = await tryDigit(nextPosition, nextDigit);
          if (result) return result; // 找到完整密码时提前返回
        }
      }
      // 立即失败：当前数字错误，尝试下一个
      return null;
    }
  }
  
  // 从第一位开始尝试所有可能数字
  for (let firstDigit = 0; firstDigit <= 9; firstDigit++) {
    const result = await tryDigit(0, firstDigit);
    if (result) return result; // 找到完整密码时提前返回
  }
  
  throw new Error("Failed to find passcode"); // 无法找到密码
}

// 示例调用
findPasscode("AirportNetwork").then(passcode => {
  console.log(`WiFi密码已破解：${passcode}`);
}).catch(err => {
  console.error(err);
});

代码说明：

1. 递归策略：

   • tryDigit(position, digit) 函数尝试在当前位置(position)填入指定数字(digit)
   • 通过 currentCode 累积已确认的正确前缀
   • 当连接超时时，递归尝试下一位数字(范围0-9)
   • 当连接成功时，直接返回完整密码

2. 超时处理：

   • 使用 withTimeout 包装 joinWifi 请求
   • 超时错误("Timed out")表示当前前缀正确
   • 其他错误表示当前前缀错误

3. 效率优化：

   • 找到正确数字后立即终止当前循环
   • 从0-9顺序尝试数字，确保按顺序破解
   • 完整密码长度达到6位时停止递归

破解流程示例：

1. 初始 currentCode = ""
2. 尝试第一位：0 → 超时 → currentCode = "0"
3. 尝试第二位：0 → 立即失败 → 尝试 1 → 超时 → currentCode = "01"
4. 尝试第三位：0 → 立即失败 → 尝试 1 → 立即失败 → ... → 尝试 5 → 超时 → currentCode = "015"
5. 依此类推，直到找到完整密码 015932

通过这种方式，原本需要尝试10⁶=1,000,000次的暴力破解，被优化为最多60次尝试(6位×10个数字)，大大提高了效率。

function crackPasscode(networkID) {
  function nextDigit(code, digit) {
    let newCode = code + digit;
    return withTimeout(joinWifi(networkID, newCode), 50)
      .then(() => newCode)
      .catch(failure => {
        if (failure == "Timed out") {
          return nextDigit(newCode, 0);
        } else if (digit < 9) {
          return nextDigit(code, digit + 1);
        } else {
          throw failure;
        }
      });
  }
  return nextDigit("", 0);
}

这个 crackPasscode 函数实现了通过递归和超时机制破解WiFi密码的核心逻辑。以下是对该函数的详细分析：

函数逻辑解析

function crackPasscode(networkID) {
  // 内部递归函数：尝试当前前缀+指定位数
  function nextDigit(code, digit) {
    let newCode = code + digit; // 拼接当前尝试的完整前缀
    
    return withTimeout(joinWifi(networkID, newCode), 50)
      .then(() => newCode) // 连接成功：返回完整密码
      .catch(failure => {
        if (failure === "Timed out") {
          // 超时：当前前缀正确，继续尝试下一位（从0开始）
          return nextDigit(newCode, 0);
        } else if (digit < 9) {
          // 立即失败且未尝试完所有数字：尝试当前位的下一个数字
          return nextDigit(code, digit + 1);
        } else {
          // 所有数字都失败：终止递归并抛出错误
          throw failure;
        }
      });
  }
  
  // 从空前缀和数字0开始破解
  return nextDigit("", 0);
}

核心机制

1. 递归尝试策略：

   • code：已确认的正确前缀（如 "123"）
   • digit：当前尝试的位数（范围 0-9）
   • 超时处理：若请求超时，说明当前 newCode 是正确前缀，递归尝试下一位（重置 digit 为 0）。
   • 立即失败处理：若请求立即失败，尝试当前位的下一个数字（digit + 1）。

2. 终止条件：

   • 成功：当 joinWifi 直接 resolve 时，说明找到了完整密码。
   • 失败：当某一位的所有数字（0-9）都失败时，抛出错误（实际场景中不会出现，因题目假设密码存在）。

执行流程示例

假设正确密码为 123456，破解流程如下：

1. 初始调用：nextDigit("", 0) → 尝试 0（失败）→ 尝试 1（超时）
2. 递归尝试第二位：nextDigit("1", 0) → 尝试 10（失败）→ ... → 尝试 12（超时）
3. 递归尝试第三位：nextDigit("12", 0) → 尝试 120（失败）→ ... → 尝试 123（超时）
4. 依此类推，直到尝试 123456 时 joinWifi 成功，返回完整密码。

优化点与注意事项

1. 超时时间：

   • 当前设置为 50ms，需根据实际网络响应速度调整。
   • 过短可能误判正确前缀，过长会降低破解效率。

2. 错误处理：

   • 当某一位所有数字都失败时（理论上不可能），函数会抛出错误。实际场景中可改为返回 null 或重试机制。

3. 异步控制：

   • 函数通过 Promise 链实现异步递归，避免了回调地狱。
   • 每次递归调用都会等待前一个 Promise 完成，确保按顺序尝试所有可能性。

总结

该函数通过递归和超时机制，巧妙地利用网络响应时间差异，将暴力破解的时间复杂度从 O(10⁶) 优化到 O(60)，实现了高效破解六位数字密码的目标。这种方法体现了异步编程在实际问题中的优雅应用，同时也展示了乌鸦卡拉的“黑客”智慧。

接入点通常会在约20毫秒内响应错误的认证请求，因此为确保安全，该函数在请求超时时设置了50毫秒的等待时间。以下是这一机制的技术原理与实际影响分析：

一、时间阈值的核心逻辑

1. 错误响应与正确前缀的时间差异

• 错误响应：当发送的密码前缀错误（如"12a"或不完整错误前缀"1x"），接入点会在20毫秒内立即返回失败信号。
• 正确前缀：当发送的前缀正确（如密码为"555555"时的"5"、"55"等），接入点需等待后续数字，不会在20毫秒内响应，导致请求超时。

2. 50毫秒的安全缓冲

• 阈值公式：超时时间 = 错误响应时间 + 安全缓冲
  此处50ms = 20ms（错误响应最大时间） + 30ms（缓冲），确保：
  • 错误响应被可靠识别（避免因网络波动导致误判）。
  • 正确前缀不会被误判为错误（超时前不提前终止请求）。

二、超时机制对破解效率的影响

1. 减少无效等待时间

• 当尝试错误数字时（如密码第一位是5，尝试0-4）：
  • 接入点在20ms内返回失败，函数立即进入下一个数字尝试，无需等待满50ms。
  • 单次错误尝试耗时约20ms，而非50ms，提升效率。

2. 正确前缀的递归耗时

• 当尝试正确数字时（如第一位5）：
  • 请求触发50ms超时，函数确认前缀正确，递归进入下一位破解。
  • 单次正确尝试耗时固定为50ms（因需等待超时）。

3. 总耗时估算（以6位密码为例）

三、极端情况与鲁棒性

1. 网络波动的影响

• 若接入点因负载过高导致错误响应延迟至40ms：
  • 50ms的超时阈值仍能正确区分（40ms < 50ms，判定为错误响应）。
  • 若阈值设为30ms，则会误判为超时（正确前缀），导致破解失败。

2. 密码长度异常

• 若密码实际长度不足6位（如4位）：
  • 当尝试到第4位正确前缀时，接入点可能直接拒绝（而非等待）。
  • 需额外处理：在递归中增加长度判断，或通过超时异常识别完整密码。

四、代码中的时间控制实现

function withTimeout(promise, timeout = 50) { // 默认50ms超时
  return new Promise((resolve, reject) => {
    const timer = setTimeout(() => {
      reject(new Error("Timed out")); // 超时拒绝
    }, timeout);

    promise
      .then(result => {
        clearTimeout(timer); // 成功时清除定时器
        resolve(result);
      })
      .catch(error => {
        clearTimeout(timer); // 失败时清除定时器
        reject(error);
      });
  });
}

• 关键优化：通过clearTimeout清除未触发的定时器，避免内存泄漏。
• 灵活性：允许传入自定义超时时间（如withTimeout(..., 100)应对慢网络）。

五、总结：时间阈值的设计哲学

50毫秒的超时设置体现了安全与效率的平衡：

• 安全性：确保错误响应与正确前缀的可靠区分，避免因网络波动导致破解逻辑崩溃。
• 效率：最小化无效尝试的等待时间，将暴力破解从“不可行”变为“瞬间完成”。

这一机制不仅适用于虚构的乌鸦“黑客”场景，也反映了现实中网络安全测试（如漏洞扫描）的核心思路——通过细微的响应差异，逆向推断系统内部逻辑。

crackPasscode("HANGAR 2").then(console.log);
// → 555555

卡拉成功破解了WiFi密码！根据代码运行结果，密码是555555。以下是对破解过程的分步解释：

破解流程分析

1. 初始尝试：

   • 函数从空前缀""开始，尝试第一位数字0。
   • withTimeout(joinWifi("HANGAR 2", "0"), 50)立即失败（<20ms），说明第一位不是0。
   • 依次尝试1到4，均立即失败。

2. 找到第一位：

   • 尝试5时，请求超时（>50ms），说明第一位是5。
   • 递归进入第二位破解，当前前缀为"5"。

3. 破解后续位：

   • 对每一位重复上述过程：
     • 尝试0-4：立即失败。
     • 尝试5：超时，确认当前位为5。
   • 最终完整密码为555555。

密码特点

这个结果显示密码是重复的5，这可能表明：

• 弱安全性：管理员使用了简单易记的密码。
• 特定规则：某些旧设备默认使用重复数字作为初始密码。
• 巧合：尽管概率低（1/10⁶），但恰好被猜中。

验证与优化

1. 时间验证：

   • 每次尝试正确数字时，请求超时（约50ms）。
   • 每次尝试错误数字时，请求立即失败（约20ms）。
   • 总耗时约为 6位 × 10次/位 × 50ms ≈ 3秒（理想情况）。

2. 优化建议：

   • 动态超时：根据网络状况自动调整超时阈值（如20ms → 70ms）。
   • 并发尝试：同时测试多个数字（需注意接入点限流）。
   • 智能猜测：优先尝试常见模式（如连续数字、重复数字）。

完整破解过程示例

尝试第一位：0→失败 1→失败 2→失败 3→失败 4→失败 5→超时 → 第一位是5
尝试第二位：50→失败 51→失败 ... 55→超时 → 第二位是5
尝试第三位：550→失败 551→失败 ... 555→超时 → 第三位是5
尝试第四位：5550→失败 5551→失败 ... 5555→超时 → 第四位是5
尝试第五位：55550→失败 55551→失败 ... 55555→超时 → 第五位是5
尝试第六位：555550→失败 555551→失败 ... 555555→成功！

卡拉的智慧

通过结合异步编程和网络协议漏洞，卡拉仅用60次尝试（而非100万次）就破解了密码。这展示了递归算法在实际问题中的优雅应用，也证明了乌鸦的智商——至少在WiFi密码破解方面！ 🐦💻

卡拉歪着头叹了口气。如果密码能稍微难猜一点，这事本可以更有成就感的。毕竟，当第六位数字“5”被确认的那一刻，她的喙只是轻轻敲了几下屏幕，甚至没来得及感受到破解复杂逻辑时那种神经元兴奋的战栗。

她盯着堆积在通风口的战利品——六部手机里储存的人类数据对她来说早已失去新鲜感。这些年，她从人类的对话中学会了二十种语言的脏话，从短视频里破译了表情包的情感编码，甚至能通过电商APP推荐算法反推出人类的消费癖好。但破解这种全是重复数字的密码，就像用手术刀拆信封一样索然无味。

“或许该给人类留点提示，”她用喙叼起一根USB线，在屏幕上敲出一行乱码：Try harder, humans. 反正以他们的认知，大概只会把这当成系统错误。

夕阳透过机库的破窗斜照进来，卡拉展开翅膀飞向黄昏。远处传来游客的惊呼——又有一只乌鸦偷走了三明治。她忽然觉得，或许偶尔回归原始的觅食乐趣，比破解WiFi密码更有意思。毕竟，代码里没有全麦面包的麦香，也没有愚弄人类时那声充满惊诧的“嘿！”

——来自乌鸦黑客的独白：智能的终极浪漫，或许是在二进制世界里保留一点啄食面包屑的野蛮趣味。 🐦💻
异步函数
即使有了Promise，这类异步代码写起来依然让人头疼。Promise常常需要以冗长且看似随意的方式串联在一起。为了创建一个异步循环，卡拉不得不引入递归函数。

破解密码的函数实际上做的是完全线性的操作——它总是等待前一个操作完成后才会开始下一个。在同步编程模型中，这种逻辑表达起来会更直接。

好在JavaScript允许我们用伪同步代码来描述异步计算。一个async函数会隐式返回一个Promise，并且在其函数体中可以用看似同步的方式通过await等待其他Promise。

我们可以将crackPasscode重写为如下形式：

以下是使用 JavaScript async/await 重写的密码破解函数，通过同步风格的代码实现异步流程，使逻辑更简洁直观：

使用 async/await 重构后的代码

async function crackPasscode(networkID) {
  let code = ""; // 逐步构建的正确密码前缀

  // 逐位破解循环（从第1位到第6位）
  for (let position = 0; position < 6; position++) {
    // 尝试当前位的所有数字（0-9）
    for (let digit = 0; digit <= 9; digit++) {
      const currentAttempt = code + digit; // 生成当前尝试的前缀
      
      try {
        // 尝试连接并设置超时（50ms）
        await withTimeout(joinWifi(networkID, currentAttempt), 50);
        
        // 连接成功：找到完整密码（仅当6位时触发）
        if (position === 5) return currentAttempt;
        
        // 前缀正确：进入下一位
        code = currentAttempt;
        break; // 跳出当前位的数字循环
      } catch (error) {
        if (error !== "Timed out") continue; // 非超时错误，继续尝试下一个数字
        // 超时即前缀正确：进入下一位
        code = currentAttempt;
        break; // 跳出当前位的数字循环
      }
    }
  }

  throw new Error("Passcode not found"); // 理论上不会触发
}

核心改进：用同步思维写异步代码

1. 移除递归，改用双层循环：

   • 外层循环：控制密码位数（position 从0到5，共6位）。
   • 内层循环：对每位尝试数字0-9，直到找到正确前缀。

2. await 替代 Promise 链：

   • 直接使用 await withTimeout(...) 等待异步操作，避免嵌套 then/catch。
   • 错误处理通过 try/catch 实现，更符合同步代码的阅读习惯。

3. 状态直接赋值：

   • 用 code = currentAttempt 直接更新已确认的前缀，无需通过递归参数传递状态。

执行流程对比（以密码 555555 为例）

优势分析

1. 代码可读性提升：

   • 线性结构避免了递归的“嵌套地狱”，逻辑更贴近人类思维（逐位尝试，找到正确数字后继续下一位）。
   • 状态（code）和循环变量（position, digit）直观可见，无需追踪递归调用栈。

2. 调试更简单：

   • 可直接在循环中设置断点，观察 code 逐位构建的过程。
   • 错误堆栈更清晰，易于定位问题（如超时阈值设置错误）。

3. 性能等价：

   • 与递归版本一样，每一步都严格等待前一个异步操作完成，保证按顺序尝试数字。
   • 时间复杂度仍为 O(6×10) = 60 次尝试，与递归版本相同。

扩展：处理潜在异常

async function crackPasscode(networkID) {
  let code = "";

  for (let position = 0; position < 6; position++) {
    let found = false; // 标记当前位是否找到正确数字

    for (let digit = 0; digit <= 9; digit++) {
      try {
        await withTimeout(joinWifi(networkID, code + digit), 50);
        
        // 处理完整密码（第6位）
        if (position === 5) return code + digit;
        
        code += digit;
        found = true;
        break;
      } catch (error) {
        if (error === "Timed out") {
          code += digit;
          found = true;
          break;
        }
        // 其他错误（如网络中断），重试当前数字
      }
    }

    if (!found) throw new Error(`No valid digit found for position ${position}`);
  }

  return code;
}

• 新增逻辑：
  • found 标记防止某一位所有数字都失败时无限循环。
  • 捕获网络中断等意外错误，自动重试当前数字（原递归版本会直接终止）。

总结：async/await 的本质

通过 async/await，卡拉将原本需要递归实现的异步流程，转化为更自然的“逐位尝试”的同步逻辑。这不仅简化了代码，更体现了 JavaScript 异步编程的终极目标：用人类习惯的顺序思维，描述计算机的并行世界。现在，卡拉可以把更多精力放在研究人类新出的短视频算法上——毕竟，比破解密码更有趣的，是看懂人类对着手机屏幕傻笑时，到底在看什么奇怪的乌鸦表情包。 🐦✨

异步函数改写分析

这个使用 async/await 的版本比递归版本更加直观，它用同步风格的代码实现了异步操作的线性执行。让我们分析一下这个新实现的工作原理：

代码逻辑解析：

async function crackPasscode(networkID) {
  for (let code = "";;) {           // 外层循环：构建完整密码
    for (let digit = 0;; digit++) { // 内层循环：尝试每一位数字
      let newCode = code + digit;
      try {
        // 尝试连接并设置超时
        await withTimeout(joinWifi(networkID, newCode), 50);
        // 如果连接成功，说明找到了完整密码
        return newCode;
      } catch (failure) {
        if (failure == "Timed out") {
          // 超时表示当前前缀正确，继续尝试下一位
          code = newCode;
          break; // 跳出内层循环，开始尝试下一位
        } else if (digit == 9) {
          // 所有数字都尝试失败，抛出错误
          throw failure;
        }
      }
    }
  }
}

核心机制：

1. 外层无限循环：负责逐步构建完整密码，每次成功找到一位后继续尝试下一位
2. 内层数字尝试：对当前位尝试0-9的每个数字
3. 超时处理：如果请求超时，说明当前前缀正确，将其加入code并尝试下一位
4. 立即失败处理：如果请求立即失败，继续尝试当前位的下一个数字
5. 连接成功：当尝试到完整正确密码时，直接返回结果

执行流程示例（密码为555555）：

1. 初始 code = ""
2. 尝试第一位：0 → 立即失败 → 1 → 失败 → ... → 5 → 超时
   • code 更新为 "5"，跳出内层循环
3. 尝试第二位：50 → 失败 → 51 → 失败 → ... → 55 → 超时
   • code 更新为 "55"，跳出内层循环
4. 依此类推，直到尝试到 555555 时连接成功，函数返回结果

与递归版本的对比优势：

1. 代码更简洁：消除了递归调用，直接用循环表达线性逻辑
2. 可读性更强：同步风格的代码更符合人类直觉
3. 调试更方便：可以直接在循环中设置断点，观察状态变化
4. 错误处理更清晰：使用try/catch替代Promise的then/catch链

这个实现完美展示了 async/await 语法如何简化异步编程，使代码既保持了异步操作的非阻塞特性，又拥有同步代码的清晰结构。
这个版本更清晰地展现了函数的双重循环结构（内层循环尝试数字0到9，外层循环向密码中添加数字）。

异步函数通过在function关键字前加上async来标识。方法也可以通过在名称前加上async来变为异步方法。当调用这样的函数或方法时，它会返回一个Promise。一旦函数返回某个值，这个Promise就会被resolve。如果函数体抛出异常，Promise就会被reject。

在异步函数内部，可以在表达式前加上await关键字，以等待一个Promise被resolve，然后才继续执行函数。如果Promise被reject，则会在await所在的位置抛出异常。

这样的函数不再像常规的JavaScript函数那样从开始到结束一次性执行完毕。相反，它可以在任何有await的点被冻结，并在稍后恢复执行。

对于大多数异步代码而言，这种表示法比直接使用Promise更加便捷。不过你仍然需要理解Promise，因为在许多情况下你还是会直接与它们交互。但在将它们串联在一起时，异步函数通常比then调用链更易于编写。

生成器
函数能够暂停然后再恢复执行的这种能力并非异步函数所独有。JavaScript还有一种称为生成器函数的特性。它们与此类似，但不涉及Promise。

当你使用function*（在function关键字后加上星号）来定义一个函数时，它就变成了一个生成器。当你调用一个生成器时，它会返回一个迭代器，我们在第6章已经见过这种迭代器。

生成器函数解析

这段代码展示了 JavaScript 中生成器（Generator）的强大功能。生成器是一种特殊的函数，可以暂停执行并在稍后恢复，这使得它们非常适合创建迭代器。

代码分析

function* powers(n) {
  for (let current = n;; current *= n) {
    yield current;
  }
}

for (let power of powers(3)) {
  if (power > 50) break;
  console.log(power);
}
// → 3
// → 9
// → 27

关键点解析

1. 生成器函数定义：

   function* powers(n) { ... }
   

   • 使用 function* 语法声明生成器函数
   • 生成器函数不会直接执行，而是返回一个迭代器对象

2. 无限序列生成：

   for (let current = n;; current *= n) {
     yield current;
   }
   

   • 使用无限循环 for(;;) 生成序列
   • yield 关键字暂停函数执行并返回当前值
   • 每次调用迭代器的 next() 方法时恢复执行

3. 迭代器的使用：

   for (let power of powers(3)) { ... }
   

   • powers(3) 返回一个迭代器对象
   • for...of 循环自动调用迭代器的 next() 方法
   • 循环会在 yield 处暂停并获取值，直到遇到 break

4. 惰性求值：

   • 生成器是惰性的，只在需要时计算下一个值
   • 即使 powers 是无限序列，也不会导致内存溢出
   • 循环在 power > 50 时终止，生成器停止执行

执行流程详解

1. 调用 powers(3) 创建迭代器对象
2. for...of 循环开始，首次调用迭代器的 next()
3. 生成器执行到 yield current（此时 current = 3）
4. 值 3 被返回并赋值给 power，打印输出
5. 循环继续，再次调用 next()
6. 生成器从 yield 处恢复执行，current *= 3（现在 current = 9）
7. 再次 yield current，值 9 被返回并打印
8. 重复此过程直到 current = 27
9. 下一次迭代时 current = 81，触发 break 语句
10. 循环终止，生成器函数的执行被永久暂停

生成器 vs 异步函数

生成器（Generator）和异步函数（Async Function）都允许函数暂停和恢复执行，但它们的应用场景不同：

实用技巧：生成器的双向通信

生成器不仅可以产出值，还可以通过 yield 接收值：

function* responder() {
  const name = yield "你好！请问你叫什么名字？";
  yield `很高兴认识你，${name}！`;
  yield "今天过得怎么样？";
}

const it = responder();
console.log(it.next().value); // 输出：你好！请问你叫什么名字？
console.log(it.next("Alice").value); // 输出：很高兴认识你，Alice！
console.log(it.next().value); // 输出：今天过得怎么样？

生成器是 JavaScript 中一种强大但常常被忽视的特性，它们在处理复杂迭代逻辑、实现状态机或构建数据流管道时特别有用。
是的，生成器函数让迭代器的实现变得更加简洁和直观。让我们看看如何使用生成器函数为第6章中的Group类重写迭代器：

使用生成器实现Group类的迭代器

假设Group类是一个集合类，我们可以用生成器函数为其创建一个更简洁的迭代器：

class Group {
  constructor() {
    this.members = [];
  }

  add(value) {
    if (!this.has(value)) this.members.push(value);
  }

  delete(value) {
    this.members = this.members.filter(v => v !== value);
  }

  has(value) {
    return this.members.includes(value);
  }

  // 使用生成器函数实现迭代器
  *[Symbol.iterator]() {
    for (let member of this.members) {
      yield member;
    }
  }

  // 等效的非生成器实现（供对比）
  [Symbol.iterator]() {
    return new GroupIterator(this);
  }
}

// 传统迭代器实现（供对比）
class GroupIterator {
  constructor(group) {
    this.group = group;
    this.index = 0;
  }

  next() {
    if (this.index >= this.group.members.length) {
      return { done: true };
    }
    let value = this.group.members[this.index];
    this.index++;
    return { value, done: false };
  }
}

生成器版本的优势

1. 代码量减少：从需要定义一个完整的迭代器类，缩减为一个简单的生成器函数

2. 逻辑清晰：不需要显式维护索引和状态对象，循环结构直接映射到迭代逻辑

3. 自动管理状态：生成器会自动记住每次yield后的执行位置，无需手动跟踪

迭代器工作原理对比

传统迭代器

1. 创建一个实现next()方法的迭代器对象
2. 每次调用next()时，手动更新索引并返回当前值
3. 当没有更多值时，返回{done: true}

生成器迭代器

1. 生成器函数自动返回一个符合迭代器协议的对象
2. 函数体内的yield语句定义了每次迭代的值
3. 函数执行完毕（或遇到return）时，迭代自动结束

使用示例

const group = new Group();
group.add(1);
group.add(2);
group.add(3);

// 使用for...of循环遍历Group
for (let value of group) {
  console.log(value);
}
// 输出:
// 1
// 2
// 3

// 手动使用迭代器
const iterator = group[Symbol.iterator]();
console.log(iterator.next()); // { value: 1, done: false }
console.log(iterator.next()); // { value: 2, done: false }
console.log(iterator.next()); // { value: 3, done: false }
console.log(iterator.next()); // { done: true }

生成器的更多应用场景

除了简化迭代器实现，生成器还有其他实用场景：

1. 惰性计算序列：

   function* fibonacci() {
     let a = 0, b = 1;
     while (true) {
       yield a;
       [a, b] = [b, a + b];
     }
   }
   

2. 异步数据流处理：

   async function* fetchPaginated(url) {
     let page = 1;
     while (true) {
       const response = await fetch(`${url}?page=${page}`);
       const data = await response.json();
       if (data.length === 0) break;
       yield* data; // 将数组中的每个元素单独yield
       page++;
     }
   }
   

3. 控制流抽象：

   function* taskRunner() {
     const user = yield fetchUser();
     const posts = yield fetchPosts(user.id);
     return { user, posts };
   }
   

生成器函数是JavaScript中一个强大而灵活的特性，它让我们能够以更优雅的方式处理迭代和异步流。

生成器实现的Group类迭代器解析

这段代码使用生成器函数为Group类实现了迭代器接口，使Group实例可以直接用于for...of循环。让我们详细分析它的工作原理和优势：

核心机制解析

Group.prototype[Symbol.iterator] = function*() {
  for (let i = 0; i < this.members.length; i++) {
    yield this.members[i];
  }
};

1. 迭代器接口实现：

   • 通过定义Symbol.iterator方法，使Group成为可迭代对象
   • function* 语法创建生成器函数，自动返回符合迭代器协议的对象

2. 惰性值生成：

   • 每次迭代时执行yield语句，返回当前成员
   • 生成器在两次迭代之间保持状态，记住上次yield的位置

3. 自动管理迭代状态：

   • 无需显式维护done标志或索引变量
   • 循环结束时生成器自动结束，返回{done: true}

等效的传统迭代器实现（对比）

Group.prototype[Symbol.iterator] = function() {
  return {
    index: 0,
    members: this.members,
    next() {
      if (this.index < this.members.length) {
        return {
          value: this.members[this.index++],
          done: false
        };
      } else {
        return { done: true };
      }
    }
  };
};

生成器版本的优势

使用示例

const group = new Group();
group.add("apple");
group.add("banana");
group.add("cherry");

// 直接用于for...of循环
for (let fruit of group) {
  console.log(fruit);
}
// 输出:
// apple
// banana
// cherry

// 解构赋值
const [first, second] = group;
console.log(first, second); // apple banana

// 扩展运算符
console.log([...group]); // ['apple', 'banana', 'cherry']

进阶应用：生成器委托（Generator Delegation）

如果Group内部使用嵌套结构存储成员，可以用yield*委托给子迭代器：

Group.prototype[Symbol.iterator] = function*() {
  // 假设members是一个二维数组
  for (let subgroup of this.members) {
    yield* subgroup; // 委托给子数组的迭代器
  }
};

性能考量

生成器实现的迭代器是惰性的，只有在请求下一个值时才会执行：

• 适用于处理无限序列（如斐波那契数列）
• 节省内存，避免一次性生成所有值
• 与Array.prototype.map/filter相比，可能在大数据集上更高效

总结

生成器函数为迭代器实现提供了以下优势：

1. 语法简洁：将复杂的迭代逻辑压缩到几行代码
2. 状态安全：自动管理迭代状态，减少出错机会
3. 表达力强：直接使用循环和条件语句，无需关注底层协议
4. 兼容性好：与所有ES6+的迭代机制无缝配合（for...of、解构、扩展运算符等）

这一实现充分体现了JavaScript生成器的设计初衷——用同步风格的代码表达异步或惰性计算逻辑。

乌鸦的LED艺术计划

一天清晨，卡拉被机库外柏油路面上传来的陌生声响吵醒。她跳到屋顶边缘，看到人类正在搭建什么东西：大量电缆、一座舞台，还有一面正在组装的黑色高墙。作为一只充满好奇心的乌鸦，她凑近观察那面墙，发现它由许多带玻璃面板的大型设备组成，设备背面印着“LedTec SIG-5030”。

通过快速的网络搜索，卡拉找到了这些设备的用户手册。原来它们是交通信号灯，配备可编程的琥珀色LED矩阵。人类大概想在活动期间用它们显示信息。有趣的是，这些屏幕可以通过无线网络编程——说不定它们连接着大楼的本地网络？

网络中的每个设备都有一个IP地址，其他设备可以通过地址发送消息（我们将在第13章详细讨论）。卡拉注意到，她偷来的手机IP地址都是类似10.0.0.20或10.0.0.33的格式。或许可以尝试向所有这类地址发送消息，看看是否有设备响应手册中描述的接口。

第18章将介绍如何在真实网络中发起请求，而本章我们先用一个简化的虚拟函数request模拟网络通信。该函数接受两个参数：网络地址和消息（可以是任何能序列化为JSON的内容），返回一个Promise——若目标设备响应则resolve为结果，若出错则reject。

根据手册，要修改SIG-5030的显示内容，需发送形如{"command": "display", "data": [0, 0, 3, …]}的消息，其中data数组的每个数字对应一个LED点的亮度（0为关闭，3为最高亮度）。每个屏幕宽50像素、高30像素，因此一次更新需要发送1500个数字。

以下代码向本地网络的所有地址发送显示更新消息，试图找出目标设备。代码中激活的LED位置与IP地址的最后一位数字相关：

代码实现：用LED矩阵“绘制”IP地址

async function scanAndDisplay() {
  const baseAddress = "10.0.0."; // 假设本地网络为10.0.0.0/24
  const width = 50, height = 30; // 屏幕尺寸

  for (let lastOctet = 0; lastOctet <= 255; lastOctet++) {
    const address = baseAddress + lastOctet;
    const data = new Array(width * height).fill(0); // 初始化全暗

    // 在屏幕底部用LED显示IP最后一位数字（横向绘制）
    const numberString = lastOctet.toString();
    for (let i = 0; i < numberString.length; i++) {
      const charCode = numberString.charCodeAt(i) - 48; // '0'→0, '1'→1...
      for (let x = i * 8; x < i * 8 + 7; x++) { // 每个数字占8像素宽度
        if (x < width && charCode & (1 << (6 - (x % 8)))) { // 7段数码管逻辑
          const y = height - 8 + (x % 8); // 底部8行显示数字
          data[y * width + x] = 3; // 点亮LED
        }
      }
    }

    const message = {
      command: "display",
      data: data
    };

    try {
      const response = await request(address, message);
      console.log(`成功连接到 ${address}，响应：`, response);
      break; // 找到目标设备后停止扫描
    } catch (error) {
      console.log(`无法连接到 ${address}：`, error);
    }
  }
}

// 示例：启动扫描
scanAndDisplay();

代码解析

1. IP地址扫描逻辑：

   • 遍历10.0.0.0到10.0.0.255的所有地址（假设本地网络为C类子网）。
   • 对每个地址生成特定的LED显示数据：在屏幕底部用7段数码管显示IP地址的最后一位（如10.0.0.42会显示42）。

2. LED数据生成：

   • data数组长度为50×30=1500，每个元素对应一个LED的亮度。
   • 通过位运算模拟7段数码管的显示逻辑，将数字转换为对应的LED点亮模式。

3. 网络请求与错误处理：

   • 使用request(address, message)发送JSON消息，若设备响应（如LED屏幕亮起），则打印成功信息并终止扫描。
   • 若请求失败（如地址不可达），则继续尝试下一个地址。

乌鸦的“艺术创作”

卡拉的代码通过LED矩阵将IP地址可视化：当某个设备（如交通信号灯）响应请求时，屏幕会显示对应的IP尾号，形成一种独特的“网络涂鸦”。这种将技术细节转化为视觉符号的方式，既是对人类网络安全的小小挑战，也是一只乌鸦用二进制逻辑创作的极简主义艺术——毕竟，在数据的海洋里，每个IP地址都像是漂浮的星星，而卡拉正在用LED为它们点亮属于自己的坐标。

当然，人类或许永远不会知道，那面突然显示奇怪数字的信号灯，曾是一只乌鸦探索数字世界的画布。 🐦✨

for (let addr = 1; addr < 256; addr++) {
  let data = [];
  for (let n = 0; n < 1500; n++) {
    data.push(n < addr ? 3 : 0);
  }
  let ip = `10.0.0.${addr}`;
  request(ip, {command: "display", data})
    .then(() => console.log(`Request to ${ip} accepted`))
    .catch(() => {});
}

乌鸦的网络探索：LED艺术背后的扫描逻辑

这段代码实现了一个简单而巧妙的网络扫描策略，让我们来分析卡拉的LED艺术创作背后的技术细节：

代码功能解析

for (let addr = 1; addr < 256; addr++) {
  let data = [];
  // 生成1500个LED数据点，前addr个点亮（亮度3），其余熄灭
  for (let n = 0; n < 1500; n++) {
    data.push(n < addr ? 3 : 0);
  }
  let ip = `10.0.0.${addr}`;
  // 向每个IP地址发送显示命令
  request(ip, {command: "display", data})
    .then(() => console.log(`Request to ${ip} accepted`))
    .catch(() => {}); // 忽略失败请求
}

关键技术点

1. IP地址扫描策略：

   • 遍历私有网络地址段 10.0.0.1 到 10.0.0.255
   • 利用常见的C类网络默认子网掩码 255.255.255.0

2. LED显示数据生成：

   • 生成一个长度为1500的数组（对应50×30像素屏幕）
   • 前addr个元素设为3（最高亮度），其余设为0（熄灭）
   • 形成一个随IP地址递增而扩展的点亮区域

3. 异步请求处理：

   • 使用非阻塞的request函数并行发送请求
   • 成功的请求会在控制台记录
   • 失败的请求被静默处理（空的catch块）

视觉效果分析

当扫描到有效IP地址时，LED屏幕会显示：

• 10.0.0.1 → 左上角第一个像素点亮
• 10.0.0.100 → 左上角100个像素形成矩形区域
• 10.0.0.255 → 左上角约1/6的屏幕被点亮

这种设计让卡拉能够直观区分不同IP地址的响应：

10.0.0.1   ⬤□□□□□□□□□□□□□□□□□□□□□□□□□□□□□□□□□□□□□□□
10.0.0.10  ⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤□□□□□□□□□□□□□□□□□□□□□□□□□□□□□
10.0.0.50  ⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤□□□□□□
10.0.0.255 ⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤
             ⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤
             ⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤⬤□

网络安全考量

这种扫描方式的巧妙之处在于：

1. 隐蔽性：通过合法的显示命令进行探测，不易被防火墙拦截
2. 可视化反馈：直接将IP地址映射为物理显示，无需复杂的响应解析
3. 并行探测：异步发送请求，大幅提高扫描效率

不过也存在局限性：

• 依赖弱密码或开放网络接口
• 可能触发网络监控系统的告警
• 只能发现支持特定显示协议的设备

乌鸦的智慧

卡拉通过结合网络知识和硬件特性，创造了一种独特的网络发现机制。这种将抽象IP地址转化为物理光信号的方式，不仅展现了她对人类技术的深刻理解，也体现了动物本能与数字世界的诗意结合——用二进制代码创作的“光绘”艺术，或许是最优雅的黑客行为。

由于大多数此类地址要么不存在，要么不会接受此类消息，catch 调用可确保网络错误不会导致程序崩溃。所有请求都会立即发出，无需等待其他请求完成，这样在某些设备无响应时就不会浪费时间。

启动网络扫描后，卡拉回到外面查看结果。令她高兴的是，所有屏幕的左上角都显示出一道光条。这些设备确实连接在本地网络上，并且接受命令。她迅速记下每个屏幕上显示的数字。共有九个屏幕，排列成三行三列，它们的网络地址如下：

由于大多数地址要么不存在，要么不会接受此类消息，catch 调用确保网络错误不会导致程序崩溃。所有请求都会立即发出，无需等待其他请求完成，这样能避免在某些设备无响应时浪费时间。

启动网络扫描后，卡拉回到外面查看结果。令她高兴的是，所有屏幕的左上角都显示出一道光条。这些设备确实连接在本地网络上，并且接受命令。她迅速记下每个屏幕上显示的数字。共有九个屏幕，排列成三行三列，它们的网络地址如下：

假设的屏幕地址与显示效果（示例）

数据解析与模式发现

卡拉注意到这些IP地址的最后一位数字（addr）与光条长度一致，且存在某种数学规律：

• 第一行：5、12、3 → 可能对应某种序列（如5+3=8，12-8=4？暂时无明显规律）
• 第二行：9、18、6 → 18是9的2倍，6是18的1/3
• 第三行：15、24、10 → 24-15=9，10=24×(5/12)

进一步观察发现，每行数字之间存在比例关系：

第1行：5 × 3 = 15，12 ÷ 4 = 3  → 可能与行号相关（第1行倍数为3？）  
第2行：9 × 2 = 18，18 ÷ 3 = 6  → 第2行倍数为2和3  
第3行：15 × 1.6 = 24，24 ÷ 2.4 = 10  → 规律不明显  

潜在规律：行列乘积模式

假设每个屏幕的IP尾号满足 addr = 行号 × 列号 × 基数，其中基数为常数：

• 第1行（行号1）：列1=1×1×5=5，列2=1×2×6=12，列3=1×3×1=3 → 基数分别为5、6、1（不统一）
• 第2行（行号2）：列1=2×1×4.5=9，列2=2×2×4.5=18，列3=2×3×1=6 → 列2基数一致，其他列不一致

另一种可能：斐波那契数列变形

将数字按行排列为数组：[5,12,3,9,18,6,15,24,10]，尝试分组：

• 前三个数：5, 12, 3 → 5+3=8，12-8=4（无意义）
• 中间三个数：9, 18, 6 → 9×2=18，18÷3=6（倍数关系：2和3）
• 后三个数：15, 24, 10 → 15+9=24，24-14=10（差值无规律）

卡拉的下一步计划

1. 验证设备响应一致性：
   发送不同的data模式（如棋盘格、箭头符号），确认所有屏幕是否支持复杂指令。

2. 构建地址映射表：
   将屏幕物理位置与IP地址绑定，创建二维数组映射：

   const screenGrid = [
     [5, 12, 3],   // 第1行
     [9, 18, 6],   // 第2行
     [15, 24, 10]  // 第3行
   ];
   

3. 探索隐藏功能：
   根据用户手册尝试其他命令（如{"command": "blink", "interval": 500}），观察设备反应。

4. 创作灯光秀：
   利用扫描得到的地址，编写动画逻辑（如逐行点亮、波浪效果），将九个屏幕组合成一个大型显示矩阵。

乌鸦的编程哲学

对卡拉而言，这些闪烁的LED不仅是技术验证的结果，更是她与人类世界对话的媒介。通过数字规律与物理世界的交互，她正在用二进制语言书写属于乌鸦的“诗”——或许下一次，人类会在某个清晨，对着突然出现的灯光矩阵惊呼：“看！这是某种智能的信号！” 而角落里的卡拉，正歪着头观察他们的反应，喙中叼着半块从游客那里“骗”来的三明治，眼中闪烁着狡黠的光。 🐦✨

屏幕地址分析与矩阵规律探索

卡拉记录的九个屏幕IP地址如下（按三行三列排列）：

const screenAddresses = [
  "10.0.0.44", "10.0.0.45", "10.0.0.41",  // 第一行
  "10.0.0.31", "10.0.0.40", "10.0.0.42",  // 第二行
  "10.0.0.48", "10.0.0.47", "10.0.0.46"   // 第三行
];

提取IP地址的最后一位数字，得到矩阵：

[44, 45, 41]  
[31, 40, 42]  
[48, 47, 46]  

一、数值模式分析

1. 行内规律

• 第一行：44, 45, 41

  • 差值：45-44=1，41-45=-4 → 无明显等差/等比关系。
  • 可能与字母ASCII码相关：44=','，45='-'，41=')' → 符号无意义。

• 第二行：31, 40, 42

  • 差值：40-31=9，42-40=2 → 无规律。
  • 31是质数，40=5×8，42=6×7 → 因数分解无共性。

• 第三行：48, 47, 46

  • 差值：47-48=-1，46-47=-1 → 等差数列，公差为-1！
  • 48=0×10+8，47=0×10+7，46=0×10+6 → 个位递减。

2. 列间规律

• 第一列：44, 31, 48
  • 44-31=13，48-31=17 → 质数差值。
• 第二列：45, 40, 47
  • 45-40=5，47-40=7 → 质数差值。
• 第三列：41, 42, 46
  • 42-41=1，46-42=4 → 平方数差值（1=1²，4=2²）。

3. 整体规律

• 行与列的交叉点：
  观察第三行的递减规律（48→47→46），推测其他行可能隐藏类似模式，例如第一行可能是 44→45→46，但第三个数字为41（而非46），存在矛盾。
• 特殊数值：
  • 31是矩阵中唯一小于40的数，可能是设备编号或手动配置的地址。
  • 40是常见的“终止符”数值（如Unix文件描述符），可能具有特殊含义。

二、潜在的矩阵逻辑

1. 纠错码矩阵

假设矩阵为某种纠错码（如汉明码）的校验矩阵：

• 第三行的等差序列可能是校验位，其他行是数据位。
• 但缺少校验规则，无法验证。

2. 坐标映射

将矩阵视为二维坐标，行号（1-3）和列号（1-3）对应IP尾号的十位和个位：

• 第一行（行号1）：十位为4 → 4x
  • 列1: 44 → 行1×列1=1×1=1 → 4+1=5？无关联。
• 第二行（行号2）：十位为3和4 → 无规律。
• 第三行（行号3）：十位为4 → 4x
  • 列1: 48 → 3×1=3 → 4+3=7？不匹配。

3. ASCII艺术预演

将数字视为LED矩阵的点亮位置（假设每个屏幕是50×30像素）：

• 例如IP尾号44可能对应左上角44个像素点亮，形成特定图案（如字母“C”的轮廓）。
• 需结合LED排列方式（横向或纵向）进一步分析。