その他の言語#

プログラミング言語

教科書該当なし

講義1回分

序論#

本ページでは例外処理，及びここまで取り上げなかったモダンな言語について紹介する．

例外処理#

例外処理は多くのプログラミング言語で採用される基本的な機能であり，実践的なプログラミングにおいて必須知識である．特にJavaでは検査例外が存在しているため，例外を知らずにJavaを使いこなすことはできない．

また例外の理解はデバッグの効率化にも繋がる．例外が発生した際のスタックトレースを理解できれば，エラー発生の原因となった箇所を極めて効率的に絞り込むことができる．

本設ではまず例外処理が必要となる状況を共有し，メソッドの提供者側と利用者側の2つの観点から例外処理の使い方を説明する．

例外の必要性#

Javaによるスタックの実装を例題に，例外の必要性を考える．

public class Main {
    public static void main(String[] args) {
        ArrayStack stack = new ArrayStack();  // 自前のスタック

        stack.push(1);
        stack.push(2);
        System.out.println(stack);  // [1, 2]

        stack.pop();
        stack.pop();
        System.out.println(stack);  // []

        stack.pop();  // ★この時ArrayStackはどう振る舞うべき？
    }
}

public class ArrayStack {
    private int sp;
    private int[] elements;
    public ArrayStack() {
        this.sp = 0;
        this.elements = new int[10];
    }
    public void push(int element) {
        elements[sp++] = element;
    }
    public int pop() {
        // ★過剰なpop()の際にどう振る舞うべきか？
        return elements[--sp];
    }
    ...
}

ArrayStackはint型の値を格納するスタッククラスであり，Mainがそのスタックを利用している．この例では，Mainクラスがスタックに対する過剰なpop()操作を呼び出している．ArrayStackクラスでは過剰pop()の対策を行っていないため，return elements[--sp]の部分で配列外参照が発生してしまいプログラムはクラッシュする．

この場合，ArrayStackクラスはどのように振る舞うのが適切だろうか？ pop()の操作をどのように修正すればよいだろうか？ まずはスタック利用（Main）側ではなく，スタック自体（ArrayStack）がどう振る舞うべきかを考える．

以下のような対策が考えられるが，いずれも問題点がある．

対策1：何も返さない#

public int pop() {
    if (sp - 1 <= 0) return;
    return elements[--sp];
}

👎：そもそもコンパイルできない．int値を返しておらずint pop()というシグネチャのルールに従っていない．

対策2：強制終了する#

public int pop() {
    if (sp - 1 <= 0) System.exit(1);
    return elements[--sp];
}

👎：危険すぎる．利用者が誤って過剰pop()をしてしまうとプログラム全体が強制終了する．配列外参照によるクラッシュとほぼ同様の振る舞いであり，問題は何一つ改善されていない．

対策3：特殊な値を返す#

public int pop() {
    if (sp - 1 <= 0) return -1;
    return elements[--sp];
}

👎：-1という値がスタック中にあったのか，過剰pop()してしまったのか判別できない．また「-1は特殊な値だ」という特殊ルールを利用者側が認識しておく必要がある．

対策4：特殊フラグを設ける#

ArrayStack側にエラーを表す特殊フラグフィールドを作る．

public class ArrayStack {
    private int sp;
    private int[] elements;
    boolean error = false;  // 特殊フラグフィールド
    ...

