第15章：Scalaの制御構造

最近、型り（語り）まくっていたけど、今回は制御構造だよ。

Scalaではどんな制御構造があるのでしょうか？

Scalaの制御構造

処理をどのように実行するかを決めること

制御構造をザックし言ってみました。
これを実現するために、多くのプログラミング言語ではifやfor等が用意されています。

Scalaの制御構造以下となっています。

• if
• for
• while
• try
• match
• 関数呼び出し

JVMを使っているからJavaと違いがないと思いきや
やっぱり別言語なので違いがありますね。。

今回は制御構造とあわせて、変数のスコープ等についても紹介していきます。

if

選択構造の代表です。 if式 と呼びます。
以下の記述は違和感なく読むことができると思います。

IfTest1.scala

import java.io.File

object IfTest1 {

  def main(args: Array[String]): Unit = {
    var filename = "config.txt"

    if (!args.isEmpty)
      filename = args(0)

    println("Filename:" + filename)
  }

}

ifの条件式 !args.isEmpty が true に成った場合、
つまりパラメータ指定で実行した時に filename の値を入れ替えます。
if の普通な使い方だと思います。

でもよーく見ると。これイケてないですよね？
変数がイミュータブルになっていないし、再代入しているし。

このような場合例えば Java だと、filename の確定処理をメソッドとして
切りだすと思うのですが、Scala での if は式のため、値を返すことができるのです。

では if が値を返すようにリファクタリングしたソースを見てみよう。

IfTest1Refactor.scala

import java.io.File

object IfTest1Refactor {

  def main(args: Array[String]): Unit = {
    val filename = if (args.isEmpty) "config.txt" else args(0)

    println("Filename:" + filename)
  }

}

変数 filename をイミュータブルに変更することができ
しかも値の確定処理を変数の宣言と共に1行にすることができました。

if を使うと、宣言と値の定義が1箇所に纏まって見やすくなりましたね。

for

繰返構造の代表です。所謂ループってやつです。
for式 と呼びます。

まずは基本的な使い方から。
コンソールで試してみます。

scala> val list = List("Brad Jones", "Steven Gerrard", "Daniel Agger", "Daniel Sturridge")
list: List[java.lang.String] = List(Brad Jones, Steven Gerrard, Daniel Agger, Daniel Sturridge)

scala> for (name <- list) { println(name) }
Brad Jones
Steven Gerrard
Daniel Agger
Daniel Sturridge

Java の拡張 for 文と似ていますね。

ここから for 式のパワーを見てみましょう。

フィルタリング

Java と違って、Scala ではフィルタリングが簡単に実現できます。

scala> for (name <- list if name.startsWith("Daniel")) { println(name) }
Daniel Agger
Daniel Sturridge

Daniel で始まる文字列だけでフィルタリングしてみました。
Java だと Commons Collections を用意したりで、面倒くさくなります。

試しにCommons Collections を使って上のソースと
同じモノをJavaで実現してみました。

JavaFiltering.java

import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

import org.apache.commons.collections.Predicate;
import org.apache.commons.collections.iterators.FilterIterator;
import org.apache.commons.lang3.StringUtils;

public class JavaFiltering {

	public static void main(String[] args) {
		final List<String> list = Arrays.asList("Brad Jones", "Steven Gerrard",
				"Daniel Agger", "Daniel Sturridge");

		final Iterator<String> iterator = new FilterIterator(list.iterator(),
				new Predicate() {

					@Override
					public boolean evaluate(Object object) {
						final String name = (String) object;
						return StringUtils.startsWith(name, "Daniel");
					}
				});

		while (iterator.hasNext()) {
			System.out.println(iterator.next());
		}
	}

}

Scalaだとこの1行ですが

for (name <- list if name.startsWith("Daniel")) { println(name) }

Javaだと、

final Iterator<String> iterator = new FilterIterator(list.iterator(),
		new Predicate() {

			@Override
			public boolean evaluate(Object object) {
				final String name = (String) object;
				return StringUtils.startsWith(name, "Daniel");
			}
		});

while (iterator.hasNext()) {
	System.out.println(iterator.next());
}

のように、 Predicate でフィルタリング条件を作って
フィルタリングする Iterator 作ったりでかなり長くなってしまいました。
完全に冗長に書いてはいますけどね。

Scala は簡単過ぎます！

新しいコレクションの生成

フィルタリングでは繰返の中で値を使いましたが
フィルタリング結果を新しいコレクションにすることも可能です。

scala> val daniels = for { name <- list if name.startsWith("Daniel") } yield name
daniels: List[java.lang.String] = List(Daniel Agger, Daniel Sturridge)

scala> for (name <- daniels) { println(name) }
Daniel Agger
Daniel Sturridge

ここで yield が登場しています。
for は戻り値がないですが、yield を使うと演算結果をコレクションにして
返すことができます。

while

これも繰返構造の代表ですね。
Scala での使い道がわかっていないので
サラッと紹介します。

whileループ

scala> var count = 0;
count: Int = 0

scala> while (count < 5) {
     |   count += 1
     |   println(count)
     | }
1
2
3
4
5

while の条件式が true である間、コードブロックを実行します。

do-while ループ

まずはコードからです。

scala> var count = 0;
count: Int = 0

scala> do {
     |   count += 1
     |   println(count)
     | } while (count < 5)
1
2
3
4
5

while と do-while の違いは、
while は条件式の評価を先にします。
do-while はコードブロックを先に実行し、条件式を評価します。

変数のスコープ

変数の生存範囲ですね。
変数は基本的には中括弧 {} 内でのみ生存できます。

