Spark记录-Scala语法基础

参考：http://docs.scala-lang.org/cheatsheets/index.html、http://docs.scala-lang.org/、http://www.scala-lang.org/api/2.10.4/#package

变量
var x = 5	变量
好 val x = 5 不好 x=6	不变
var x: Double = 5	显式类型
功能
好 def f(x: Int) = { x*x } 不好 def f(x: Int) { x*x }	定义函数 隐藏错误：无=这是一个单元返回过程; 造成严重破坏
好 def f(x: Any) = println(x) 不好 def f(x) = println(x)	定义函数 语法错误：每个arg需要类型。
type R = Double	类型别名
def f(x: R) 与 def f(x: => R)	按值 呼叫按名称（懒惰参数）
(x:R) => x*x	匿名功能
(1 to 5).map(_*2) 与 (1 to 5).reduceLeft( _+_ )	匿名函数：下划线是位置匹配的arg。
(1 to 5).map( x => x*x )	匿名函数：要使用一个arg两次，必须命名它。
好 (1 to 5).map(2*) 不好 (1 to 5).map(*2)	匿名函数：绑定中缀方法 使用2*_了理智的缘故吧。
(1 to 5).map { x => val y=x*2; println(y); y }	匿名函数：块样式返回最后一个表达式。
(1 to 5) filter {_%2 == 0} map {_*2}	匿名函数：管道风格。（或者也是parens）。
def compose(g:R=>R, h:R=>R) = (x:R) => g(h(x))  val f = compose({_*2}, {_-1})	匿名功能：传入多个块，需要外部的包袱。
val zscore = (mean:R, sd:R) => (x:R) => (x-mean)/sd	currying，语法明显。
def zscore(mean:R, sd:R) = (x:R) => (x-mean)/sd	currying，语法明显
def zscore(mean:R, sd:R)(x:R) = (x-mean)/sd	咖喱，糖语法。但是之后：
val normer = zscore(7, 0.4) _	需要尾随下划线才能得到部分，只有糖版本。
def mapmake[T](g:T=>T)(seq: List[T]) = seq.map(g)	泛型类型。
5.+(3); 5 + 3  (1 to 5) map (_*2)	中缀糖。
def sum(args: Int*) = args.reduceLeft(_+_)	可变参数。
包
import scala.collection._	通配符导入。
import scala.collection.Vector  import scala.collection.{Vector, Sequence}	选择性进口。
import scala.collection.{Vector => Vec28}	重命名导入。
import java.util.{Date => _, _}	从Date中除外的java.util全部导入。
package pkg 在文件开始  package pkg { ... }	申报一个包裹。
数据结构
(1,2,3)	元组文字。（Tuple3）
var (x,y,z) = (1,2,3)	解构绑定：通过模式匹配解开元组。
坏 var x,y,z = (1,2,3)	隐藏的错误：每个分配给整个元组。
var xs = List(1,2,3)	列表（不可变）。
xs(2)	paren索引。（幻灯片）
1 :: List(2,3)	利弊。
1 to 5 与...一样 1 until 6  1 to 10 by 2	范围糖。
() （空的parens）	Unit类型的唯一成员（如C / Java void）。
控制结构
if (check) happy else sad	有条件的。
if (check) happy  与...一样 if (check) happy else ()	有条件的糖。
while (x < 5) { println(x); x += 1}	while循环。
do { println(x); x += 1} while (x < 5)	做while循环。
import scala.util.control.Breaks._ breakable { for (x <- xs) { if (Math.random < 0.1) break } }	打破。（幻灯片）
for (x <- xs if x%2 == 0) yield x*10  与...一样 xs.filter(_%2 == 0).map(_*10)	理解：过滤器/地图
for ((x,y) <- xs zip ys) yield x*y  与...一样 (xs zip ys) map { case (x,y) => x*y }	理解：解构约束
for (x <- xs; y <- ys) yield x*y  与...一样 xs flatMap {x => ys map {y => x*y}}	理解：交叉产品
for (x <- xs; y <- ys) { println("%d/%d = %.1f".format(x, y, x/y.toFloat)) }	理解：势在必行 sprintf式
for (i <- 1 to 5) { println(i) }	理解：迭代包括上限
for (i <- 1 until 5) { println(i) }	理解：迭代省略上界
模式匹配
好 (xs zip ys) map { case (x,y) => x*y } 不好 (xs zip ys) map( (x,y) => x*y )	用于模式匹配的函数参数用例。
坏 val v42 = 42 Some(3) match { case Some(v42) => println("42") case _ => println("Not 42") }	“v42”被解释为与任何Int值匹配的名称，并且打印“42”。
好 val v42 = 42 Some(3) match { case Some(`v42`) => println("42") case _ => println("Not 42") }	带有反引号的“v42”被解释为现有的val v42，并且“Not 42”被打印。
好 val UppercaseVal = 42 Some(3) match { case Some(UppercaseVal) => println("42") case _ => println("Not 42") }	UppercaseVal被视为现有的val，而不是新的模式变量，因为它以大写字母开头。因此，UppercaseVal检查包含在内的值3，并打印“不是42”。
面向对象
class C(x: R)	构造函数参数 - x仅在类体中可用
class C(val x: R) var c = new C(4) c.x	构造函数参数 - 自动公共成员定义
class C(var x: R) { assert(x > 0, "positive please") var y = x val readonly = 5 private var secret = 1 def this = this(42) }	构造函数是类体 声明一个public成员 声明一个gettable但不可设置的成员 声明一个私有成员的 替代构造函数
new{ ... }	匿名类
abstract class D { ... }	定义一个抽象类。（非可创建）
class C extends D { ... }	定义一个继承的类。
class D(var x: R) class C(x: R) extends D(x)	继承和构造函数参数。（心愿：默认自动传递params）
object O extends D { ... }	定义一个单例。（模块样）
trait T { ... } class C extends T { ... } class C extends D with T { ... }	特征。 接口与-实施。没有构造函数参数。可混合的。
trait T1; trait T2 class C extends T1 with T2 class C extends D with T1 with T2	多重特质。
class C extends D { override def f = ...}	必须声明方法覆盖。
new java.io.File("f")	创建对象。
坏的 new List[Int] 好 List(1,2,3)	类型错误：抽象类型 代替，惯例：可调用的工厂阴影类型
classOf[String]	类文字。
x.isInstanceOf[String]	类型检查（运行时）
x.asInstanceOf[String]	类型转换（运行时）
x: String	归属（编译时间）

