Scala – pierwsze kroki cz.1

Skoro wiemy już dlaczego warto pisać w Scali, możemy zastanowić się co będzie nam do tego potrzebne.

Instalacja Scali

Ponieważ Scala działa na JVM, więc musimy zainstalować zarówno samą Javę (JRE), jak też narzędzia deweloperskie JDK. Wszystko to możemy pobrać bezpośrednio ze strony Oracle wybierając wersję dla naszego systemu operacyjnego. Potrzebna nam najnowsza wersja Java 7 SE. (Wsparcie dla Java 8 pojawi się dopiero w wersji 2.12 języka Scala.) Następnie pobieramy samą Scalę ze strony scala-lang.org wybierając najnowszą wersję (w tym momencie 2.11.2). W przypadku Linuksa możemy też pokusić się o ściągnięcie tego wszystkiego z naszego systemu pakietów. Na Ubuntu wystarczy komenda:

sudo apt-get install scala

Co prawda w pakietach mamy starszą wersję 2.9, ale dla potrzeb nauki w zupełności na razie nam wystarczy. Do pisania większych programów używa się zazwyczaj SBT, które i tak ściąga sobie wersję jaką ustawimy w konfiguracji, więc wersja Scali na komputerze jest drugorzędna.

Praca w IDE

Na początku do nauki będziemy raczej wykorzystywać konsolę interaktywną. Tym niemniej kiedyś będziemy musieli sięgnąć po IDE. Mamy kilka możliwości wyboru:

• ScalaIDE - oficjalne dzieło twórców Scali oparte o Eclipse (lub użycie już posiadanego Eclipse i dodanie wtyczki do Scali)
• IntelliJ IDEA - z pluginem dla Scali
• Netbeans - z pluginem dla Scali
• EMACS - z pluginem Ensime
• każdy prosty edytor tekstu z dostępnym kolorowaniem składni dla Scali (wbrew pozorom wiele osób korzysta, chociażby z VIMa, szczególnie przy krótszych programach lub skryptach)

Linki do trzech pierwszych IDE można znaleźć na podanej już wcześniej stronie.

Interpreter

Jeśli ktoś programował np. w Pythonie to wie czym jest interpreter interaktywny. Służy on sprawdzaniu działania różnych fragmentów naszego kodu. Dzięki temu nie musimy kompilować naszego programu, aby przekonać się, że linijka, którą napisaliśmy nie robi tego co chcemy. Tryb ten jest świetny również do stawiania pierwszych kroków w nauce programowania.

Aby uruchomić interpreter wystarczy wpisać w konsoli polecenie:

scala

Wyświetli nam ono komunikat podobny do poniższego, na końcu którego znajduje się znak zachęty do wpisywania poleceń:

Welcome to Scala version 2.9.2 (OpenJDK 64-Bit Server VM, Java 1.7.0_55).
Type in expressions to have them evaluated.
Type :help for more information.

scala>

W przypadku innych systemów niż Linuks może być konieczne odnalezienie miejsca położenia pliku uruchomieniowego Scali. Jak widać w powyższym komunikacie konsola posiada pomoc. Posługujemy się w niej również ułatwieniami typowymi dla konsoli jak strzałka w górę i w dół pokazująca poprzednie polecenia czy też tabulacja do podpowiadania składni (głównie dostępnych klas i metod).

Krok pierwszy - jak używać interpretera

Wpisujemy w konsoli:

3 + 4

Na co konsola odpowiada napisem:

res0: Int = 7

Widzimy tutaj w jaki sposób zapisuje się zmienne: res0 to nazwa zmiennej (interpreter sam nadaje jej nazwę jeśli my tego nie zrobiliśmy), a Int to typ całkowity (integer). Po znaku równości pojawia się jego wartość. Programujący w Javie zauważą, że nie jest to typ prymitywny int. Jednak w czasie kompilacji, wszędzie gdzie to możliwe, kompilator używa tego typu w celu uzyskania maksymalnej wydajności.

Możemy teraz wykorzystać zmienną res0 mnożąc ją przez 3:

res0 * 3
res1: Int = 21

