| layout | title | partof | by | about | language |
|---|---|---|---|---|---|
cheatsheet |
Scala Cheatsheet |
cheatsheet |
Brendan O'Connor |
Zahvaljujući <a href="https://brenocon.com/">Brendan O'Connor</a>u ovaj cheatsheet teži da bude kratki pregled sintakse Scale. Licenca pripada Brendan O'Connor-u, pod CC-BY-SA 3.0 licencom. |
ba |
{{ page.about }}
| 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ševal v42 = 42Some(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. |
| Dobroval v42 = 42Some(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. |
| Dobroval UppercaseVal = 42Some(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 = xval readonly = 5private var secret = 1def 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]({{ site.baseurl }}/tutorials/tour/mixin-class-composition.html).
| trait T1; trait T2class C extends T1 with T2class 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). |