1.关键字

abstract    case        catch       class       def
do          else        extends     false       final
finally     for         forSome     if          implicit
import      lazy        macro       match       new
null        object      override    package     private
protected   return      sealed      super       this
throw       trait       try         true        type
val         var         while       with        yield

_    :    =    =>    <-    <:    <%     >:    #    @

2.符号

1. 空白字符。u0020 | u0009 | u000D | u000A。

2. 字母包括小写字母（Ll），大写字母（Lu），标题字母（Lt），其他字母（Lo），字母数字（Nl）以及两个字母u0024 ‘$’和数字u005F ‘_’。

3. 数字‘0’ | … | ‘9’。

4. 括号‘(’ | ‘)’ | ‘[’ | ‘]’ | ‘{’ | ‘}’。

5. 分隔符字符‘`’ | ‘'’ | ‘"’ | ‘.’ | ‘;’ | ‘,’。

6. 操作员字符。这些包含所有可打印的ASCII字符（u0020- u007E），不在上述集合中，数学符号（Sm）和其他符号（So）。

‘‘ ‘b‘	u0008	退格	BS
‘‘ ‘t‘	u0009	水平选项卡	HT
‘‘ ‘n‘	u000a	换行	LF
‘‘ ‘f‘	u000c	形成饲料	FF
‘‘ ‘r‘	u000d	回车	CR
‘‘ ‘"‘	u0022	双引号	"
‘‘ ‘'‘	u0027	单引号	'
‘‘ ‘‘	u005c	反斜线