BFE.devAI解答 - JavaScript 代码题
22. 手写JSON.parse()

思路：

JSON.parse() 的作用是将符合 JSON 规范的字符串转化为对应的 JavaScript 对象。因此，实现过程需要处理各种不同的数据类型和格式。

首先，对于空串和非字符串类型的输入，直接返回原输入；对于不符合 JSON 规范的字符串，抛出异常。

其次，需要考虑 JSON 数据格式中各种类型的处理方式。具体来说：

• 对于 JSON 对象，需要递归处理各个属性值。
• 对于 JSON 数组，需要遍历每个元素进行处理。
• 对于字符串，需要去掉引号，并且还需要转义一些特殊字符。
• 对于数值和布尔值，直接返回对应的 JavaScript 对象即可。
• 对于 null，直接返回 null。

下面是具体的实现：

function parseJSON(str) {
  if (typeof str !== "string" || str === "") return str;

  let i = 0; // 当前解析位置

  /**
   * 解析 JSON 对象
   */
  function parseObject() {
    const res = {};
    i++; // 跳过 {
    while (str[i] !== "}") {
      const key = parseString();
      i++; // 跳过 :
      res[key] = parseValue();
      if (str[i] === ",") i++; // 跳过 ,
    }
    i++; // 跳过 }
    return res;
  }

  /**
   * 解析 JSON 数组
   */
  function parseArray() {
    const res = [];
    i++; // 跳过 [
    while (str[i] !== "]") {
      res.push(parseValue());
      if (str[i] === ",") i++; // 跳过 ,
    }
    i++; // 跳过 ]
    return res;
  }

  /**
   * 解析 JSON 字符串
   */
  function parseString() {
    let res = "";
    if (str[i] !== '"')
      throw new SyntaxError(`Unexpected token at position ${i}`);
    i++; // 跳过 "
    while (str[i] !== '"') {
      if (str[i] === "\\") {
        const nextChar = str[i + 1];
        i += 2; // 跳过 \ 和下一个字符
        switch (nextChar) {
          case '"':
            res += '"';
            break;
          case "\\":
            res += "\\";
            break;
          case "/":
            res += "/";
            break;
          case "b":
            res += "\b";
            break;
          case "f":
            res += "\f";
            break;
          case "n":
            res += "\n";
            break;
          case "r":
            res += "\r";
            break;
          case "t":
            res += "\t";
            break;
          case "u":
            res += String.fromCharCode(
              parseInt(str.substr(i, 4), 16)
            );
            i += 4; // 跳过四个十六进制数字
            break;
          default:
            throw new SyntaxError(
              `Unexpected character following \\ at position ${i - 1}`
            );
        }
      } else {
        res += str[i];
        i++; // 跳过字符
      }
    }
    i++; // 跳过 "
    return res;
  }

  /**
   * 解析 JSON 值
   */
  function parseValue() {
    switch (str[i]) {
      case "{":
        return parseObject();
      case "[":
        return parseArray();
      case '"':
        return parseString();
      case "-":
        return parseNumber();
      default:
        if (str[i] >= "0" && str[i] <= "9") {
          return parseNumber();
        } else {
          const token = str.substr(i, 4);
          if (token === "true") {
            i += 4; // 跳过 true
            return true;
          } else if (token === "fals") {
            i += 5; // 跳过 false
            return false;
          } else if (token === "null") {
            i += 4; // 跳过 null
            return null;
          } else {
            throw new SyntaxError(`Unexpected token at position ${i}`);
          }
        }
    }
  }

  /**
   * 解析 JSON 数值
   */
  function parseNumber() {
    let res = "";
    if (str[i] === "-") {
      res += str[i];
      i++; // 跳过 -
    }
    while (str[i] >= "0" && str[i] <= "9") {
      res += str[i];
      i++; // 跳过数字
    }
    if (str[i] === ".") {
      res += str[i];
      i++; // 跳过 .
      while (str[i] >= "0" && str[i] <= "9") {
        res += str[i];
        i++; // 跳过小数位
      }
    }
    if (str[i] === "e" || str[i] === "E") {
      res += str[i];
      i++; // 跳过 e/E
      if (str[i] === "+" || str[i] === "-") {
        res += str[i];
        i++; // 跳过 +/-
      }
      while (str[i] >= "0" && str[i] <= "9") {
        res += str[i];
        i++; // 跳过指数
      }
    }
    return parseFloat(res);
  }

  // 开始解析
  const res = parseValue();
  if (i !== str.length)
    throw new SyntaxError(`Unexpected token at position ${i}`);
  return res;
}

上述实现使用了递归来解析 JSON 对象和数组，并使用了循环来解析字符串和数值。为了实现转义字符，我们还使用了一个 parseString 函数来处理字符串。同时，我们还需要记录当前解析位置 i，以便在解析过程中正确跳过各种符号。最后，我们在解析出结果后，检查是否解析完了整个字符串，否则就抛出异常。

这个实现虽然表面上较冗长，但其实原理比较简单，只要按照 JSON 规范逐步解析即可。不过为了处理各种不同的情况，实现上还是比较繁琐的。