中国领先的IT技术网站
|
|

深入理解Scala---核心规则

Scala是表达式导向的编程语言。但并不是100%成立,Scala代码中还是有控制语块,毕竟我们写程序就是为了控制各种实体为我们服务的。

作者:欧阳左至来源:oschina|2014-04-09 09:42

沙龙活动 | 去哪儿、陌陌、ThoughtWorks在自动化运维中的实践!10.28不见不散!


Read Eval Print Loop (REPL)

REPL在Scala里面指的是直接运行scala.exe进入的交互式命令行模式。广义上讲,也泛指那些在线编程工具。

核心规则1:请使用REPL来熟悉Scala语言。

Scala的REPL有个好处是能够将我们输入的每行代码的内部表示反馈出来。比如:

scala> def add(a:Int, b:Int):Int = a + b

add: (a: Int, b: Int)Int

我们定义一个函数,完成两个数的加法。Scala回显给我们的内容可以帮助我们写代码。

表达式与语句

表达式与语句的区别是:语句是用来执行的,而表达式是用来求值的。在程序员的世界里,表达式就是返回值,语言就是没有返回值执行程序。

Scala是表达式导向的编程语言。但并不是100%成立,Scala代码中还是有控制语块,毕竟我们写程序就是为了控制各种实体为我们服务的。

核心规则2:使用表达式,而不是语句。

这条规则主要是帮助我们简化代码,就像前面加法的例子,a+b就是一个表达式。相比于我们C语言写的相同实现,简单不好。代码里面,像这样的例子肯定还是存在很多的。

不要使用Return

当我们使用表达式的时候,就不需要Return了。因为表达式本身就是用来求值的,我们必要再去显式地说我现在要返回什么。Scala编译器自动使用最后一个表达式的返回值作为函数的返回值。

我们应该记得一个编程指导意见就是函数在同一个地方返回。如果我们现在没有Return语句了,像在Scala中,有没有类似的编程指导呢?看个例子:

  1. object NoReturn extends scala.App {  
  2.   def createErrorMessage1(errorCode : Int) : String = {  
  3.     val result = errorCode match {  
  4.       case 1 => "Network Failure" 
  5.       case 2 => "I/O Failure" 
  6.       case 3 => "Unknown Error" 
  7.     }  
  8.     return result  
  9.   }  
  10.   def createErrorMessage2(errorCode: Int) : String = {  
  11.     var result : String = null            // not val  
  12.     errorCode match {  
  13.       case 1 =>  
  14.         result = "Network Failure" 
  15.       case 2 =>  
  16.         result = "I/O Failure" 
  17.       case _ =>  
  18.         result = "Unknown Error" 
  19.     }  
  20.     return result;  
  21.   }  
  22.   def createErrorMessage3(errorCode : Int) : String = {  
  23.     errorCode match {  
  24.       case 1 => "Network Failure" 
  25.       case 2 => "I/O Failure" 
  26.       case 3 => "Unknown Error" 
  27.     }  
  28.   }  
  29.   println(createErrorMessage1(1))  
  30.   println(createErrorMessage2(2))  
  31.   println(createErrorMessage3(3))  
  32.   println(1 match{case 1 => "Network Failure" case 2 => 3})  
  33.   println(2 match{case 1 => "Network Failure" case 2 => 3})  
  34. }  

createErrorMessage2应该是我们以往的写法。定义一个局部变量,然后匹配errorCode,对其进行赋值。createErrorMessage1是Scala推荐的写法(虽然还不够简洁),它使用的是val而不是var,来声明临时变量。val表示值,赋值后就不允许再更改;var是变量,可以重复赋值。createErrorMessage1的的result之后是一个表达式。求值之后直接就赋值了。createErrorMessage3就更加简洁了,差不多到了终极形态了。函数直接就返回一个表达式,少了临时对象。

注:match case支持每个分支返回的类型不同。这个特性在函数式编程中非常有用。

Scala虽然支持所有的3中写法,但是推荐最后一种。因为它帮助简化了代码的复杂度,增加了程序的不可变性。不可变指的是程序在执行过程中,所有的状态(变量)都是常量。不可变的代码比可变代码更加容易理解、调试和维护。

表达式导向的语言倾向与使用不可变的对象,能减少程序中的可变对象。

使用不可变对象

核心规则3:使用不可变对象可以大幅减少运行时故障。当面对可变与不可变的选择时,选择不可变对象无疑是最安全的。

对象等价性

Scala提供了##和==来判断对象是不是等价,它们可以作用于AnyRef(引用)和AnyVal(值)。

