使用Scala构建JSON解析器及TwitterAPI解析应用

### 使用 Scala 构建 JSON 解析器及 Twitter API 解析应用 #### 1. 从 BNF 到运行中的应用 在之前简单的四则计算器示例基础上，我们将着手处理更复杂的任务——解析 JSON。JSON（JavaScript Object Notation）是一种在互联网上交换数据的常见且轻量级的机制。它是 JavaScript 的子集，可被浏览器内置的快速、稳定且高效的 JavaScript 解析器解析。JSON 具有与 XML 相当的可读性，比 XML 更紧凑，并且对应于大多数动态语言中的内置类型，如字符串、数字、布尔值、数组和字典或哈希映射。 #### 2. 构建 JSON 解析器 我们将遵循 ECMAScript 规范来构建 JSON 解析器。在这个解析器中，唯一的新概念是正则表达式解析器。`RegexParsers` 特质提供了从正则表达式到 `Parser[String]` 的隐式转换。例如，在定义空格时，我们使用了 `"""\\s*""".r`。 以下是创建 JSON 解析器的代码： ```scala import scala.util.parsing.combinator._ object JSON extends RegexParsers with RunParser { // 从 ECMAScript 规范翻译而来 // http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-262.pdf /* 空格 */ lazy val spaces: Parser[String] = """\s*""".r /* 源字符（任何有效的 Unicode 字符） */ lazy val sourceCharacter: Parser[Char] = elem("Source Character", c => true) /* 十六进制数字 :: 以下之一 0 1 2 3 4 5 6 7 8 9 a b c d e f A B C D E F */ lazy val hexDigit: Parser[Char] = elem("Hex Digit", c => ((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F'))) /* 7.8 字面量 语法 字面量 :: 空字面量 布尔字面量 数字字面量 字符串字面量 */ lazy val literal: Parser[Any] = nullLiteral | booleanLiteral | numericLiteral | stringLiteral /* 7.8.1 空字面量 语法 空字面量 :: null */ lazy val nullLiteral: Parser[Any] = spaces ~ "null" ~ spaces ^^^ None /* 7.8.2 布尔字面量 语法 布尔字面量 :: true false */ lazy val booleanLiteral: Parser[Boolean] = spaces ~> ("true" ^^^ true | "false" ^^^ false) <~ spaces /* 7.8.3 数字字面量 语法 数字字面量 :: 十进制字面量 十六进制整数字面量 */ lazy val numericLiteral: Parser[Double] = spaces ~> (hexIntegerLiteral | decimalLiteral) <~ spaces /* 十进制字面量 :: 十进制整数字面量 . 十进制数字（可选）指数部分（可选） . 十进制数字 指数部分（可选） 十进制整数字面量 指数部分（可选） */ lazy val decimalLiteral: Parser[Double] = (decimalIntegerLiteral ~ '.' ~ opt(decimalDigits) ~ opt(exponentPart)) ^^ {case lit ~ _ ~ frac ~ optExp => val d: Double = frac.map(f => (lit.toString + "." + f.mkString).toDouble) getOrElse lit.toDouble optExp.map(_(d)) getOrElse d } | '.' ~> decimalDigits ~ opt(exponentPart) ^^ { case dd ~ optExp => val d = ("." + dd.mkString).toDouble optExp.map(_(d)) getOrElse d } | decimalIntegerLiteral ~ opt(exponentPart) ^^ { case dd ~ optExp => optExp.map(_(dd)) getOrElse dd } /* 十进制整数字面量 :: 0 非零数字 十进制数字（可选） */ lazy val decimalIntegerLiteral: Parser[Long] = '0' ^^^ 0L | nonZeroDigit ~ opt(decimalDigits) ^^ { case first ~ rest => (first :: (rest getOrElse Nil)).mkString.toLong } /* 十进制数字 :: 十进制数字 十进制数字 十进制数字 */ lazy val decimalDigits: Parser[List[Char]] = rep1(decimalDigit) /* 十进制数字 :: 以下之一 0 1 2 3 4 5 6 7 8 9 */ lazy val decimalDigit = elem("Decimal Digit", c => c >= '0' && c <= '9') /* 非零数字 :: 以下之一 1 2 3 4 5 6 7 8 9 */ lazy val nonZeroDigit = elem("Non-zero Digit", c => c >= '1' && c <= '9') /* 指数部分 :: 指数指示符 有符号整数 */ lazy val exponentPart: Parser[Double => Double] = exponentIndicator ~> signedInteger ^^ { si => n => n.doubleValue * Math.pow(10.0, si.doubleValue) } /* 指数指示符 :: 以下之一 e E */ lazy val exponentIndicator = elem("exp ind", c => c == 'e' || c == 'E') /* 有符号整数 :: 十进制数字 + 十进制数字 - 十进制数字 */ lazy val signedInteger: Parser[Long] = decimalDigits ^^ (_.mkString.toLong) | '+' ~> decimalDigits ^^ (_.mkString.toLong) | '-' ~> decimalDigits ^^ (_.mkString.toLong * -1L) /* 十六进制整数字面量 :: 0x 十六进制数字 0X 十六进制数字 十六进制整数字面量 十六进制数字 */ lazy val hexIntegerLiteral: Parser[Double] = (elem('0') ~ (elem('x') | 'X')) ~> rep1(hexDigit) ^^ (s => java.lang.Long.parseLong(s.mkString, 16).toDouble) /* 7.8.4 字符串字面量 字符串字面量是由单引号或双引号括起来的零个或多个字符。 每个字符可以由转义序列表示。 语法 字符串字面量 :: " 双字符串字符（可选） " ' 单字符串字符（可选） ' */ lazy val stringLiteral: Parser[String] = '"' ~> opt(doubleStringCharacters) <~ '"' ^^ (_ getOrElse "") | '\'' ~> opt(singleStringCharacters) <~ '\'' ^^ (_ getOrElse "") /* 双字符串字符 :: 双字符串字符 双字符串字符（可选） */ lazy val doubleStringCharacters: Parser[String] = rep1(doubleStringCharacter) ^^ (_.mkString) /* 单字符串字符 :: 单字符串字符 单字符串字符（可选） */ lazy val singleStringCharacters: Parser[String] = rep1(singleStringCharacter) ^^ (_.mkString) /* 双字符串字符 :: 源字符，但不是双引号 " 或反斜杠 \ 或行终止符 \ 转义序列 */ lazy val doubleStringCharacter: Parser[Char] = ('\\' ~> escapeSequence) | ((not('"') ~ not('\\') ~ not(lineTerminator)) ~> sourceCharacter) /* 行终止符 :: <LF> <CR> <LS> <PS> */ lazy val lineTerminator = elem("Line Terminator", c => (c == '\r' || c == '\n' || c == '\u2028' || c == '\u2029')) /* 单字符串字符 :: 源字符，但不是单引号 ' 或反斜杠 \ 或行终止符 \ 转义序列 */ lazy val singleStringCharacter: Parser[Char] = ('\\' ~> escapeSeque ```