ある生存範囲では、同じ変数を宣言できません。
なので次の場合は、エラーとなります。

scala> {
     |   val variable = "a"
     |   val variable = "b"
     | }
<console>:10: error: variable is already defined as value variable
                    val variable = "b"
                        ^

そして、外側の中括弧で宣言した変数は、その内部の中括弧でも
使用可能です。以下は、外側の中括弧で宣言した変数 count を、
while の中括弧内で使用しています。

scala> {
     |   val variable = "a"
     |
     |   {
     |     println(variable)
     |   }
     | }
a

ここまではJava と変わらないんだけど、最後に「Scala 固有の規則」です。

Scala では、そして、外側の中括弧で宣言した変数は、
その内部の中括弧でも 宣言 可能です。

scala> {
     |   val variable = "a"
     |
     |   {
     |     val variable = "b"
     |     println(variable)
     |   }
     | }
b

この時、 内部の変数は外側の変数をシャドウイングしている と表現します。

実はコンソール上の動きは、シャドウイングしてたりします。

ただこのシャドウイング、ソースを書く上では全く使い道がわからないです。
スコープの小さい if 式とかで、変数名を考えるのが面倒臭い時等に使うくらいかな。

読み辛くなる可能性が高いので、あまり使わない方が良いですね。

例外 (Exception)

例外とは、 処理の異常時に戻り値とは別のやり方で呼出元に通知する仕組み です。
呼出元は例外発生の通知を受け取った時に、以下なことをするのが多いです。

• 上位に更に通知を出す(上位に伝播させる)
• 別の処理(所謂、準正常系や異常系の処理)を実施する

例外を作る (throw)

例外を作るのは簡単です。
以下のようにするだけです。

throw new FileNotFoundException

これで FileNotFoundException という例外を生成して、上位に投げています。
__スローする__と言ったりします。

実際に試してみたのが以下となります。

scala> throw new java.io.FileNotFoundException
java.io.FileNotFoundException
        at .<init>(<console>:8)
        at .<clinit>(<console>)
        at .<init>(<console>:11)
        at .<clinit>(<console>)
        at $print(<console>)
        at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
        at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57)
        at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
        at java.lang.reflect.Method.invoke(Method.java:601)
        at scala.tools.nsc.interpreter.IMain$ReadEvalPrint.call(IMain.scala:704)
        at scala.tools.nsc.interpreter.IMain$Request$$anonfun$14.apply(IMain.scala:920)
        at scala.tools.nsc.interpreter.Line$$anonfun$1.apply$mcV$sp(Line.scala:43)
        at scala.tools.nsc.io.package$$anon$2.run(package.scala:25)
        at java.lang.Thread.run(Thread.java:722)

これで自分で例外の生成ができるようになりますね！

例外を捕える (try/catch)

次に、下位でスローされた例外の通知を検知できるようにします。
__例外をキャッチする__と言ったりします。

__try/catch 節__というのを使います。
ソースをみてみましょう。

コンソールで動かした結果も載せたいので
パッケージ名載せて見辛くなっているはゴメンナサイ。

scala> try {
     |   val input = new java.io.FileInputStream("input.txt")
     | } catch {
     |   case ex: java.io.FileNotFoundException => println("File not found")
     |   case ex: java.io.IOException => println("IOError")
     | }
File not found

例外クラス

まず2つの例外クラスについて説明します

• java.io.FileNotFoundException

  • 実ファイルが存在しない場合にスローされる

• java.io.IOException

  • 書き込みが失敗する等のIO系のエラーが発生した場合にスローされる

java.io.FileInputStream のインスタンスを作った時に
この2つの例外がスローされると予測しています。

catch

例外をキャッチします。
そしてcaseでパターンマッチを行っています。

このソースを実行した時に、「input.txt」というファイルが存在していなかったので
「File not found」と出力されました。

try

どこで発生した例外を対象にするかを決めます。
try で始まる中括弧の中で発生した例外がのみが、
キャッチ対象となるわけです。

finally

例外がスローされると後続の処理が実施されません。
正常系でも例外が発生しても、最後に確実に実行させたい処理がある場合に使用します。

scala> {
     |   val input = new java.io.FileInputStream("input.txt")
     |
     |   try {
     |     throw new java.io.IOException // 明示的に例外をスロー
     |
     |     input.close() // 例外がスローされているので、ここには到達しない
     |   } catch {
     |     case ex: java.io.FileNotFoundException => println("File not found")
     |     case ex: java.io.IOException => println("IOError")
     |   } finally {
     |     println("Finally")
     |     input.close()  // 例外が発生しても、しなくてもここに入ってくる
     |   }
     | }
IOError
Finally

よくあるのがファイルのクローズですね。

Scalaの例外

最後に、Scala ではJava と違ってチェック例外のキャッチが必須ではないです。
チェック例外って何って？

Javaの例外には2種類あります。

• チェック例外
• 非チェック例外

チェック例外

Exception クラスをを継承しているクラスをスローして発生させる例外。
throws を強制される。

上位では以下のいずれかが必要となる。

• キャッチする
• throws 宣言をして、更に上位にスローする

非チェック例外

RuntimeException クラスを継承しているクラスをスローして発生させる例外
throws を強制されない。

上位でのキャッチや throws 宣言は必須ではない。

つまりScala では、Java における 非チェック例外 のように例外を扱えます。

まとめ

制御構造にしてみたけどどうだった？

今回、 match については触れなかったけど、別の機会で語ります。

今回も
体で感じてくれたかな？