对象的哈希值和equal应该成对出现。因为等价性经常使用到了hash值。

  1. import collection.immutable.HashMap  
  2. class Point2(var x: Int, var y: Int) extends Equals {  
  3.   def move(mx: Int, my: Int) : Unit = {  
  4.     x = x + mx  
  5.     y = y + my  
  6.   }  
  7.   override def hashCode(): Int = y + (31*x)  
  8.   def canEqual(that: Any): Boolean = that match {  
  9.     case p: Point2 => true 
  10.     case _ => false 
  11.   }  
  12.   override def equals(that: Any): Boolean = {  
  13.     def strictEquals(other: Point2) =  
  14.       this.x == other.x && this.y == other.y  
  15.     that match {  
  16.       case a: AnyRef if this eq a => true 
  17.       case p: Point2 => (p canEqual this) && strictEquals(p)  
  18.       case _ => false 
  19.     }  
  20.   }  
  21. }  
  22. object ObjecteEquality extends scala.App  
  23. {  
  24.   val x = new Point2(1,1)  
  25.   val y = new Point2(1,2)  
  26.   val z = new Point2(1,1)  
  27.   println(x == y) // false  
  28.   println(x == z) // true  
  29.   val map = HashMap(x -> "HAI", y -> "ZOMG")  
  30.   println(map(x)) // HAI  
  31.   println(map(y)) // ZOMG  
  32.   println(map(z)) // HAI, if we remove hashCode, there will be an exception  
  33.   x.move(1,1)  
  34. // println(map(x)) //Exception in thread "main" java.util.NoSuchElementException: key not found: Point2@40  
  35.   println(map.find(_._1 == x))  
  36. }  

3-22行定义了一个Point2类,它继承自Equals。

  1. trait Equals extends Any {  
  2.  
  3.   def canEqual(that: Any): Boolean  
  4.  
  5.   def equals(that: Any): Boolean  
  6.  
  7. }  

定义了自己的move方法和hashCode方法。canEqual用来判断是否可以在对象上应用equal方法,这里只是检查是否类型匹配。equal包含一个内部函数strictEquals用来判断对象的成员是否相等。equal首先检查是不是引用了同一个Point2对象,如果是,直接返回true。否则,检查类型是不是匹配,如果是,用strictEquals用来判断对象的成员是否相等。

第36行:println(map(z)),它的正确执行依赖于hashCode是否定义。Map在寻找指定key的值的时候,会调用key.##。

第38行,由于move改变了x的内部状态,hashCode计算出来的新值当做key去Map里面查找,找不到对应的值,就会报NoSuchElementException异常。

第40行,比较奇特。看下find的定义:

trait IterableLike:

  1. override /*TraversableLike*/ def find(p: A => Boolean): Option[A] = iterator.find(p)  

