新手向,面向刚从java过渡到scala的同学,目的是写出已已易于维护和阅读的代码.
语句(statement): 一段可执行的代码表达式(expression): 一段可以被求值的代码
在Java中语句和表达式是有区分的,表达式必须在return或者等号右侧,而在scala中,一切都是表达式.
一个例子:假设我们在公司的内网和外网要从不同的域名访问一样的机器
//Java代码 String urlString = null; String hostName = InetAddress.getLocalHost().getHostName(); if (isInnerHost(hostName)) { urlString = "http://inner.host"; } else { urlString = "http://outter.host"; }
刚转到scala的人很可能这么写
var urlString: String = null var hostName = InetAddress.getLocalHost.getHostName if (isInnerHost(hostName)) { urlString = "http://inner.host" } else { urlString = "http://outter.host" }
我们让它更像scala一点吧
val hostName = InetAddress.getLocalHost.getHostName val urlString = if (isInnerHost(hostName)) { "http://inner.host" } else { "http://outter.host" }
这样做的好处都有啥?
很多时候,我们编程时说的安全并不是指怕被黑客破坏掉,而是预防自己因为逗比而让程序崩了.
纯函数(Pure Function)是这样一种函数——输入输出数据流全是显式(Explicit)的。显式(Explicit)的意思是,函数与外界交换数据只有一个唯一渠道——参数和返回值;函数从函数外部接受的所有输入信息都通过参数传递到该函数内部;函数输出到函数外部的所有信息都通过返回值传递到该函数外部。
如果一个函数通过隐式(Implicit)方式,从外界获取数据,或者向外部输出数据,那么,该函数就不是纯函数,叫作非纯函数(Impure Function)。隐式(Implicit)的意思是,函数通过参数和返回值以外的渠道,和外界进行数据交换。比如,读取全局变量,修改全局变量,都叫作以隐式的方式和外界进行数据交换;比如,利用I/O API(输入输出系统函数库)读取配置文件,或者输出到文件,打印到屏幕,都叫做隐式的方式和外界进行数据交换。
//一些例子 //纯函数 def add(a:Int,b:Int) = a + b //非纯函数 var a = 1 def addA(b:Int) = a + b def add(a:Int,b:Int) = { println(s"a:$a b:$b") a + b } def randInt() = Random.nextInt()
单元测试什么的,赶紧去 http://www.scalatest.org 试试吧
维基百科中惰性求值的解释
惰性求值(Lazy Evaluation),又称惰性计算、懒惰求值,是一个计算机编程中的一个概念,它的目的是要最小化计算机要做的工作。它有两个相关而又有区别的含意,可以表示为“延迟求值”和“最小化求值”,本条目专注前者,后者请参见最小化计算条目。除可以得到性能的提升外,惰性计算的最重要的好处是它可以构造一个无限的数据类型。
惰性求值的相反是及早求值,这是一个大多数编程语言所拥有的普通计算方式。
import scala.io.Source.fromFile val iter: Iterator[String] = fromFile("sampleFile") .getLines()
文件迭代器就用到了惰性求值.用户可以完全像操作内存中的数据一样操作文件,然而文件只有一小部分传入了内存中.
lazy val firstLazy = { println("first lazy") 1 } lazy val secondLazy = { println("second lazy") 2 } def add(a:Int,b:Int) = { a+b }
//在 scala repl 中的结果 scala> add(secondLazy,firstLazy) second lazy first lazy res0: Int = 3 res0: Int = 3
second lazy 先于 first lazy输出了
def firstLazy = { println("first lazy") 1 } def secondLazy = { println("second lazy") 2 } def chooseOne(first: Boolean, a: Int, b: Int) = { if (first) a else b } def chooseOneLazy(first: Boolean, a: => Int, b: => Int) = { if (first) a else b }
chooseOne(first = true, secondLazy, firstLazy) //second lazy //first lazy //res0: Int = 2 chooseOneLazy(first = true, secondLazy, firstLazy) //second lazy //res1: Int = 2
对于非纯函数,惰性求值会产生和立即求值产生不一样的结果.
//需要查询mysql等,可能来自于一个第三方jar包 def itemIdToShopId: Int => Int var cache = Map.empty[Int, Int] def cachedItemIdToShopId(itemId: Int):Int = { cache.get(itemId) match { case Some(shopId) => shopId case None => val shopId = itemIdToShopId(itemId) cache += itemId -> shopId shopId } }
//用你的本地mock来测试程序 def mockItemIdToSHopId: Int => Int def cachedItemIdToShopId(itemId: Int): Int ={ cache.get(itemId) match { case Some(shopId) => shopId case None => val shopId = mockItemIdToSHopId(itemId) cache += itemId -> shopId shopId } }
//将远程请求的结果作为函数的一个参数 def cachedItemIdToShopId(itemId: Int, remoteShopId: Int): Int = { cache.get(itemId) match { case Some(shopId) => shopId case None => val shopId = remoteShopId cache += itemId -> shopId shopId } } //调用这个函数 cachedItemIdToShopId(itemId,itemIdToShopId(itemId))
没错,cache根本没有起应有的作用,函数每次执行的时候都调用了itemIdToShopId从远程取数据
//改成call by name就没有这个问题啦 def cachedItemIdToShopId(itemId: Int, remoteShopId: =>Int): Int = { cache.get(itemId) match { case Some(shopId) => shopId case None => val shopId = remoteShopId cache += itemId -> shopId shopId } } //调用这个函数 cachedItemIdToShopId(itemId,itemIdToShopId(itemId))
val (one, two) = (1, 2) one //res0: Int = 1 two //res1: Int = 2 def sellerAndItemId(orderId: Int): (Int, Int) = orderId match { case 0 => (1, 2) } val (sellerId, itemId) = sellerAndItemId(0) sellerId // sellerId: Int = 1 itemId // itemId: Int = 2 val sellerItem = sellerAndItemId(0) sellerItem._1 //res4: Int = 1 sellerItem._2 //res5: Int = 2
val sampleList = List((1, 2, 3), (4, 5, 6), (7, 8, 9)) sampleList.map(x => s"${x._1}_${x._2}_${x._3}") //res0: List[String] = List(1_2_3, 4_5_6, 7_8_9) sampleList.map { case (orderId, shopId, itemId) => s"${orderId}_${shopId}_$itemId" } //res1: List[String] = List(1_2_3, 4_5_6, 7_8_9)
上下两个map做了同样的事情,但下一个map为tuple中的三个值都给了名字,增加了代码的可读性.
//case如果是常量,就在值相等时匹配. //如果是变量,就匹配任何值. def describe(x: Any) = x match { case 5 => "five" case true => "truth" case "hello" => "hi!" case Nil => "the empty list" case somethingElse => "something else " + somethingElse }
case class,tuple以及列表都可以在匹配的同时捕获内部的内容.
case class Sample(a:String,b:String,c:String,d:String,e:String) def showContent(x: Any) = x match { case Sample(a,b,c,d,e) => s"Sample $a.$b.$c.$d.$e" case (a,b,c,d,e) => s"tuple $a,$b,$c,$d,$e" case head::second::rest => s"list head:$head second:$second rest:$rest" }
Map<String, String> map = ??? String valFor2014 = map.get(“1024”); // null if (valFor1024 == null) abadon(); else doSomething();
Some[A](x: A)
,size为0的时候就是一个 None
def get(key: A): Option[B] def getOrElse[B1 >: B](key: A, default: => B1): B1 = get(key) match { case Some(v) => v case None => default }
getOrElse
这个方法并放在一个叫做MapUtils的类里. 确实能够区分Map是无值还是值为null了.
但是if(为null) 则 abandon 要写一百遍.
case Some(v) => v
case None => default
似乎也得写一百遍.
不,不是这样的
不要忘了option是个容器
http://www.scala-lang.org/api/2.11.7/index.html#scala.Optionval a: Option[String] = Some("1024") val b: Option[String] = None a.map(_.toInt) //res0: Option[Int] = Some(1024) b.map(_.toInt) //res1: Option[Int] = None,不会甩exception a.filter(_ == "2048") //res2: Option[String] = None b.filter(_ == "2048") //res3: Option[String] = None a.getOrElse("2048") //res4: String = 1024 b.getOrElse("2048") //res5: String = 2048 a.map(_.toInt) .map(_ + 1) .map(_ / 5) .map(_ / 2 == 0) //res6: Option[Boolean] = Some(false) //如果是null,恐怕要一连check abandon四遍了
val a: Seq[String] = Seq("1", "2", "3", null, "4") val b: Seq[Option[String]] = Seq(Some("1"), Some("2"), Some("3"), None, Some("4")) a.filter(_ != null).map(_.toInt) //res0: Seq[Int] = List(1, 2, 3, 4) //如果你忘了检查,编译器是看不出来的,只能在跑崩的时候抛异常 b.flatMap(_.map(_.toInt)) //res1: Seq[Int] = List(1, 2, 3, 4)
scala原生容器类都对option有良好支持
Seq(1,2,3).headOption //res0: Option[Int] = Some(1) Seq(1,2,3).find(_ == 5) //res1: Option[Int] = None Seq(1,2,3).lastOption //res2: Option[Int] = Some(3) Vector(1,2,3).reduceLeft(_ + _) //res3: Int = 6 Vector(1,2,3).reduceLeftOption(_ + _) //res4: Option[Int] = Some(6) //在vector为空的时候也能用 Seq("a", "b", "c", null, "d").map(Option(_)) //res0: Seq[Option[String]] = // List(Some(a), Some(b), Some(c), None, Some(d)) //原始数据转换成option也很方便
try { 1024 / 0 } catch { case e: Throwable => e.printStackTrace() }
用try-catch的模式,异常必须在抛出的时候马上处理.然而在分布式计算中,我们很可能希望将异常集中到一起处理,来避免需要到每台机器上单独看错误日志的窘态.
val seq = Seq(0, 1, 2, 3, 4) //seq: Seq[Int] = List(0, 1, 2, 3, 4) val seqTry = seq.map(x => Try { 20 / x }) //seqTry: Seq[scala.util.Try[Int]] = List(Failure(java.lang.ArithmeticException: devide by zero),Success(20), Success(10), Success(6), Success(5)) val succSeq = seqTry.flatMap(_.toOption) //succSeq: Seq[Int] = List(20, 10, 6, 5) Try可以转换成Option val succSeq2 = seqTry.collect { case Success(x) => x } //succSeq2: Seq[Int] = List(20, 10, 6, 5) 和上一个是一样的 val failSeq: Seq[Throwable] = seqTry.collect { case Failure(e) => e } //failSeq: Seq[Throwable] = List(java.lang.ArithmeticException: devide by zero)
Try实例可以序列化,并且在机器间传送.
一个java版本
List<String> params = new LinkedList<>(); List<Integer> nums = new LinkedList<>(); List<String> marks = new LinkedList<>(); public JavaRangeMatcher(List<String> params) { this.params = params; for (String param : params) { String[] markNum = param.split(" "); marks.add(markNum[0]); nums.add(Integer.parseInt(markNum[1])); } } public boolean check(int input) { for (int i = 0; i < marks.size(); i++) { int num = nums.get(i); String mark = marks.get(i); if (mark.equals(">") && input <= num) return false; if (mark.equals(">=") && input < num) return false; if (mark.equals("<") && input >= num) return false; if (mark.equals("<=") && input > num) return false; } return true; } List<String> paramsList = new LinkedList<String>() {{ add(“>= 3”); add(“< 7”); }}; JavaRangeMatcher matcher = new JavaRangeMatcher(paramsList); int[] inputs = new int[]{1, 3, 5, 7, 9}; for (int input : inputs) { System.out.println(matcher.check(input)); } //给自己有限的时间,想想又没有性能优化的余地 //我们一起来跑跑看
一个 scala 版本
def exprToInt(expr: String): Int => Boolean = { val Array(mark, num, _*) = expr.split(" ") val numInt = num.toInt mark match { case "<" => numInt.> case ">" => numInt.< case ">=" => numInt.<= case "<=" => numInt.>= } //返回函数的函数 } case class RangeMatcher(range: Seq[String]) { val rangeFunc: Seq[(Int) => Boolean] = range.map(exprToInt) def check(input: Int) = rangeFunc.forall(_(input)) } def main(args: Array[String]) { val requirements = Seq(">= 3", "< 7") val rangeMatcher = RangeMatcher(requirements) val results = Seq(1, 3, 5, 7, 9).map(rangeMatcher.check) println(results.mkString(",")) //false,true,true,false,false }
这里有一个 性能测试 网站
我对于网站测试的结果,我总结的情况就是两点.
1. 排在后面的基本都是动态类型语言,静态类型语言相对容易优化到性能差不多的结果.
2. 同一个语言代码写得好差产生的性能差异,远远比各种语言最好的代码性能差异大.
不过也有返利,我们之前那个程序就是.
//java版本 public static void main(String[] args) { List<String> paramsList = new LinkedList<String>() {{ add(">= 3"); add("< 7"); }}; JavaRangeMatcher matcher = new JavaRangeMatcher(paramsList); Random random = new Random(); long timeBegin = System.currentTimeMillis(); for (int i = 0; i < 100000000; i++) { int input = random.nextInt() % 10; matcher.check(input); } long timeEnd = System.currentTimeMillis(); System.out.println("java 消耗时间: " + (timeEnd - timeBegin) + " 毫秒"); //java 消耗时间: 3263 毫秒 }
//scala版本 def main(args: Array[String]) { val requirements = Seq(">= 3", "< 7") val rangeMatcher = RangeMatcher(requirements) val timeBegin = System.currentTimeMillis() 0 until 100000000 foreach { case _ => rangeMatcher.check(Random.nextInt(10)) } val timeEnd = System.currentTimeMillis() println(s"scala 消耗时间 ${timeEnd - timeBegin} 毫秒") //scala 消耗时间 2617 毫秒 }
想想这是为什么?