Scalacheat

Languages

Contents

Other Cheatsheets


About

Zahvaljujući Brendan O'Connoru ovaj cheatsheet teži da bude kratki pregled sintakse Scale. Licenca pripada Brendan O'Connor-u, pod CC-BY-SA 3.0 licencom.

Doprinio Brendan O’Connor
   
varijable  
var x = 5 varijabla.
Dobro val x = 5
Loše x=6
konstanta.
var x: Double = 5 eksplicitni tip.
funkcije  
Dobro def f(x: Int) = { x*x }
Loše def f(x: Int) { x*x }
definicija funkcije.
skrivena greška: bez = ovo je procedura koja vraća Unit; uzrokuje zabunu.
Dobro def f(x: Any) = println(x)
Loše def f(x) = println(x)
definicija funkcije.
sintaksna greška: potrebni su tipovi za svaki argument.
type R = Double pseudonim za tip.
def f(x: R) ili
def f(x: => R)
poziv-po-vrijednosti.
poziv-po-imenu (lijeni parameteri).
(x:R) => x*x anonimna funkcija.
(1 to 5).map(_*2) ili
(1 to 5).reduceLeft( _+_ )
anonimna funkcija: donja crta odgovara argumentu po poziciji.
(1 to 5).map( x => x*x ) anonimna funkcija: da bi koristili argument više od jednom, morate mu dati ime.
Dobro (1 to 5).map(2*)
Loše (1 to 5).map(*2)
anonimna funkcija: vezana infiksna metoda. Koristite 2*_ zbog jasnoće.
(1 to 5).map { x => val y=x*2; println(y); y } anonimna funkcija: blokovski stil vraća vrijednost zadnjeg izraza.
(1 to 5) filter {_%2 == 0} map {_*2} anonimne funkcije: pipeline stil (može i sa oblim zagradama).
def compose(g:R=>R, h:R=>R) = (x:R) => g(h(x))
val f = compose({_*2}, {_-1})
anonimne funkcije: da bi proslijedili više blokova, potrebne su dodatne zagrade.
val zscore = (mean:R, sd:R) => (x:R) => (x-mean)/sd curry-jevanje, očita sintaksa.
def zscore(mean:R, sd:R) = (x:R) => (x-mean)/sd curry-jevanje, očita sintaksa.
def zscore(mean:R, sd:R)(x:R) = (x-mean)/sd curry-jevanje, sintaksni šećer (kratica). Ali onda:
val normer = zscore(7, 0.4) _ je potrebna prateća donja crta za parcijalnu primjenu, samo kod šećer (skraćene) verzije.
def mapmake[T](g:T=>T)(seq: List[T]) = seq.map(g) generički tip.
5.+(3); 5 + 3
(1 to 5) map (_*2)
infiksni šećer.
def sum(args: Int*) = args.reduceLeft(_+_) varirajući broj argumenata (varargs).
paketi  
import scala.collection._ džoker (wildcard) import.
import scala.collection.Vector
import scala.collection.{Vector, Sequence}
selektivni import.
import scala.collection.{Vector => Vec28} preimenujući import.
import java.util.{Date => _, _} import svega iz java.util paketa osim Date.
package pkg na početku fajla
package pkg { ... }
deklaracija paketa.
strukture podataka  
(1,2,3) torka (tuple) literal (Tuple3).
var (x,y,z) = (1,2,3) destrukturirajuće vezivanje: otpakivanje torke podudaranjem uzoraka (pattern matching).
Loševar x,y,z = (1,2,3) skrivena greška: svim varijablama dodijeljena cijela torka.
var xs = List(1,2,3) lista (nepromjenjiva).
xs(2) indeksiranje zagradama (slajdovi).
1 :: List(2,3) cons.
1 to 5 isto kao 1 until 6
1 to 10 by 2
šećer za raspon (range).
() (prazne zagrade) jedina instanca Unit tipa (slično kao u C/Java void).
kontrolne strukture  
if (check) happy else sad uslov.
if (check) happy isto kao
if (check) happy else ()
sintaksni šećer za uslov.
while (x < 5) { println(x); x += 1} while petlja.
do { println(x); x += 1} while (x < 5) do while petlja.
import scala.util.control.Breaks._
breakable {
for (x <- xs) {
if (Math.random < 0.1) break
}
}
break (slajdovi).
for (x <- xs if x%2 == 0) yield x*10 isto kao
xs.filter(_%2 == 0).map(_*10)
for komprehensija: filter/map.
for ((x,y) <- xs zip ys) yield x*y isto kao
(xs zip ys) map { case (x,y) => x*y }
for komprehensija: destrukturirajuće vezivanje.
for (x <- xs; y <- ys) yield x*y isto kao
xs flatMap {x => ys map {y => x*y}}
for komprehensija: međuproizvod (vektorski proizvod).
for (x <- xs; y <- ys) {
println("%d/%d = %.1f".format(x, y, x/y.toFloat))
}
for komprehensija: imperativ-asto.
sprintf-stil.
for (i <- 1 to 5) {
println(i)
}
for komprehensija: iteracija uključujući gornju granicu.
for (i <- 1 until 5) {
println(i)
}
for komprehensija: iteracija ne uključujući gornju granicu.
podudaranje uzoraka (pattern matching)  
Dobro (xs zip ys) map { case (x,y) => x*y }
Loše (xs zip ys) map( (x,y) => x*y )
slučaj korištenja u argumentima funkcije.
Loše
val v42 = 42
Some(3) match {
case Some(v42) => println("42")
case _ => println("Not 42")
}
“v42” interpretira se kao ime koje odgovara bilo kojoj vrijednosti Int, i “42” se prikazuje.
Dobro
val v42 = 42
Some(3) match {
case Some(`v42`) => println("42")
case _ => println("Not 42")
}
”`v42`” s kosim apostrofima interpretira se kao postojeća val v42, i “Not 42” se prikazuje.
Dobro
val UppercaseVal = 42
Some(3) match {
case Some(UppercaseVal) => println("42")
case _ => println("Not 42")
}
UppercaseVal tretira se kao postojeća val, a ne kao nova vrijednost uzorka, zato što počinje velikim slovom. Stoga, vrijednost u UppercaseVal se poredi sa 3, i “Not 42” se prikazuje.
objektna orijentisanost  
class C(x: R) isto kao
class C(private val x: R)
var c = new C(4)
parameteri konstruktora - privatni.
class C(val x: R)
var c = new C(4)
c.x
parameteri konstruktora - javni.
class C(var x: R) {
assert(x > 0, "positive please")
var y = x
val readonly = 5
private var secret = 1
def this = this(42)
}