object Iterator:

  1. def find(p: A => Boolean): Option[A] = {  
  2.   var res: Option[A] = None  
  3.   while (res.isEmpty && hasNext) {  
  4.     val e = next()  
  5.     if (p(e)) res = Some(e)  
  6.   }  
  7.   res  

传给find的是一个predicate。迭代器遍历集合中的每个元素,并将该元素作为参数传给predicate。所有我们这里传给predicate的参数是一个键值对[A,B]。_就是传给predicate的参数。_1指的是键值对中的第一个元素(实际上是元组中的第一个元素),即A,也就是作为key的Point2。现在很容易明白这句的意思了,就是与x的hashCode一样的元素。_1的定义位于:

trait Product2:

  1. /** A projection of element 1 of this Product.  
  2.    * @return A projection of element 1.  
  3.    */ 
  4.   def _1: T1  

在我们实现对象的等价判断的时候,请遵循:

  • 如果两个对象相等,那它们应该有相同的hashCode。

  • 对象的hashCode在其生命周期内不会改变。

  • 如果将一个对象发送给其他的JVM,应该保证等价判断依赖于对象在两个JVM都可用的属性。主要用于序列化。

如果我们的对象是不可变的,那么上面的条件2自行就满足了,这会简化等价判断。另外,不可变性不仅仅简化等价判断,也会简化并行数据的访问,因为不存在同步互斥。

使用None而不是null

null的使用还是很受大家诟病的。null迫使大家添加了额外的处理代码。Scala使用Option来包装了null的处理,我们不在需要去判断变量是否为空。我们可以将Option看成一个通用的容器,包含了一些对象的容器(Some),或者是空容器(None)。这两周容器都需要对象的类型。

类似地,Scala还有空的列表Nil。

核心规则4:使用None而不是null

Java中,我们经常会碰到空异常。如果我们学会了正确使用Option,完全可以避免空异常的发生。

Scala的Option伴生对象(companion object)包含一个工厂方法,将Java的null自动转换为None:var x : Option[String] = Option(null)。等价于var x : Option[String] = Null。

Scala更加高级的用法是把它当作一个集合。这意味着,你可以在Option上使用map、flatMap、foreach,甚至是for表达式。

使用Null的一些高级实例:

  1. class HttpSession  
  2. class Connection  
  3. object DriverManager {  
  4.   def getConnection(url: String, user: String, pw: String): Connection = {  
  5.     println("getConnection")  
  6.     new Connection  
  7.   }  
  8. }  
  9. object AdvancedNull extends scala.App {  
  10.   //CREATE AN OBJECT OR RETURN A DEFAULT  
  11.   def getTemporaryDirectory(tmpArg: Option[String]): java.io.File = {  
  12.     tmpArg.map(name => new java.io.File(name)).  
  13.       filter(_.isDirectory).  
  14.       getOrElse(new java.io.File(  
  15.       System.getProperty("java.io.tmpdir")))  
  16.   }  
  17.   //EXECUTE BLOCK OF CODE IF VARIABLE IS INITIALIZED  
  18.   val username1: Option[String] = Option("Sulliy")  
  19.   for (uname <- username1) {  
  20.     println("User: " + uname)  
  21.   }  
  22.   val username2: Option[String] = None  
  23.   for (uname <- username2) {  
  24.     println("User: " + uname)  
  25.   }  
  26.   def canAuthenticate(username: String, password: Array[Char]): Boolean = {  
  27.     println("canAuthenticate")  
  28.     true 
  29.   }  
  30.   def privilegesFor(username: String): Int = {  
  31.     println("privilegesFor")  
  32.     0 
  33.   }  
  34.   def injectPrivilegesIntoSession(session: HttpSession, privileges: Int): Unit = {  
  35.     println("injectPrivilegesIntoSession")  
  36.   }  
  37.   def authenticateSession(session: HttpSession,  
  38.                           username: Option[String],  
  39.                           password: Option[Array[Char]]) = {  
  40.     for (u <- username;  
  41.          p <- password;  
  42.          if canAuthenticate(u, p)) {  
  43.       val privileges = privilegesFor(u)  
  44.       injectPrivilegesIntoSession(session, privileges)  
  45.     }  
  46.   }  
  47.   authenticateSession(new HttpSession, None, None)  
  48.   //USING POTENTIAL UNINITIALIZED VARIABLES TO CONSTRUCT ANOTHER VARIABLE  
  49.   def createConnection(conn_url: Option[String],  
  50.                        conn_user: Option[String],  
  51.                        conn_pw: Option[String]): Option[Connection] =  
  52.     for {  
  53.       url <- conn_url  
  54.       user <- conn_user  
  55.       pw <- conn_pw  
  56.     } yield DriverManager.getConnection(url, user, pw)  
  57.   createConnection(None, Option("sully"), None)  
  58.   def lift3[A, B, C, D](f: Function3[A, B, C, D]): Function3[Option[A], Option[B], Option[C], Option[D]] = {  
  59.     (oa: Option[A], ob: Option[B], oc: Option[C]) =>  
  60.       for (a <- oa; b <- ob; c <- oc) yield f(a, b, c)  
  61.   }  
  62.   lift3(DriverManager.getConnection)(Option("127.0.0.1"), Option("sulliy"), Option("sulliy"))  
  63. }  

11行-16行,示例了通过一个文件名获取File对象。由于输入参数是Option[String],该函数可以接受None,既null。map、filter、getOrElse都是Option的成员函数:

  1. @inline final def map[B](f: A => B): Option[B] =  
  2.  
  3.     if (isEmpty) None else Some(f(this.get))  
  4.  
  5. @inline final def filter(p: A => Boolean): Option[A] =  
  6.  
  7.     if (isEmpty || p(this.get)) this else None  
  8.  
  9. @inline final def getOrElse[B >: A](default: => B): B =  
  10.  
  11.     if (isEmpty) default else this.get 

前两个函数都又返回了Option[],所以我们可以进行级联的书写。map返回None(Option的子类),None的filter返回None,None的getOrElse返回default,即new java.io.File( System.getProperty("java.io.tmpdir")。

我们在需要创建一个对象或者返回一个缺省对象的时候,可以使用这种方法。

18行-21行,示例了将Option放在for循环里面。由于username1赋值了,username2为空,因此20行会被执行,24行不会被执行。37行-47行,给了一个更加复杂的例子。

49行-56行,示例了通过一个可能未初始化的对象来创建新对象。用到了yield。

58行-62行,提供了一个通用方法,将普通的Java方法封装为支持Option的新的Scala方法。这样,我们就不需要自己去处理所有参数的null检查。

多态环境下的等价判断

核心规则5:在使用多态情况下,使用scala.Equals提供的模板。

前面已经提到了scala.Equals,需要注意的是:请同时重写canEqual和equal。

原文链接:http://my.oschina.net/sulliy/blog/220081

【编辑推荐】

  1. 有趣的Scala语言: 使用递归的方式去思考
  2. JVM并发机制探讨—内存模型、内存可见性和指令重排序
  3. Java下一代:Groovy、Scala和Clojure共同点,第2部分
  4. JVM性能优化,Java的伸缩性
  5. 利用Scala语言开发Spark应用程序
【责任编辑:林师授 TEL:(010)68476606】

点赞 0
分享:
大家都在看
猜你喜欢

读 书 +更多

大师品软件——软件之痛与应对之道

这并不是一本传统的技术专著,因为它并没有包含一行代码,而更像是一部技术评论。作者通过幽默诙谐而又不失辛辣的语言,从程序员、用户等多...

订阅51CTO邮刊

点击这里查看样刊

订阅51CTO邮刊
× Python最火的编程语言