Programming Scala

是 否 +2 论坛币

k人 参与回答

经管之家送您一份

应届毕业生专属福利!

求职就业群

赵安豆老师微信：zhaoandou666

经管之家联合CDA

送您一个全额奖学金名额~ !

立即领取

感谢您参与论坛问题回答

经管之家送您两个论坛币！

+2 论坛币

Programming Scala

Scalability = Functional Programming + Objects

Book Description
Learn how to be more productive with Scala, a new multi-paradigm language for the Java Virtual Machine (JVM) that integrates features of both object-oriented and functional programming. With this book, you'll discover why Scala is ideal for highly scalable, component-based applications that support concurrency and distribution.

Programming Scala clearly explains the advantages of Scala as a JVM language. You'll learn how to leverage the wealth of Java class libraries to meet the practical needs of enterprise and Internet projects more easily. Packed with code examples, this book provides useful information on Scala's command-line tools, third-party tools, libraries, and available language-aware plugins for editors and IDEs.
Book Details

• Publisher:        O'Reilly Media
• By:        Dean Wampler, Alex Payne
• ISBN:        978-0-596-15595-7
• Year:        2009
• Pages:        448
• Language:        English
• File size:        3.37 MB
• File format:        PDF
• Download:        

  本帖隐藏的内容

  Programming Scala.rar (3.19 MB, 需要: 20 个论坛币) 本附件包括：

  • Programming Scala.pdf

  2015-5-1 10:16:09 上传

  
  需要: 20 个论坛币  [购买]
  
  
• https://github.com/deanwampler/prog-scala-2nd-ed-code-examples
  

扫码加我 拉你入群

请注明：姓名-公司-职位

以便审核进群资格，未注明则拒绝

分享0 收藏0 回帖

关键词：Programming Program SCALA gram Ming advantages discover features support learn

1. Guards in case Clauses
   
2. Matching on literal values is very useful, but sometimes you need a little additional logic:
   
3. 
   
4. // src/main/scala/progscala2/patternmatching/match-guard.sc
   
5. 
   
6. for (i <- Seq(1,2,3,4)) {
   
7.   i match {
   
8.     case _ if i%2 == 0 => println(s"even: $i")                       // 1
   
9.     case _             => println(s"odd:  $i")                       // 2
   
10.   }
    
11. }
    
12. 1
    
13. Match only if i is even. We use _ instead of a variable, because we already have i.
    
14. 
    
15. 2
    
16. Match the only other possibility, that i is odd.

复制代码

1. // src/main/scala/progscala2/patternmatching/match-deep.sc
   
2. 
   
3. // Simplistic address type. Using all strings is questionable, too.
   
4. case class Address(street: String, city: String, country: String)
   
5. case class Person(name: String, age: Int, address: Address)
   
6. 
   
7. val alice   = Person("Alice",   25, Address("1 Scala Lane", "Chicago", "USA"))
   
8. val bob     = Person("Bob",     29, Address("2 Java Ave.",  "Miami",   "USA"))
   
9. val charlie = Person("Charlie", 32, Address("3 Python Ct.", "Boston",  "USA"))
   
10. 
    
11. for (person <- Seq(alice, bob, charlie)) {
    
12.   person match {
    
13.     case Person("Alice", 25, Address(_, "Chicago", _)) => println("Hi Alice!")
    
14.     case Person("Bob", 29, Address("2 Java Ave.", "Miami", "USA")) =>
    
15.       println("Hi Bob!")
    
16.     case Person(name, age, _) =>
    
17.       println(s"Who are you, $age year-old person named $name?")
    
18.   }
    
19. }

复制代码

1. // src/main/scala/progscala2/patternmatching/match-vararglist.sc
   
2. 
   
3. // Operators for WHERE clauses
   
4. object Op extends Enumeration {                                      // 1
   
5.   type Op = Value
   
6. 
   
7.   val EQ   = Value("=")
   
8.   val NE   = Value("!=")
   
9.   val LTGT = Value("<>")
   
10.   val LT   = Value("<")
    
11.   val LE   = Value("<=")
    
12.   val GT   = Value(">")
    
13.   val GE   = Value(">=")
    
14. }
    
15. import Op._
    
16. 
    
17. // Represent a SQL "WHERE x op value" clause, where +op+ is a
    
18. // comparison operator: =, !=, <>, <, <=, >, or >=.
    