konstruktor je tijelo klase.
deklaracija javnog člana.
deklaracija dostupnog ali nepromjenjivog člana
deklaracija privatnog člana.
alternativni konstruktor.
new{ ... } anonimna klasa.
abstract class D { ... } definicija apstraktne klase (ne može se kreirati).
class C extends D { ... } definicija nasljedne klase.
class D(var x: R)
class C(x: R) extends D(x)
nasljeđivanje i parameteri konstruktora (lista želja: automatsko prosljeđivanje parametara…).
object O extends D { ... } definicija singletona (kao modul).
trait T { ... }
class C extends T { ... }
class C extends D with T { ... }
trejtovi.
interfejs-s-implementacijom. Bez parametara konstruktora. Miksabilan.
trait T1; trait T2
class C extends T1 with T2
class C extends D with T1 with T2
više trejtova.
class C extends D { override def f = ...} moraju se deklarisati prebrisane metode.
new java.io.File("f") kreiranje objekta.
Loše new List[Int]
Dobro List(1,2,3)
greška tipa: apstraktni tip.
umjesto toga, konvencija: fabrika istoimenog tipa.
classOf[String] literal za klasu.
x.isInstanceOf[String] provjera tipa (runtime).
x.asInstanceOf[String] kastovanje tipa (runtime).
x: String askripcija (compile time).