Scala备忘单

Scala Cheatsheet

Language

感谢Brendan O'Connor ,此备忘单旨在成为Scala句法构造的快速参考. 由Brendan O'Connor根据CC-BY-SA 3.0许可授权.

variables
var x = 5

Good
x = 6
Variable.
val x = 5

Bad
x = 6
Constant.
var x: Double = 5
显式类型.
functions
Good
def f(x: Int) = { x * x }

Bad
def f(x: Int)   { x * x }
定义功能.
隐藏的错误:不=它是一个过程返回Unit ; 造成破坏. 在Scala 2.13中弃用 .
Good
def f(x: Any) = println(x)

Bad
def f(x) = println(x)
定义功能.
语法错误:每个arg需要类型.
type R = Double
输入别名.
def f(x: R)
vs.
def f(x: => R)
按值致电.

名称呼叫(惰性参数).
(x: R) => x * x
匿名函数.
(1 to 5).map(_ * 2)
vs.
(1 to 5).reduceLeft(_ + _)
匿名函数:下划线与arg位置匹配.
(1 to 5).map(x => x * x)
匿名函数:要两次使用arg,必须对其进行命名.
(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
咖喱,明显的语法.
def zscore(mean: R, sd: R) =
  (x: R) =>
    (x - mean) / sd
咖喱,明显的语法.
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(_+_)
Varargs.
packages
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 {
  ...
}

单例包:
package object pkg {
  ...
}
声明一个包裹.
数据结构
(1, 2, 3)
元组文字( Tuple3 ).
var (x, y, z) = (1, 2, 3)
破坏绑定:通过模式匹配对元组进行拆包.
Bad
var x, y, z = (1, 2, 3)
隐藏的错误:每个分配给整个元组.
var xs = List(1, 2, 3)
列表(不可变).
xs(2)
Paren索引( 幻灯片 ).
1 :: List(2, 3)
Cons.
1 to 5
如同
1 until 6

1 to 10 by 2
范围糖.
()
空括号是单位类型的单例值.
等效于C和Java中的void .
控制结构
if (check) happy else sad
Conditional.
if (check) happy

如同
if (check) happy else ()
有条件的糖.
while (x < 5) {
  println(x)
  x += 1
}
While循环.
do {
  println(x)
  x += 1
} while (x < 5)
同时执行循环.
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) {
  val div = x / y.toFloat
  println("%d/%d = %.1f".format(x, y, div))
}
理解:命令式的.
sprintf样式 .
for (i <- 1 to 5) {
  println(i)
}
理解:迭代包括上限.
for (i <- 1 until 5) {
  println(i)
}
理解:省略上限.
模式匹配
Good
(xs zip ys) map {
  case (x, y) => x * y
}

Bad
(xs zip ys) map {
  (x, y) => x * y
}
函数args中的用例用于模式匹配.
Bad
val v42 = 42
3 match {
  case v42 => println("42")
  case _   => println("Not 42")
}
v42被解释为与任何Int值匹配的名称,并打印" 42".
Good
val v42 = 42
3 match {
  case `v42` => println("42")
  case _     => println("Not 42")
}
带有反引号的`v42`被解释为现有的val v42 ,并显示" Not 42".
Good
val UppercaseVal = 42
3 match {
  case UppercaseVal => println("42")
  case _            => println("Not 42")
}
UppercaseVal被视为现有val,而不是新的模式变量,因为它以大写字母开头. 因此,将对照3检查UppercaseVal包含的值,并打印" Not 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)
}
构造函数是类主体.
声明一个公共成员.
声明一个可获取但不可设置的成员.
声明一个私人成员.
替代构造函数.
new {
  ...
}
匿名类.
abstract class D { ... }
定义一个抽象类(不可创建).
class C extends D { ... }
定义一个继承的类.
class D(var x: R)

class C(x: R) extends D(x)
继承和构造函数参数(愿望清单:默认情况下自动传递参数).
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")
创建对象.
Bad
new List[Int]