19. case class WhereOp[T](columnName: String, op: Op, value: T)          // 2
    
20. 
    
21. // Represent a SQL "WHERE x IN (a, b, c, ...)" clause.
    
22. case class WhereIn[T](columnName: String, val1: T, vals: T*)         // 3
    
23. 
    
24. val wheres = Seq(                                                    // 4
    
25.   WhereIn("state", "IL", "CA", "VA"),
    
26.   WhereOp("state", EQ, "IL"),
    
27.   WhereOp("name", EQ, "Buck Trends"),
    
28.   WhereOp("age", GT, 29))
    
29. 
    
30. for (where <- wheres) {
    
31.   where match {
    
32.     case WhereIn(col, val1, vals @ _*) =>                            // 5
    
33.       val valStr = (val1 +: vals).mkString(", ")
    
34.       println (s"WHERE $col IN ($valStr)")
    
35.     case WhereOp(col, op, value) => println (s"WHERE $col $op $value")
    
36.     case _ => println (s"ERROR: Unknown expression: $where")
    
37.   }
    
38. }
    
39. 1
    
40. An enumeration for the comparison operators, where we assign a “name” that’s the string representation of the operator in SQL.
    
41. 
    
42. 2
    
43. A case class for WHERE x OP y clauses.
    
44. 
    
45. 3
    
46. A case class for WHERE x IN (val1, val2, …) clauses.
    
47. 
    
48. 4
    
49. Some example objects to parse.
    
50. 
    
51. 5
    
52. Note the syntax for matching on a variable argument: name @ _*.

复制代码

1. Matching on Regular Expressions
   
2. Regular expressions (or regexes) are convenient for extracting data from strings that have a particular structure.
   
3. 
   
4. Scala wraps Java’s regular expressions.[7] Here is an example:
   
5. 
   
6. // src/main/scala/progscala2/patternmatching/match-regex.sc
   
7. 
   
8. val BookExtractorRE = """Book: title=([^,]+),\s+author=(.+)""".r     // 1
   
9. val MagazineExtractorRE = """Magazine: title=([^,]+),\s+issue=(.+)""".r
   
10. 
    
11. val catalog = Seq(
    
12.   "Book: title=Programming Scala Second Edition, author=Dean Wampler",
    
13.   "Magazine: title=The New Yorker, issue=January 2014",
    
14.   "Unknown: text=Who put this here??"
    
15. )
    
16. 
    
17. for (item <- catalog) {
    
18.   item match {
    
19.     case BookExtractorRE(title, author) =>                           // 2
    
20.       println(s"""Book "$title", written by $author""")
    
21.     case MagazineExtractorRE(title, issue) =>
    
22.       println(s"""Magazine "title", issue $issue""")
    
23.     case entry => println(s"Unrecognized entry: $entry")
    
24.   }
    
25. }
    
26. 1
    
27. Match a book string, with two capture groups (note the parentheses), one for the title and one for the author. Calling the r method on a string creates a regex from it. Match a magazine string, with capture groups for the title and issue (date).
    
28. 
    
29. 2
    
30. Use them like case classes, where the string matched by each capture group is assigned to a variable.

复制代码

1. // src/main/scala/progscala2/patternmatching/match-deep2.sc
   
2. 
   
3. case class Address(street: String, city: String, country: String)
   
4. case class Person(name: String, age: Int, address: Address)
   
5. 
   
6. val alice   = Person("Alice",   25, Address("1 Scala Lane", "Chicago", "USA"))
   
7. val bob     = Person("Bob",     29, Address("2 Java Ave.",  "Miami",   "USA"))
   
8. val charlie = Person("Charlie", 32, Address("3 Python Ct.", "Boston",  "USA"))
   
9. 
   
10. for (person <- Seq(alice, bob, charlie)) {
    
11.   person match {
    
12.     case p @ Person("Alice", 25, address) => println(s"Hi Alice! $p")
    
13.     case p @ Person("Bob", 29, a @ Address(street, city, country)) =>
    
14.       println(s"Hi ${p.name}! age ${p.age}, in ${a.city}")
    
15.     case p @ Person(name, age, _) =>
    
16.       println(s"Who are you, $age year-old person named $name? $p")
    
17.   }
    
18. }
    
19. The p @ … syntax assigns to p the whole Person instance and similarly for a @ … and an Address.

复制代码