    public int pop() {
        if (sp - 1 <= 0) {
            this.error = true;  // エラーが発生したらフラグtrue
            return -1;  // この場合返り値は意味をなさない
        }
        return elements[--sp];
    }

Main側ではpop()後にフラグを確認する．

public static void main(String[] args) {
    stack.pop();
    if (stack.error) { ... }

    stack.pop();
    if (stack.error) { ... }

👎：「pop()後にフラグを確認せよ」という特殊ルールを利用者が認識しておく必要がある．

プログラム処理中のエラー発生は，プログラミングにおいて極めて一般的な現象である．

• 配列外参照を行った（elements[--sp] elements[elements.size()]）
• 0除算を行った（y = 1 / x）
• ファイルの作成処理で，すでに同名のファイルが存在していた
• ネットワーク処理中に，何かしらの理由でコネクションが切断された

エラーが発生する条件のチェック自体は難しい問題ではない．スタックに対するpop()の場合if (sp - 1 <= 0)がエラー条件のチェック処理に該当する．問題は「エラーが発生した」という状況を提供者側がどのように表現し，クラスの利用者に伝えるかである．

多くのプログラミングでは，プログラム処理中のエラーの発生を表す方法が言語仕様として設けられている．このエラーのことを例外（exception），例外のハンドル方法を例外処理（exception handling）と呼ぶ．直感的には，returnによる正常時の返り値とは独立に異常時の返り値を定義する方法である．

例外の処理方法：提供者側#

Javaにおける例外処理方法を説明する．対策4（特殊フラグ）と同様，提供者側と利用者側の双方で例外の対策が必要である．提供者は例外を発生させ，利用者が例外を受け取るという処理を加える．

まず提供者側では，特定の状況下で例外を発生させる．

public int pop() throws EmptyStackException { // 例外を宣言に追加
    if (sp - 1 <= 0) {
        throw new EmptyStackException();  // 実際に例外を投げる
        // return ???                     // throwしたらreturn不可（到達不可）
    }
    return elements[--sp];
}

エラー条件if (sp - 1 <= 0)を確認した後，throw節によって例外インスタンスを投げる．throw節は例外を投げた直後にメソッドを終了する命令であり，例外専用のreturn節だと認識しても良い(1)．

1. 正常時はreturnで，異常時はthrowで値を返す，と解釈しても良い．

throw対象であるnew EmptyStackException()はnew節を用いた単なるオブジェクトのインスタンス化である．Javaはオブジェクト指向言語であり，例外そのものもクラスとして表現されている．throw時には例外をインスタンス化して投げる(1)．

1. throw対象のクラスはjava.lang.Throwableクラスを継承している必要がある．

今回の例では，java.utilパッケージのEmptyStackExceptionクラスを投げている．Javaには様々な例外が用意されており，エラーの状況を表す適切な名前の例外クラスを探すと良い．スタック利用者が例外の名前だけを見て，何が起きているのか予想可能な例外クラスを選ぶ．

メソッド内でthrowする際には，必ずシグネチャにthrowsを加え，どのような例外を発生させ得るのかを宣言する必要がある．return節の返り値がint型であることをint pop()のように宣言するのと同じ理由である．シグネチャとはメソッドの仕様である(1)．

1. 複数の例外をメソッド内でthrowしても構わない．この場合，throws Exception1, Exception2のように複数種類の例外が発生する可能性があることを宣言する．

public int pop() throws Exception {
    if (sp - 1 <= 0) {
        throw new EmptyStackException();
    }
    return elements[--sp];
}

EmptyStackException e = new EmptyStackException(); // 普通の宣言
Exception e = new EmptyStackException(); // 親クラスで受けてもOK
Object e = new EmptyStackException(); // さらに親で受けてもOK

String s = new String("a"); // 普通の宣言
Object o = new String("a"); // 親クラスで受けてもOK

例外の処理方法：利用者側#

利用者側ではtry catch節によって例外を掴む必要がある．

try {
    stack.pop();
} catch (EmptyStackException e) {
    ...  // 例外発生時の処理を追加
}

例外を発生させ得るメソッドpop()の呼び出しは，必ずtry { ... }ブロックで囲む必要がある．tryは「失敗するかもしれない処理を試す」というニュアンスである．もしpop()内で例外が投げられた場合，catch() { ... }側に処理が移る．「発生した例外を掴む」というニュアンスである．提供者側がthrow節で投げた例外インスタンスはcatch(例外の型 e)の変数eとして受け取ることができる．

例外発生時にcatch内でどのような処理を行うべきかは状況によって異なる．回復不能な致命的な状況であれば強制終了catch (..) { System.exit(1); }とすることもある．あるいは過剰pop()を無視して良ければcatch (..) {}としても良い．これを例外を握りつぶすとも言う．

例外クラスはprintStackTrace()というメソッドを必ず持っている（継承している）．例外が発生した瞬間のメソッドの呼び出し系列(1)を標準出力に書き出すメソッドである．例外発生の状況把握に役立つため，ひとまずcatch後にはe.printStacktrace()してみると良い．

1. スタックフレームの情報のこと．

try {
    stack.pop();
} catch (EmptyStackException e) {
    e.printStackTrace();  // よくある（一時的な）例外処理
}

標準出力には以下のような内容が書き込まれる．日常的によく見るスタックトレースである．

java.util.EmptyStackException    //  ← 発生した例外の名前
        at jp.osakau.ArrayStack.pop(ArrayStack.java:18)
        at jp.osakau.Main.main(Main.java:13)
 //            ↗      ↗    ↑             ↖
 //  パッケージ名  クラス名  メソッド名   ファイル名:行番号

これまで説明した例外処理を適用済みのMainクラスとArrayStackクラスを以下に示す．

public class Main {
    public static void main(String[] args) {
        ArrayStack stack = new ArrayStack();

        stack.push(1);
        stack.push(2);
        System.out.println(stack);

        try {  // まとめてtry-catchも可，ただし範囲はでできるだけ狭く
            stack.pop();
            stack.pop();
            System.out.println(stack);

            stack.pop();
        } catch (EmptyStackException e) {
            e.printStackTrace(); // 適切な対策が不明なのでひとまずprint
            // TODO              // TODOをつけておくと良い
        }
    }
}

public class ArrayStack {
    private int sp;
    private int[] elements;
    ...

    public int pop() throws EmptyStackException {
        if (sp - 1 <= 0) {
            throw new EmptyStackException();
        }
        return elements[--sp];
    }

検査例外と非検査例外#

Javaには検査例外と非検査例外の2種類の例外がある．検査例外は検査が必須となる例外である．検査していない場合はコンパイルエラーとなる．

検査例外を発生させるメソッドを呼び出す際は，try catchで例外を直接検査するか，throws宣言を加えて例外をさらに親メソッドへ投げる必要がある．他方，非検査例外は例外の検査がオプショナルであり，利用者側で例外の発生を無視することができる(1)．

1. 先の例のEmptyStackExceptionクラスは非検査例外である．つまりMainクラス側でのtry catchを省略してもコンパイル・実行が可能である．

Javaではファイル周りの操作で検査例外が多数設けられている．よってJavaによるファイル操作はプログラムの記述量が多くなりがちである(1)．

1. 他の言語と比較して厳格だといえる．

try {
    Files.delete(Paths.get("tmp.txt"));
} catch (NoSuchFileException e) { // fileがないとき（検査例外）
    ...
} catch (DirectoryNotEmptyException e) {// dirが空でないとき（検査例外）
    ...
}

スレッド周りの処理も検査例外が多い．

try {
    Thread.sleep(1000);
} catch (InterruptedException e) { // スレッドが割り込まれたら
    ..
}

Pythonは全て非検査例外であり検査例外が存在しない．つまり利用者側による例外検査は必須ではない．

import os
os.remove("tmp.txt")

import os
try:
    os.remove("tmp.txt")
except FileNotFoundError:
    ...

 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

public static void main(String[] args) {
    try {
        f1();
    } catch (Exception e) {
        e.printStackTrace();
    }
}
public static void f1() throws Exception {
    f2(); // どうなる？
}
public static void f2() throws Exception {
    throw new Exception();
}

java.lang.Exception:
    at Main.f2(Main.java:14)
    at Main.f1(Main.java:11)
    at Main.main(Main.java:5)

 3
 4
 5
 6
 7
 8
 9
10
11

public static void main(String[] args) throws Exception {
    f1();
}
public static void f1() throws Exception {
    f2();
}
public static void f2() throws Exception {
    throw new Exception();
}

ERROR!
Exception in thread "main" java.lang.Exception:
    at Main.f2(Main.java:10)
    at Main.f1(Main.java:7)
    at Main.main(Main.java:4)

try {
    Files.delete(Paths.get("tmp.txt"));
} catch (NoSuchFileException e) {} // 例外を握りつぶす（無視する）
                                   // ファイルが存在しなければ
                                   // 削除失敗は無視してOK

API仕様の読み方#

オブジェクト指向言語と上記例外の内容を理解できれば，JavaのAPI仕様を読めるようになる．Google等で下手に検索するよりも，公式のAPI仕様を読んだほうが問題解決の近道となる場合が多い．ドキュメントを読む上手さもプログラミングの必須能力だと心がけよ．

以下はjava.nio.file.Files#delete()のAPI仕様である．

delete#

public static void delete(Path path) throws IOException

ファイルを削除します。

（略）

ファイルがディレクトリの場合、ディレクトリは空である必要があります。 （略）

パラメータ:#

• path - 削除するファイルへのパス

例外:#

• NoSuchFileException - ファイルが存在しない場合(オプションの固有例外)
• DirectoryNotEmptyException - ファイルがディレクトリで、ディレクトリが空でないために削除できなかった場合(オプションの固有例外)
• （略）

String s = null;
s.toUpperCase();    // NPE発生

Stack stack = null;
stack.pop();        // NPE発生

List l = null;
l.size();           // NPE発生

ERROR!
Exception in thread "main" java.lang.NullPointerException: Cannot invoke "String.toUpperCase()" because "s" is null
    at Main.main(Main.java:8)

try {
    s.toUpperCase();
} catch (NullPointerException e) {
    ...
}

try {
    System.out.println("Hello World");
} catch (NullPointerException e) {
    ...
}

void f1a() {
  throw new Exception();
}
void f1b() {
  throw new RuntimeException();
}

void f2a() throws Exception {
  throw new Exception();
}
void f2b() throws RuntimeException {
  throw new RuntimeException();
}

void f3a() {
  try {
    throw new Exception();
  } catch(Exception e) {}
}
void f3b() {
  try {
    throw new RuntimeException();
  } catch(RuntimeException e) {}
}

モダンな言語#

ここまで取り上げなかったモダンな言語について紹介する．言語の選定と比較基準はまつ本の主観が多分に含まれている点に注意せよ．

あらかじめ本節の要点をまとめておく．

• 2000年以降も新たな言語が登場している
• 最強の言語は存在しない・一つの言語のみを習得するだけでは不十分である
• 一つの言語を習得できれば他の言語の習得は比較的容易である
• 言語ごとの得意不得意がある・状況に応じて様々な言語を使い分ける必要がある
• 様々な便利な言語機能は登場しているが，本質は大きく変化していない

比較表#

各種言語による階乗計算#

package main

import "fmt"

func factorial(n int) int {
    if n <= 1 {
        return 1
    }
    return n * factorial(n - 1)
}
func main() {
    var ans int = factorial(5)
    fmt.Println(ans) // 120
}

func factorial(n: Int) -> Int {
  if n <= 1 {
    return 1
  }
  return n * factorial(n: n - 1)
}

let ans: Int = factorial(n: 5)  // 120
print(ans)

factorial n = if n <= 0
              then 1
              else n * factorial(n - 1)
main = print (factorial 5)

def factorial(n):
    if n <= 1:
        return 1
    return n * factorial(n - 1)

ans = factorial(5)
print(ans)  # 120

fn factorial(n : i32) -> i32 {
    if n <= 1 {
        return 1;
    }
    return n * factorial(n - 1);
}

fn main() {
    let ans = factorial(5);  // 120
    println!("{}", ans);
}

function factorial(n) {
    if (n <= 1) {
        return 1;
    }
    return n * factorial(n - 1);
}

ans = factorial(5);
console.log(ans);  // 120

function factorial(n: number) : number {
    if (n <= 1) {
        return 1
    }
    return n * factorial(n - 1)
}

let ans: number = factorial(5)
console.log(ans)  // 120

int i = 10;
String s = "hi";

var i int = 10;
var s string = "hi";

def create_user(name, age):  # 関数の宣言
    ...

create_user("shinsuke", 42)          # 順序で引数を紐づけ
create_user(name="shinsuke", age=42) # 名前付き引数
create_user(age=42, name="shinsuke") # 名前があるので順序を変えてもOK

JSフレームワーク#

Angular Vue.js React Svelteなど

• JavaScriptフレームワーク（プログラミング言語ではない）
• Webフロントエンド開発（HTML+CSS+JS）のための仕組み

文字列が英数字のみかをチェックする例：

PureJS

<input type="text">
<p class="msg"></p>
<p class="error" style="display:none">Invalid uid!!</p>

<script>
const validateUid = function(e) {
  const uid = e.target.value;
  document.querySelector('.msg').innerText = uid;

  if (!uid.match(/^[a-zA-Z0-9]*$/)) {
    document.querySelector('.error').style.display = null;
  } else {
    document.querySelector('.error').style.display = 'none';
  }
}
const elem = document.querySelector('input');
elem.addEventListener('input', validateUid);
</script>

Svelte

<input bind:value={uid} on:input={validateUid}>
<p>{uid}</p>
{#if isInvalid}
    <p>Invalid uid!!</p>
{/if}

<script>
    let uid = '';
    let isInvalid = false;
    let validateUid = function() {
        isInvalid = !uid.match(/^[a-zA-Z0-9]*$/);
    }
</script>

ゼミA楠本研でSvelteをやります．

《宿題》#