なにこれ

• コップ本にだいたい則ってScalaについてまとめたもの。
• Scala勉強会とかで使いたい。
• Scala処理系が入っている前提。

とりあえず触ってみる

• scalaコマンドを実行するとインタプリタが立ち上がる。

   1 scala> 1+1
   2 res0: Int = 2

   1 scala> res0 * 5
   2 res1: Int = 10

• 出力にはprintlnメソッドを使う。
  • printlnメソッドはUnit型の唯一のメンバである()を返す→Javaのvoidに相当

   1 scala> println("Hello, world!")
   2 Hello, world!

変数の定義

   1 scala> val msg = "Hello, world!"
   2 msg: String = Hello, world!

• 上の定義の時にわざわざ型名(String)って書かなかった

• 型が明らかなときは型名を書かなくてもいい→型推論

• もちろん書いてもいい
  • 変数の後ろにコロンを書いて型名

   1 scala> val msg2:String = "Hello, world!"
   2 msg2: String = Hello, world!

varとval

• 変数を定義するときにはvarとvalというキーワードが使える
  • varは何度でも変更できる
  • valは一度しか代入できない

   1 scala> val msg = "Hello, world!!"
   2 <console>:8: error: reassignment to val
   3        msg = "Hello, World!!"

• varはなるべく使わないほうがいい
  • 変数の値をいつでも変えられるというのは強力だけど、同時にどこで変数の値が変わってしまったのかわかりにくくなる
  • 極力valを使い、どうしてもパフォーマンスなどでvarのほうが良い時だけvarを使う。

関数定義

   1 def 関数名(引数名:引数型, 引数名:引数型, ...):戻り値型 = 関数の式

• 具体的な例

   1 def hello(name:String):String = {
   2   return "Hello! " + name
   3 }

• returnは省略できる
  • 最後の式の結果が返される

   1 def hello(name:String):String = {
   2   "Hello! " + name
   3 }

• returnを省略して、かつ戻り値の型が明らかなら戻り値の方も省略できる

   1 def hello(name:String) = {
   2   "Hello! " + name
   3 }

• 一行ならそもそも中括弧もいらない

   1 def hello(name:String) = "Hello! " + name

単独で動くプログラムをつくってみる

• テンプレ
  • 今はおまじないだと思いましょう
  • argsはStringの配列になっていてmainメソッドの引数です。

   1 object hoge
   2   def main(args:Array[String]) = {
   3     //メインの処理
   4   }
   5 }

• かけたらコンパイルします

scalac hoge.scala

• 実行します

scala hoge

• scalacじゃなくてfscを使うと便利です
  • fscを使うと2回目以降コンパイルが速くなる

Scalaらしいループ

• argsの中身を順番に表示するプログラムを書いてみる
• こんなプログラムを書いてみよう
  • scalaでは配列の添字は丸括弧
  • インクリメントの演算子がないのでi += 1で我慢する
  • 行末のセミコロンはいらない

   1 var i = 0
   2 while(i < args.length) {
   3   println(args(i))
   4   i += 1
   5 }

• このプログラムは良くない
  • varがあるから
• 配列にはforeachメソッドというのが用意されている
  • 関数を引数にとってその関数を配列の要素に対して実行する

   1 args.foreach((arg:String) => println(arg))

• argの型はStringなのはわかりきってるのでargの型名は省略できる

   1 args.foreach(arg => println(arg))

配列

• 同じ型しか要素にとれない
• valで宣言しても要素の変更は自由

配列の生成

   1 val hoge = Array[String](3)

配列への代入と参照

   1 hoge(2) = "kyoko"
   2 println(hoge(2))

便利な配列の生成方法

   1 val hoge = Array("Akari", "Kyoko", "Yui", "Chinatsu")

リスト

• 同じ型しか要素にとれない
• 要素の変更は(通常)不可能
  • mutableなリストというのが特別に用意してあって、それを使えば良い。もちろん推奨はされない。

リストの生成

   1 val hoge = List(2, 3, 5, 7)

リストの結合

   1 val hoge = List(2, 3)
   2 val fuga = List(5, 7)
   3 val piyo = hoge ::: fuga

リストの先頭に要素を追加

   1 val hoge = List(3, 5, 7)
   2 val fuga = 2 :: hoge

• これは実は下の糖衣構文になっている。つまりListの::というメソッドを呼び出してる

   1 hoge.::(2)

• ::や:::のことをconsという

タプル

• 違う型の要素も持てる
• 要素の変更は不可能
• 言語の制約上22個しか要素が持てない

タプルを作る

   1 val hoge = (1, "Kyoko", 2, "Akari")

タプルを使う

   1 println(hoge._2)  // Kyoko と表示される
   2 

• タプルの要素番号はHaskellなどの慣習から1番スタートになっている