Good
List(1, 2, 3)
类型错误:抽象类型.
相反,约定:可调用的工厂阴影类型.
classOf[String]
类文字.
x.isInstanceOf[String]
键入检查(运行时).
x.asInstanceOf[String]
键入强制类型(运行时).
x: String
归属(编译时间).
options
Some(42)
构造一个非空的可选值.
None
单例为空的可选值.
Option(null) == None
Option(obj.unsafeMethod)
but
Some(null) != None
空安全的可选值工厂.
val optStr: Option[String] = None
如同
val optStr = Option.empty[String]
空可选值的显式类型.
空的可选值的工厂.
val name: Option[String] =
  request.getParameter("name")
val upper = name.map {
  _.trim
} filter {
  _.length != 0
} map {
  _.toUpperCase
}
println(upper.getOrElse(""))
管道样式.
val upper = for {
  name <- request.getParameter("name")
  trimmed <- Some(name.trim)
    if trimmed.length != 0
  upper <- Some(trimmed.toUpperCase)
} yield upper
println(upper.getOrElse(""))
理解语法.
option.map(f(_))
如同
option match {
  case Some(x) => Some(f(x))
  case None    => None
}
在可选值上应用函数.
option.flatMap(f(_))
如同
option match {
  case Some(x) => f(x)
  case None    => None
}
与map相同,但函数必须返回可选值.
optionOfOption.flatten
如同
optionOfOption match {
  case Some(Some(x)) => Some(x)
  case _             => None
}
提取嵌套选项.
option.foreach(f(_))
如同
option match {
  case Some(x) => f(x)
  case None    => ()
}
对可选值应用一个过程.
option.fold(y)(f(_))
如同
option match {
  case Some(x) => f(x)
  case None    => y
}
将函数应用于可选值,如果为空,则返回默认值.
option.collect {
  case x => ...
}
如同
option match {
  case Some(x) if f.isDefinedAt(x) => ...
  case Some(_)                     => None
  case None                        => None
}
将部分模式匹配应用于可选值.
option.isDefined
如同
option match {
  case Some(_) => true
  case None    => false
}
如果不为空,则为true .
option.isEmpty
如同
option match {
  case Some(_) => false
  case None    => true
}
如果为空,则为true .
option.nonEmpty
如同
option match {
  case Some(_) => true
  case None    => false
}
如果不为空,则为true .
option.size
如同
option match {
  case Some(_) => 1
  case None    => 0
}
如果为空则为0 ,否则为1 .
option.orElse(Some(y))
如同
option match {
  case Some(x) => Some(x)
  case None    => Some(y)
}
评估并返回可选的可选值(如果为空).
option.getOrElse(y)
如同
option match {
  case Some(x) => x
  case None    => y
}
评估并返回默认值(如果为空).
option.get
如同
option match {
  case Some(x) => x
  case None    => throw new Exception
}
返回值,如果为空,则抛出异常.
option.orNull
如同
option match {
  case Some(x) => x
  case None    => null
}
返回值,如果为空,则返回null .
option.filter(f)
如同
option match {
  case Some(x) if f(x) => Some(x)
  case _               => None
}
可选值满足谓词.
option.filterNot(f(_))
如同
option match {
  case Some(x) if !f(x) => Some(x)
  case _                => None
}
可选值不满足谓词.
option.exists(f(_))
如同
option match {
  case Some(x) if f(x) => true
  case Some(_)         => false
  case None            => false
}
将谓词应用于可选值;如果为空,则应用false .
option.forall(f(_))
如同
option match {
  case Some(x) if f(x) => true
  case Some(_)         => false
  case None            => true
}
将谓词应用于可选值;如果为空,则为true .
option.contains(y)
如同
option match {
  case Some(x) => x == y
  case None    => false
}
检查value是否等于可选值,如果为空则检查是否为false .

Contributors to this page:

by  ICOPY.SITE