Do drukowania napisów na standardowym wyjściu używamy funkcji println:

println("Witaj świecie!")
Witaj świecie!

Krok drugi - definiujemy zmienne (i "niezmienniki")

W Scali istnieją dwa typy zmiennych: val i var. Pierwsza jest podobna do zmiennej zdeklarowanej w Javie ze słowem kluczowym final. Jest to stała referencja do obiektu:

val msg = "Witaj świecie!"
msg: java.lang.String = Witaj świecie!

Jak widać, napis jest stringiem z Javy. Nie zadeklarowaliśmy tutaj typu danej, ponieważ w większości przypadków kompilator Scali potrafi rozpoznać ten typ na podstawie tego co przypisujemy po prawej stronie. Równie dobrze moglibyśmy deklarować jawnie:

val msg:String = "Witaj świecie!"
msg: String = Witaj świecie!

Teraz spróbujemy przypisać do msg nowy napis:

msg = "Żegnaj świecie"
<console>:8: error: reassignment to val
       msg = "Żegnaj świecie"

Jak widać nie jest to możliwe. Gdybyśmy jednak w konsoli powtórzyli pierwsze polecenie z tego kroku to okaże się, że wynik będzie identyczny z poprzednim i interpreter nie zwróci błędu ponownego przypisania do niezmiennika. Efekt ten można zobaczyć tylko w konsoli interaktywnej. W programie napisanym w pliku kompilator zwróci nam błąd jeśli zmienne nie będą różniły się zasięgiem. I z ostatniego zdania możemy wywnioskować jak to się dzieje w interpreterze. Po prostu każde polecenie jest następnym poziomem zagnieżdżenia, czyli tworzona jest nowa zmienna o identycznej nazwie, a stara nie jest już dostępna bo przesłoniła ją nowa. Możemy teraz używać zmiennej np.:

println(msg)
Witaj świecie!

Gdy chcemy użyć zmiennej, której zawartość będziemy chcieli podmienić użyjemy słowa kluczowego var:

var powitanie = "Witaj, świecie!"
powitanie: java.lang.String = Witaj, świecie!

Teraz możemy zmienić napis na jaki pokazuje nasz string (zauważ brak na początku var):

powitanie = "Dzień dobry!"
powitanie: java.lang.String = Dzień dobry!

Gdybyśmy spojrzeli na bytecode wyprodukowany przez kompilator to okazałoby się, że w rzeczywistości zmiana wartości zmiennej polega na przypisaniu nowej, podczas gdy starą zajmuje się GC (garbage collector). Programujący w Javie wiedzą, że klasa String nie pozwala na zmianę łańcucha tworzącego napis poprzez podmianę liter. W rzeczywistości tworzymy nowy napis, w razie potrzeby sklejając go z poprzedniego i zmienna pokazuje już na nowy łańcuch znaków. Okazuje się to szybsze i bezpieczniejsze niż tworzenie napisów mutowalnych, takich jak klasa string w C++. W Javie i Scali napisy przypominają const char* z języka C. Projektanci Scali wykorzystali ten sposób dla wszystkich typów danych, przy czym zmiennej typu val nie można już przypisać do innej wartości, co jest możliwe z var.

Jeśli po wpisaniu polecenia nie dokończysz go i dodasz dwie puste linie interpreter przerwie tworzenie polecenia anulując czynność.

val msg:String = 
     | 
     | 
You typed two blank lines.  Starting a new command.

Ważną cechą Scali jest fakt, że nie można zadeklarować pustej zmiennej. Do każdej musi być przypisana wartość początkowa, próba deklaracji zmiennej bez podania jej wartości początkowej kończy się komunikatem:

var msg:String
<console>:7: error: only classes can have declared but undefined members
(Note that variables need to be initialized to be defined)
       var msg:String

Komunikat nie jest jednak zbyt precyzyjny, ponieważ pola klasy mogą nie mieć wartości początkowych jeśli te wartości są przekazywane przez konstruktor klasy.

Edit: Aby wyjść z interpretera wpisujemy :quit albo :q lub exit (działa w Linuksie) bądź wciskamy kombinację klawiszy Ctrl + C

Następna część.