クラス

• Scalaはオブジェクト指向言語なのでクラスを持っている

   1 class Hoge {
   2   var hoge = 1 //フィールド
   3   var fuga = 3 //フィールド
   4 
   5   def myMultiple() = hoge * fuga //メソッド
   6 }

• Javaとかと同じようにnewでクラスからオブジェクトを生成できる

   1 val a = new Hoge()

• オブジェクトをval宣言の変数に代入しても、そのオブジェクトのフィールドがvar宣言されていれば再代入できる

   1 a.hoge = 2  // OK
   2 

メソッド

• メソッドの引数は勝手にvalで定義される
  • 勝手に変えられないようにするため
• 戻り値がUnitのメソッドは=を省略できる。ただし=を省略すると中括弧を省略できない。
• メソッドをprivateにするには次のように記述する

   1 private def hello() = "Hello, World!"

シングルトンオブジェクト

• Scalaは徹底したオブジェクト指向
  • オブジェクトに属していないものの存在なんて許せない！！！！
  • なのでstaticがありません
• そのかわりにシングルトンオブジェクトというのがある

シングルトンオブジェクトの定義

   1 object Hoge {
   2   // あーだこーだ
   3 

シングルトンオブジェクトの性質

• シングルトンオブジェクトはコードが実行されるときに自動的に生成される
• またあるスコープの中でひとつしかないことが保証される
  • 多分後述
• 先ほど「単独で動くプログラムをつくってみる」の所でobjectうんたらと書いたのは、プログラム実行開始時にシングルトンオブジェクトを生成させてその中のmainメソッドを実行するというふうにScalaが仕組まれているから。

コンパニオンクラスとコンパニオンオブジェクト

• シングルトンオブジェクトと同じ名前のクラスを定義するとそれぞれコンパニオンオブジェクトとコンパニオンクラスと呼ばれるようになって、対で扱われるようになる。
• コンパニオンオブジェクトからはコンパニオンクラスにアクセスすることができる。
• コンパニオンオブジェクトはシングルトンオブジェクトなので、プログラム実行開始時に勝手に生成される。
• なのでstatic代わりに使える。

コンパニオンオブジェクトの例

• https://gist.github.com/j5ik2o/1298006

基本型

• Scalaには次のような型がある
  • 数値型
    • Byte
    • Int
    • Long
    • Short
    • Double
    • Float
    • Char
  • String
  • Boolean

基本リテラル

整数リテラル

• Int, Long, Short, Byte型のリテラル。
• 10進、8進、16進表記可能。

浮動小数点リテラル

• 10進表記のみ。
• 指数表記もできる。

文字リテラル

• シングルクォートでUnicode文字を囲んだもの。

文字列リテラル

• 文字列をダブルクォートで囲ったもの。
• 改行するとそれもそのまま文字列として反映される

シンボルリテラル

• シンボルもやはり文字列を表すためのリテラル
• 次のように表記する

   1 `hoge //hogeのシンボルリテラル
   2 

• 文字列リテラルとの違いは文字列へのシンボルリテラルであれば必ず同じオブジェクトへの参照になっているということ

   1 val hoge = "hoge"
   2 val hoge2 = "hoge" //hogeとhoge2は違うオブジェクトになっている
   3 
   4 val fuga = `fuga
   5 val fuga2 = `fuga //fugaとfuga2は同じオブジェクト
   6 

Booleanリテラル

• TrueとFalseがある

演算子

• 演算子はメソッドです

   1 1 + 2
   2 (1).+(2)  // この2つは同じ意味
   3 

• 演算子の種類はJavaに準ずるので適当にググってね

比較演算子について

• 1つだけ注意を要するのが比較演算子の==
• Javaではオブジェクトとしての等価性を判定するものだった

   1 "hoge" == "hoge" //左と右の文字列は同じオブジェクトかも知れないし違うオブジェクトかもしれないから、TrueかもしれないしFalseかもしれない
   2 

• Scalaでは内部的にJavaのequalsメソッドを呼び出しているので、==はオブジェクトの持っている値そのものの比較になる

   1 "hoge" == "hoge" //かならずTrue
   2 

演算子の優先順位について

• Scalaでは演算子の優先順位は演算子の名前で決まっている
  • 演算子は特別な存在ではなく、ただのメソッドだから
  • 例えば*メソッドは+メソッドよりも優先順位が高いとかいう決め方をしている

リッチラッパー

• ScalaではJavaの演算子に加えてもっと賢い演算子が使えるようになっている
• 例えば

   1 0 min 5 // min演算子で計算されて結果が0になる
   2 

• これはリッチラッパーというクラスによって用意されている。ふだん使うぶんにはリッチラッパーという存在を意識せずにそのまま使うことが出来る。