加载中...

Scala

其中 Y=Scala

源代码下载： learnscala-zh.scala

Scala - 一门可拓展的语言

  1. /*
  2.   自行设置:
  4.   1) 下载 Scala - http://www.scala-lang.org/downloads
  5.   2) unzip/untar 到您喜欢的地方，并把 bin 子目录添加到 path 环境变量
  6.   3) 在终端输入 scala，启动 Scala 的 REPL，您会看到提示符：
  8.   scala>
  10.   这就是所谓的 REPL (读取-求值-输出循环，英语： Read-Eval-Print Loop)，
  11.   您可以在其中输入合法的表达式，结果会被打印。
  12.   在教程中我们会进一步解释 Scala 文件是怎样的，但现在先了解一点基础。
  13. */
  15. /////////////////////////////////////////////////
  16. // 1\. 基础
  17. /////////////////////////////////////////////////
  19. //  单行注释开始于两个斜杠
  21. /*
  22.   多行注释，如您之前所见，看起来像这样
  23. */
  25. // 打印并强制换行
  26. println("Hello world!")
  27. println(10)
  29. // 没有强制换行的打印
  30. print("Hello world")
  32. // 通过 var 或者 val 来声明变量
  33. // val 声明是不可变的，var 声明是可修改的。不可变性是好事。
  34. val x = 10 // x 现在是 10
  35. x = 20 // 错误: 对 val 声明的变量重新赋值
  36. var y = 10 
  37. y = 20  // y 现在是 20
  39. /*
  40.   Scala 是静态语言，但注意上面的声明方式，我们没有指定类型。
  41.   这是因为类型推导的语言特性。大多数情况， Scala 编译器可以推测变量的类型，
  42.   所以您不需要每次都输入。可以像这样明确声明变量类型：
  43. */
  44. val z: Int = 10
  45. val a: Double = 1.0
  47. // 注意从 Int 到 Double 的自动转型，结果是 10.0, 不是 10
  48. val b: Double = 10
  50. // 布尔值
  51. true
  52. false
  54. // 布尔操作
  55. !true // false
  56. !false // true
  57. true == false // false
  58. 10 > 5 // true
  60. // 数学运算像平常一样
  61. 1 + 1 // 2
  62. 2 - 1 // 1
  63. 5 * 3 // 15
  64. 6 / 2 // 3
  65. 6 / 4 // 1
  66. 6.0 / 4 // 1.5
  68. // 在 REPL 计算一个表达式会返回给您结果的类型和值
  70. 1 + 7
  72. /* 上行的结果是：
  74.   scala> 1 + 7
  75.   res29: Int = 8
  77.   这意味着计算 1 + 7 的结果是一个 Int 类型的对象，其值为 8
  79.   注意 "res29" 是一个连续生成的变量名，用以存储您输入的表达式结果，
  80.   您看到的输出可能不一样。
  81. */
  83. "Scala strings are surrounded by double quotes"
  84. 'a' // Scala 的字符
  85. // '不存在单引号字符串' <= 这会导致错误
  87. // String 有常见的 Java 字符串方法
  88. "hello world".length
  89. "hello world".substring(2, 6)
  90. "hello world".replace("C", "3")
  92. // 也有一些额外的 Scala 方法，另请参见：scala.collection.immutable.StringOps
  93. "hello world".take(5)
  94. "hello world".drop(5)
  96. // 字符串改写：留意前缀 "s"
  97. val n = 45
  98. s"We have $n apples" // => "We have 45 apples"
  100. // 在要改写的字符串中使用表达式也是可以的
  101. val a = Array(11, 9, 6)
  102. s"My second daughter is ${a(0) - a(2)} years old." // => "My second daughter is 5 years old."
  103. s"We have double the amount of ${n / 2.0} in apples." // => "We have double the amount of 22.5 in apples."
  104. s"Power of 2: ${math.pow(2, 2)}" // => "Power of 2: 4"
  106. // 添加 "f" 前缀对要改写的字符串进行格式化
  107. f"Power of 5: ${math.pow(5, 2)}%1.0f" // "Power of 5: 25"
  108. f"Square root of 122: ${math.sqrt(122)}%1.4f" // "Square root of 122: 11.0454"
  110. // 未处理的字符串，忽略特殊字符。
  111. raw"New line feed: \n. Carriage return: \r." // => "New line feed: \n. Carriage return: \r."
  113. // 一些字符需要转义，比如字符串中的双引号
  114. "They stood outside the \"Rose and Crown\"" // => "They stood outside the "Rose and Crown""
  116. // 三个双引号可以使字符串跨越多行，并包含引号
  117. val html = """<form id="daform">
  118.                 <p>Press belo', Joe</p>
  119.                 <input type="submit">
  120.               </form>"""
  122. /////////////////////////////////////////////////
  123. // 2\. 函数
  124. /////////////////////////////////////////////////
  126. // 函数可以这样定义:
  127. //
  128. //   def functionName(args...): ReturnType = { body... }
  129. //
  130. // 如果您以前学习过传统的编程语言，注意 return 关键字的省略。
  131. // 在 Scala 中， 函数代码块最后一条表达式就是返回值。
  132. def sumOfSquares(x: Int, y: Int): Int = {
  133.   val x2 = x * x
  134.   val y2 = y * y
  135.   x2 + y2
  136. }
  138. // 如果函数体是单行表达式，{ } 可以省略：
  139. def sumOfSquaresShort(x: Int, y: Int): Int = x * x + y * y
  141. // 函数调用的语法是熟知的：
  142. sumOfSquares(3, 4)  // => 25
  144. // 在多数情况下 (递归函数是需要注意的例外), 函数返回值可以省略，
  145. // 变量所用的类型推导一样会应用到函数返回值中：
  146. def sq(x: Int) = x * x  // 编译器会推断得知返回值是 Int
  148. // 函数可以有默认参数
  149. def addWithDefault(x: Int, y: Int = 5) = x + y
  150. addWithDefault(1, 2)  // => 3
  151. addWithDefault(1)  // => 6
  153. // 匿名函数是这样的：
  154. (x:Int) => x * x
  156. // 和 def 不同，如果语义清晰，匿名函数的参数类型也可以省略。
  157. // 类型 "Int => Int" 意味着这个函数接收一个 Int 并返回一个 Int。
  158. val sq: Int => Int = x => x * x
  160. // 匿名函数的调用也是类似的：
  161. sq(10)   // => 100
  163. // 如果您的匿名函数中每个参数仅使用一次，
  164. // Scala 提供一个更简洁的方式来定义他们。这样的匿名函数极为常见，
  165. // 在数据结构部分会明显可见。
  166. val addOne: Int => Int = _ + 1
  167. val weirdSum: (Int, Int) => Int = (_ * 2 + _ * 3)
  169. addOne(5)  // => 6
  170. weirdSum(2, 4)  // => 16
  172. // return 关键字是存在的，但它只从最里面包裹了 return 的 def 函数中返回。
  173. // 警告： 在 Scala 中使用 return 容易出错，应该避免使用。
  174. // 在匿名函数中没有效果，例如：
  175. def foo(x: Int): Int = {
  176.   val anonFunc: Int => Int = { z =>
  177.     if (z > 5)
  178.       return z  // 这一行令 z 成为 foo 函数的返回值！
  179.     else
  180.       z + 2  // 这一行是 anonFunc 函数的返回值
  181.   }
  182.   anonFunc(x)  // 这一行是 foo 函数的返回值
  183. }
  185. /*
  186.  * 译者注：此处是指匿名函数中的 return z 成为最后执行的语句，
  187.  *    在 anonFunc(x) 下面的表达式（假设存在）不再执行。如果 anonFunc
  188.  *    是用 def 定义的函数， return z 仅返回到 anonFunc(x) ，
  189.  *    在 anonFunc(x) 下面的表达式（假设存在）会继续执行。
  190.  */
  192. /////////////////////////////////////////////////
  193. // 3\. 控制语句
  194. /////////////////////////////////////////////////
  196. 1 to 5
  197. val r = 1 to 5
  198. r.foreach( println )
  200. r foreach println
  201. // 附注： Scala 对点和括号的要求想当宽松，注意其规则是不同的。
  202. // 这有助于写出读起来像英语的 DSL(领域特定语言) 和 API(应用编程接口)。
  204. (5 to 1 by -1) foreach ( println )
  206. // while 循环
  207. var i = 0
  208. while (i < 10) {  println("i " + i); i+=1  }
  210. while (i < 10) {  println("i " + i); i+=1  }   // 没错，再执行一次，发生了什么？为什么？
  212. i    // 显示 i 的值。注意 while 是经典的循环方式，它连续执行并改变循环中的变量。
  213.      // while 执行很快，比 Java 的循环快，但像上面所看到的那样用组合子和推导式
  214.      // 更易于理解和并行化。
  216. // do while 循环
  217. do {
  218.   println("x is still less than 10");
  219.   x += 1
  220. } while (x < 10)
  222. // Scala 中尾递归是一种符合语言习惯的递归方式。
  223. // 递归函数需要清晰的返回类型，编译器不能推断得知。
  224. // 这是一个 Unit。
  225. def showNumbersInRange(a:Int, b:Int):Unit = {
  226.   print(a)
  227.   if (a < b)
  228.     showNumbersInRange(a + 1, b)
  229. }
  230. showNumbersInRange(1,14)
  232. // 条件语句
  234. val x = 10
  236. if (x == 1) println("yeah")
  237. if (x == 10) println("yeah")
  238. if (x == 11) println("yeah")
  239. if (x == 11) println ("yeah") else println("nay")
  241. println(if (x == 10) "yeah" else "nope")
  242. val text = if (x == 10) "yeah" else "nope"
  244. /////////////////////////////////////////////////
  245. // 4\. 数据结构
  246. /////////////////////////////////////////////////
  248. val a = Array(1, 2, 3, 5, 8, 13)
  249. a(0)
  250. a(3)
  251. a(21)    // 抛出异常
  253. val m = Map("fork" -> "tenedor", "spoon" -> "cuchara", "knife" -> "cuchillo")
  254. m("fork")
  255. m("spoon")
  256. m("bottle")       // 抛出异常
  258. val safeM = m.withDefaultValue("no lo se")
  259. safeM("bottle")
  261. val s = Set(1, 3, 7)
  262. s(0)
  263. s(1)
  265. /* 这里查看 map 的文档 -
  266.  * http://www.scala-lang.org/api/current/index.html#scala.collection.immutable.Map
  267.  * 并确保你会阅读
  268.  */
  270. // 元组
  272. (1, 2)
  274. (4, 3, 2)
  276. (1, 2, "three")
  278. (a, 2, "three")
  280. // 为什么有这个？
  281. val divideInts = (x:Int, y:Int) => (x / y, x % y)
  283. divideInts(10,3) // 函数 divideInts 同时返回结果和余数
  285. // 要读取元组的元素，使用 _._n，n是从1开始的元素索引
  286. val d = divideInts(10,3)
  288. d._1
  290. d._2
  292. /////////////////////////////////////////////////
  293. // 5\. 面向对象编程
  294. /////////////////////////////////////////////////
  296. /*
  297.   旁白: 教程中到现在为止我们所做的一切只是简单的表达式（值，函数等）。
  298.   这些表达式可以输入到命令行解释器中作为快速测试，但它们不能独立存在于 Scala 
  299.   文件。举个例子，您不能在 Scala 文件上简单的写上 "val x = 5"。相反 Scala 文件
  300.   允许的顶级结构是：
  302.   - objects
  303.   - classes
  304.   - case classes
  305.   - traits
  307.   现在来解释这些是什么。
  308. */
  310. // 类和其他语言的类相似，构造器参数在类名后声明，初始化在类结构体中完成。
  311. class Dog(br: String) {
  312.   // 构造器代码在此
  313.   var breed: String = br
  315.   // 定义名为 bark 的方法，返回字符串
  316.   def bark = "Woof, woof!"
  318.   // 值和方法作用域假定为 public。"protected" 和 "private" 关键字也是可用的。
  319.   private def sleep(hours: Int) =
  320.     println(s"I'm sleeping for $hours hours")
  322.   // 抽象方法是没有方法体的方法。如果取消下面那行注释，Dog 类必须被声明为 abstract
  323.   //   abstract class Dog(...) { ... }
  324.   // def chaseAfter(what: String): String
  325. }
  327. val mydog = new Dog("greyhound")
  328. println(mydog.breed) // => "greyhound"
  329. println(mydog.bark) // => "Woof, woof!"
  331. // "object" 关键字创造一种类型和该类型的单例。
  332. // Scala 的 class 常常也含有一个 “伴生对象”，class 中包含每个实例的行为，所有实例
  333. // 共用的行为则放入 object 中。两者的区别和其他语言中类方法和静态方法类似。
  334. // 请注意 object 和 class 可以同名。
  335. object Dog {
  336.   def allKnownBreeds = List("pitbull", "shepherd", "retriever")
  337.   def createDog(breed: String) = new Dog(breed)
  338. }
  340. // Case 类是有额外内建功能的类。Scala 初学者常遇到的问题之一便是何时用类
  341. // 和何时用 case 类。界线比较模糊，但通常类倾向于封装，多态和行为。类中的值
  342. // 的作用域一般为 private ， 只有方向是暴露的。case 类的主要目的是放置不可变
  343. // 数据。它们通常只有几个方法，且方法几乎没有副作用。
  344. case class Person(name: String, phoneNumber: String)
  346. // 创造新实例，注意 case 类不需要使用 "new" 关键字
  347. val george = Person("George", "1234")
  348. val kate = Person("Kate", "4567")
  350. // 使用 case 类，您可以轻松得到一些功能，像 getters:
  351. george.phoneNumber  // => "1234"
  353. // 每个字段的相等性比较（无需覆盖 .equals）
  354. Person("George", "1234") == Person("Kate", "1236")  // => false
  356. // 简单的拷贝方式
  357. // otherGeorge == Person("george", "9876")
  358. val otherGeorge = george.copy(phoneNumber = "9876")
  360. // 还有很多。case 类同时可以用于模式匹配，接下来会看到。
  362. // 敬请期待 Traits ！
  364. /////////////////////////////////////////////////
  365. // 6\. 模式匹配
  366. /////////////////////////////////////////////////
  368. // 模式匹配是一个强大和常用的 Scala 特性。这是用模式匹配一个 case 类的例子。
  369. // 附注：不像其他语言， Scala 的 case 不需要 break， 其他语言中 switch 语句的
  370. // fall-through 现象不会发生。
  372. def matchPerson(person: Person): String = person match {
  373.   // Then you specify the patterns:
  374.   case Person("George", number) => "We found George! His number is " + number
  375.   case Person("Kate", number) => "We found Kate! Her number is " + number
  376.   case Person(name, number) => "We matched someone : " + name + ", phone : " + number
  377. }
  379. val email = "(.*)@(.*)".r  // 定义下一个例子会用到的正则
  381. // 模式匹配看起来和 C语言家族的 switch 语句相似，但更为强大。
  382. // Scala 中您可以匹配很多东西：
  383. def matchEverything(obj: Any): String = obj match {
  384.   // 匹配值：
  385.   case "Hello world" => "Got the string Hello world"
  387.   // 匹配类型：
  388.   case x: Double => "Got a Double: " + x
  390.   // 匹配时指定条件
  391.   case x: Int if x > 10000 => "Got a pretty big number!"
  393.   // 像之前一样匹配 case 类：
  394.   case Person(name, number) => s"Got contact info for $name!"
  396.   // 匹配正则表达式：
  397.   case email(name, domain) => s"Got email address $name@$domain"
  399.   // 匹配元组：
  400.   case (a: Int, b: Double, c: String) => s"Got a tuple: $a, $b, $c"
  402.   // 匹配数据结构：
  403.   case List(1, b, c) => s"Got a list with three elements and starts with 1: 1, $b, $c"
  405.   // 模式可以嵌套
  406.   case List(List((1, 2,"YAY"))) => "Got a list of list of tuple"
  407. }
  409. // 事实上，你可以对任何有 "unapply" 方法的对象进行模式匹配。
  410. // 这个特性如此强大以致于 Scala 允许定义一个函数作为模式匹配：
  411. val patternFunc: Person => String = {
  412.   case Person("George", number) => s"George's number: $number"
  413.   case Person(name, number) => s"Random person's number: $number"
  414. }
  416. /////////////////////////////////////////////////
  417. // 7\. 函数式编程
  418. /////////////////////////////////////////////////
  420. // Scala 允许方法和函数作为其他方法和函数的参数和返回值。
  422. val add10: Int => Int = _ + 10 // 一个接受一个 Int 类型参数并返回一个 Int 类型值的函数
  423. List(1, 2, 3) map add10 // List(11, 12, 13) - add10 被应用到每一个元素
  425. // 匿名函数可以被使用来代替有命名的函数：
  426. List(1, 2, 3) map (x => x + 10)
  428. // 如果匿名函数只有一个参数可以用下划线作为变量
  429. List(1, 2, 3) map (_ + 10)
  431. // 如果您所应用的匿名块和匿名函数都接受一个参数，那么你甚至可以省略下划线
  432. List("Dom", "Bob", "Natalia") foreach println
  434. // 组合子
  436. // 译注: val sq: Int => Int = x => x * x
  437. s.map(sq)
  439. val sSquared = s. map(sq)
  441. sSquared.filter(_ < 10)
  443. sSquared.reduce (_+_)
  445. // filter 函数接受一个 predicate （函数根据条件 A 返回 Boolean）并选择
  446. // 所有满足 predicate 的元素
  447. List(1, 2, 3) filter (_ > 2) // List(3)
  448. case class Person(name:String, age:Int)
  449. List(
  450.   Person(name = "Dom", age = 23),
  451.   Person(name = "Bob", age = 30)
  452. ).filter(_.age > 25) // List(Person("Bob", 30))
  454. // Scala 的 foreach 方法定义在某些集合中，接受一个函数并返回 Unit （void 方法）
  455. // 另请参见：
  456. // http://www.scala-lang.org/api/current/index.html#scala.collection.IterableLike@foreach(f:A=>Unit):Unit
  457. val aListOfNumbers = List(1, 2, 3, 4, 10, 20, 100)
  458. aListOfNumbers foreach (x => println(x))
  459. aListOfNumbers foreach println
  461. // For 推导式
  463. for { n <- s } yield sq(n)
  465. val nSquared2 = for { n <- s } yield sq(n)
  467. for { n <- nSquared2 if n < 10 } yield n
  469. for { n <- s; nSquared = n * n if nSquared < 10} yield nSquared
  471. /* 注意，这些不是 for 循环，for 循环的语义是‘重复’，然而 for 推导式定义
  472.    两个数据集合的关系。 */
  474. /////////////////////////////////////////////////
  475. // 8\. 隐式转换
  476. /////////////////////////////////////////////////
  478. /* 警告 警告: 隐式转换是 Scala 中一套强大的特性，因此容易被滥用。
  479.  * Scala 初学者在理解它们的工作原理和最佳实践之前，应抵制使用它的诱惑。
  480.  * 我们加入这一章节仅因为它们在 Scala 的库中太过常见，导致没有用隐式转换的库
  481.  * 就不可能做有意义的事情。这章节主要让你理解和使用隐式转换，而不是自己声明。
  482.  */
  484. // 可以通过 "implicit" 声明任何值（val, 函数，对象等）为隐式值，
  485. // 请注意这些例子中，我们用到第5部分的 Dog 类。
  486. implicit val myImplicitInt = 100
  487. implicit def myImplicitFunction(breed: String) = new Dog("Golden " + breed)
  489. // implicit 关键字本身不改变值的行为，所以上面的值可以照常使用。
  490. myImplicitInt + 2  // => 102
  491. myImplicitFunction("Pitbull").breed  // => "Golden Pitbull"
  493. // 区别在于，当另一段代码“需要”隐式值时，这些值现在有资格作为隐式值。
  494. // 一种情况是隐式函数参数。
  495. def sendGreetings(toWhom: String)(implicit howMany: Int) =
  496.   s"Hello $toWhom, $howMany blessings to you and yours!"
  498. // 如果提供值给 “howMany”，函数正常运行
  499. sendGreetings("John")(1000)  // => "Hello John, 1000 blessings to you and yours!"
  501. // 如果省略隐式参数，会传一个和参数类型相同的隐式值，
  502. // 在这个例子中， 是 “myImplicitInt":
  503. sendGreetings("Jane")  // => "Hello Jane, 100 blessings to you and yours!"
  505. // 隐式的函数参数使我们可以模拟其他函数式语言的 type 类（type classes）。
  506. // 它经常被用到所以有特定的简写。这两行代码是一样的：
  507. def foo[T](implicit c: C[T]) = ...
  508. def foo[T : C] = ...
  510. // 编译器寻找隐式值另一种情况是你调用方法时
  511. //   obj.method(...)
  512. // 但 "obj" 没有一个名为 "method" 的方法。这样的话，如果有一个参数类型为 A
  513. // 返回值类型为 B 的隐式转换，obj 的类型是 A，B 有一个方法叫 "method" ，这样
  514. // 转换就会被应用。所以作用域里有上面的 myImplicitFunction, 我们可以这样做：
  515. "Retriever".breed  // => "Golden Retriever"
  516. "Sheperd".bark  // => "Woof, woof!"
  518. // 这里字符串先被上面的函数转换为 Dog 对象，然后调用相应的方法。
  519. // 这是相当强大的特性，但再次提醒，请勿轻率使用。
  520. // 事实上，当你定义上面的隐式函数时，编译器会作出警告，除非你真的了解
  521. // 你正在做什么否则不要使用。
  523. /////////////////////////////////////////////////
  524. // 9\. 杂项
  525. /////////////////////////////////////////////////
  527. // 导入类
  528. import scala.collection.immutable.List
  530. // 导入所有子包
  531. import scala.collection.immutable._
  533. // 一条语句导入多个类
  534. import scala.collection.immutable.{List, Map}
  536. // 使用 ‘=>’ 对导入进行重命名
  537. import scala.collection.immutable.{ List => ImmutableList }
  539. // 导入所有类，排除其中一些。下面的语句排除了 Map 和 Set：
  540. import scala.collection.immutable.{Map => _, Set => _, _}
  542. // 在 Scala 文件用 object 和单一的 main 方法定义程序入口：
  543. object Application {
  544.   def main(args: Array[String]): Unit = {
  545.     // stuff goes here.
  546.   }
  547. }
  549. // 文件可以包含多个 class 和 object，用 scalac 编译源文件
  551. // 输入和输出
  553. // 按行读文件
  554. import scala.io.Source
  555. for(line <- Source.fromFile("myfile.txt").getLines())
  556.   println(line)
  558. // 用 Java 的 PrintWriter 写文件
  559. val writer = new PrintWriter("myfile.txt")
  560. writer.write("Writing line for line" + util.Properties.lineSeparator)
  561. writer.write("Another line here" + util.Properties.lineSeparator)
  562. writer.close()

更多的资源

为没耐心的人准备的 Scala

Twitter Scala school

The Scala documentation

在浏览器尝试 Scala

加入 Scala 用户组

还没有评论.