（前半省略） -Xms40m -Xmx1000m -Dhttp.proxyHost=proxy.example.com -Dhttp.proxyPort=8080 -Dhttp.proxyUser=account_name -Dhttp.proxyPassword=account_passwordDart Editor 0.6.21_r26639 と、Windows XP および Ubuntu 13.04 の環境で確認しました。
import ('dart:async');
Future<String> asyncTask() {
var c = new Completer<String>();
// ここで非同期処理を実行する。
// Completer#future を返す。
return c.future;
}
void main() {
asyncTask()
.then(print)
.catchError((e) => print('ERROR: $e'));
}
非同期処理が完了したことを通知するためには Completer#complete を使います。
同じように、エラーが発生したことを通知するためには Completer#completeError を使います。import ('dart:async');
Future<String> asyncTask() {
var c = new Completer<String>();
// 非同期処理
const ONE_SEC = const Duration(seconds: 1);
new Timer(ONE_SEC, () {
c.complete('Pass');
// エラーの時は
// c.completeError('Fail');
});
// Completer#future を返す。
return c.future;
}
void main() {
asyncTask()
.then(print)
.catchError((e) => print('ERROR: $e'));
}
実行すると 1 秒後に then で登録した関数が呼びだされ、結果が表示されます。dependencies: unittest: anyできたら pub install を実行します（Dart Editor の場合は自動で実行されます）。
import 'dart:async';
import 'package:unittest/unittest.dart';
String syncTask() => 'Pass';
void main() {
test('Test a function', () {
expect(syncTask(), equals('Pass'));
});
}
これに対して非同期処理のテストコードは次のようになります。
import 'dart:async';
import 'package:unittest/unittest.dart';
Future<String> asyncTask() {
var c = new Completer<String>();
const ONE_SEC = const Duration(seconds: 1);
new Timer(ONE_SEC, () => c.complete('Pass'));
return c.future;
}
void main() {
// テスト
test('Test a future', () {
asyncTask().then(
expectAsync1(
(e) => expect(e, equals('Pass'))));
});
}
Future#then や Future#catchError などに expectAsync1（1 は引数の個数）で取得した関数を渡してテストします。
同期処理のテストと若干が違いますが、おおよそ似たような形で書くことができます。import ('dart:async');
Future<String> asyncTask1() { /* ... */ }
Future<String> asyncTask2(String s) { /* ... */ }
main() {
Future<String> f1 = asyncTask1();
Future<String> f2 = f1.then((s) {
return asyncTask2(s);
});
f2.then((s) => print(s));
}
Future#then に指定したコールバック関数が Future のインスタンスを返す場合（つまりこのコードの return asyncTask2(s) のようになっている場合）、元々の Future（f1）と連結された新しい Future が then の戻り値（f2）となります。
したがってこのように書くと、asyncTask1 で生成された Future の処理が完了したあとに asyncTask2 で生成された Future が続けて処理されるようになります。import ('dart:async');
Future<String> asyncTask1() { /* ... */ }
Future<String> asyncTask2(String s) { /* ... */ }
main() {
asyncTask1()
.then((s) => asyncTask2(s))
.then((s) => print(s));
// あるいは
asyncTask1()
.then(asyncTask2)
.then(print);
}
import ('dart:async');
Future<String> asyncTask1() {
// ここでエラーが発生しても...
}
Future<String> asyncTask2(String s) {
// ここでエラーが発生しても...
}
main() {
asyncTask1()
.then(asyncTask2)
.catchError((e) { /* ここでエラーが処理できる。 */ })
.whenComplete(() { /* ここは最後に実行される。 */ });
}
見た目は少し異なりますが、try-catch と同じように扱えると考えれば迷わないでしょう。import ('dart:async');
Future asyncTask(String s) { /* ... */ }
main() {
List<String> strs = ['a', 'b', 'c'];
// strs の要素が一つずつ渡されて処理される。
Future f = Future.forEach(strs, asyncTask);
// 最後の要素が処理されると呼び出される。
f.then((_) => print('Completed.'));
}
Future を then でつなげていった時と同じように、'a' の処理が終わったら 'b'、'b' の処理が終わったら 'c'、すべて終わったら最後の then という順番で処理されます。import ('dart:async');
Future asyncTask(String s) { /* ... */ }
main() {
// List に複数の Future を入れておく。
List<Future> fs = [
asyncTask('a'),
asyncTask('b'),
asyncTask('c')
];
// まとめて待つ。
Future f = Future.wait(fs);
f.then((_) => print('Completed.'));
}
List に入っている３つの Future はそれぞれ非同期に実行され、すべての Future が完了した時点で最後の Future の then に登録した関数が呼ばれます。
それぞれの結果はやはり捨てられますので、結果は別のオブジェクトに保存するなどしてください。 import ('dart:async');
void main() { /* ... */ }
同期的な関数は戻り値として処理結果を返します。エラーが発生した場合には例外を送出します。
// 同期的な関数
String concat(String a, String b) {
return a + b;
}
void main() {
// Hello world
print(concat('Hello ', 'world'));
}
concat 関数から戻った時点で print 関数へ渡す結果が出ています。これに対して非同期的な関数では、関数から戻った時点では結果が出ているかどうか分かりません。そのような場合、Dart の関数は Future のインスタンスが返るようになっています。処理が終わると Future#then で指定した関数がコールバックされますので、そこに結果の処理を記述します。
import ('dart:async');
// 非同期的な関数
Future<String> asyncTask() { /* ... */ }
void main() {
// Future を受け取る。
var f = asyncTask();
// Future#then に完了時の処理を書く。
f.then((String s) => print(s));
}
実践的なプログラミングでは次のように短く書かれます。
import ('dart:async');
Future<String> asyncTask() { /* ... */ }
void main() {
asyncTask().then(print);
}
import ('dart:async');
Future<String> asyncTask() {
// 非同期処理中にエラーが発生したり...
}
void main() {
asyncTask().then(
(s) {
// コールバック関数内で例外が発生すると...
},
// onError が呼び出される。
onError: (e) => print('ERROR: $e'));
}
あるいは Future#catchError を使って次のように書くこともできます。
import ('dart:async');
Future<String> asyncTask() { /* ... */ }
void main() {
asyncTask()
.then(print)
.catchError((e) => print('ERROR: $e'));
}
エラーの処理では、エラーの型や内容によって処理を分けることがよくあります。Future#catchError では test 引数に bool 型の戻り値を持つ関数を渡し、そのコールバック関数でエラーを処理するかどうかを決められます。test 引数で指定した関数が true を返すとコールバック関数が呼び出され、false を返すと呼び出されません。
import ('dart:async');
Future<String> asyncTask() { /* ... */ }
void main() {
asyncTask()
.then(print)
// int の場合はこちら
.catchError((e) => print('ERROR No.$e'),
test: (e) => e is int)
// String の場合はこちら
.catchError((e) => print('ERROR Message: $e'),
test: (e) => e is String);
}
then と catchError を使った書き方は、同期処理における try-catch 構文に相当します。非同期処理と then で登録する関数は try ブロック、catchError で登録する関数は catch ブロックの処理に対応しています。そして finally に相当する Future#whenComplete も用意されています。
import ('dart:async');
Future<String> asyncTask() { /* ... */ }
void main() {
asyncTask()
.then(print)
.catchError((e) => print('ERROR No.$e'),
test: (e) => e is int)
.catchError((e) => print('ERROR Message: $e'),
test: (e) => e is String)
.whenComplete(() => print('Completed.'));
}
正常に終了した場合は then と whenComplete、エラーが発生した場合は catchError と whenComplete で登録した関数が順に呼ばれます。 <ul> <li id="bull">Bull<li> <li id="cat">Cat<li> <li id="dog">Dog<li> </ul>人気投票をしたところ Cat が 1 位になったので、太字にして王冠のイラストを追加してみましょう。
var licat = document.query('#cat');
licat.append(new Element.html('<img src="crown.png">'))
licat.style.fontWeight = 'bold';
カスケード呼び出し（..）を使うと次のように書くことができます。document.query('#cat')
..append(new Element.html('<img src="crown.png">'))
..style.fontWeight = 'bold';
先のコードに比べて読みやすい形で表現されていると思います。呼び出すメソッドの数が増えるほどカスケード呼び出しを使うメリットが増えます。document.query('#cat') の戻り値は li 要素になります。子要素を追加する append メソッドを普通に呼び出すと、その戻り値は追加した要素、つまりここでは img 要素です。しかし .. を使って呼び出すと、元々のメソッドの戻り値は無視され、元のオブジェクトが返ってきます。var img = new Element.html('<img src="crown.png">');
// e は追加した子要素（つまり img 要素）
var e = document.query('#cat').append(img);
// f は document.query('#cat') の値（li 要素）
var f = document.query('#cat')..append(img);
カスケード オペレーターでは結果が元のオブジェクトになるので、同じオブジェクトに対して次のメソッドを呼び出すことができるわけです。.. は [] にも使うことができます。document.query('#cat').attributes
..['style'] = 'color: red'
..['title'] = 'popular';
void main() {
Options opt = new Options();
print("executable=${opt.executable}");
print("script=${opt.script}");
opt.arguments.forEach((e) => print("argument=$e"));
}
このコードをDart Editor上で実行してみましょう。スクリプトへの引数はManage LaunchesのウィンドウからScript arguments欄に設定することができます。
executable=/home/dart-ing/Downloads/dart/dart-sdk/bin/dart script=/home/dart-ing/dart/OptionsTest/OptionsTest.dart argument=abc argument=123
void main() {
int a = 0;
try {
a.length;
} catch (final NoSuchMethodException e) {
print(e);
}
}
このコードではint型の変数のlengthプロパティを参照していますが、そのようなプロパティ（getterメソッド）はint型には存在しないので NoSuchMethodException が発生します。これを catch で受け取っています。void main() {
int a = 0;
try {
a.length;
} catch (final var e) {
/* ここが実行されます。 */
}
try {
a.length;
} catch (final NoSuchMethodException e) {
/* ここが実行されます。 */
} catch (final e) {
/* ここは実行されません。 */
}
}
例外発生箇所のスタックトレースを受け取るには、catch の2つめの要素として指定します。
void main() {
int a = 0;
try {
a.length;
} catch (final NoSuchMethodException e, var stack) {
print("exception: $e");
print("stack: $stack");
/*
exception: NoSuchMethodException : method not found: 'get:length'
Receiver: 0
Arguments: []
stack: 0. Function: 'Object.noSuchMethod' url: 'bootstrap' line:2698 col:3
1. Function: '::main' url: 'file:///home/dart-ing/dart/ExceptionTest/ExceptionTest.dart' line:4 col:13
*/
}
}
このように例外を簡単に受け取ることができますが、実際には例外の発生を予期するのは難しいことです。コードの中で受け取られなかった例外は、実行環境側へ渡されて Unhandled exception としてそれぞれの方法で処理されます。void main() {
int a = 0;
try {
a.length;
} catch (final NoSuchMethodException e) {
print(e);
}
finally {
print("finally");
}
}
この場合、catch による例外処理が行われてから、最後に finally が実行されます。 void main() {
try {
throw new Exception("message");
} catch (final Exception e) {
print(e); // Exception: message
}
}
[Desktop Entry] Version=1.0 Type=Application Terminal=false StartupNotify=true Icon=Dartを展開したパス/icon.xpm Name=Dart Editor Comment=Dart IDE Exec=Dartを展開したパス/DartEditor Categories=Development;IDE;IconとExecに設定するパスは環境にあわせて設定してください。例えば、私の場合は /home/dart/Downloads にダウンロードしてその場所で展開しましたので、次のようになりました。
nacci(List実行結果：sequence) { int type = sequence.length; return calc(int n) { if (sequence.length < n + 1) { int value = 0; for (int i = 1; i <= type; i++) { value += calc(n - i); } sequence.add(value); } return sequence[n]; }; } void main() { var fibo = nacci([0, 1]); var tri = nacci([0, 0, 1]); var tetra = nacci([0, 0, 0, 1]); var lucas = nacci([2, 1]); for (int i = 0; i <= 10; i++) { print("$i : ${fibo(i)}, ${tri(i)}, ${tetra(i)}, ${lucas(i)}"); } }
0 : 0, 0, 0, 2 1 : 1, 0, 0, 1 2 : 1, 1, 0, 3 3 : 2, 1, 1, 4 4 : 3, 2, 1, 7 5 : 5, 4, 2, 11 6 : 8, 7, 4, 18 7 : 13, 13, 8, 29 8 : 21, 24, 15, 47 9 : 34, 44, 29, 76 10 : 55, 81, 56, 123
main() {
int i = Math.parseInt("123");
double d = Math.parseDouble("1.23");
print("i=$i, d=$d");
}
変換に失敗するとBadNumberFormatException例外が発生します。main() {
// 大きな数（1e+30）
print(Math.parseInt("1000000000000000000000000000000"));
// 16進数（10）
print(Math.parseInt("0xA"));
// 指数表現（10）
print(Math.parseDouble("1e+1"));
}
main() {
int i = 1;
print("$i, ${i.toString()}"); // 1, 1
}
書式を指定するにはnumクラスに用意されている次のメソッドを使います。void main() {
print("123=${123.toRadixString(10)}(10)"); // 123(10)
print("123=${123.toRadixString(16)}(16)"); // 7b(16)
print("123=${123.toStringAsExponential(1)}"); // 1.2e+2
print("123=${123.toStringAsExponential(2)}"); // 1.23e+2
print("123=${123.toStringAsExponential(3)}"); // 1.230e+2
print("123.45=${(123.45).toStringAsFixed(1)}"); // 123.5
print("123.45=${(123.45).toStringAsFixed(2)}"); // 123.45
print("123.45=${(123.45).toStringAsFixed(3)}"); // 123.450
print("123.45=${(123.45).toStringAsPrecision(2)}"); // 1.2e+2
print("123.45=${(123.45).toStringAsPrecision(3)}"); // 123
print("123.45=${(123.45).toStringAsPrecision(4)}"); // 123.5
}
// テストコードを含む典型的なJavaのコード
// インターフェイス
interface IDuck {
void quack();
}
// 実装クラス
class Duck implements IDuck {
void quack() { /* ... */ }
}
// テスト用のモック クラス
class MockDuck implements IDuck {
void quack() { /* ... */ }
}
本来、実装に必要なのはDuckクラスだけですが、自動テストのためにIDuckインターフェイスを作り、そこからテスト用のモック クラスを用意しています。モックを自動生成するライブラリもいくつかありますが、設定の手間が必要だったり、コードがJavaの言語仕様からみると不自然な感じになったりしてしまいます。（それでも便利ですが）// 実装クラス
class Duck {
quack() => 'complicated enterprise n-tier quack';
}
// テスト用のモック クラス
// Duckクラスを実装（implements）する。
class MockDuck implements Duck {
quack() => 'quack for testing';
}
main() {
Duck duck = new MockDuck();
print(duck is Duck); // true
print(duck.quack()); // quack for testing
}
MockDuckクラスはDuckクラスを実装（implements）しています。もちろん、MockDuckではquackメソッドを実装する必要があります。
$ cat test.dart
main() { int a = 'a'; }
$ dart --enable_checked_mode test.dart
Unhandled exception:
type 'OneByteString' is not a subtype of type 'int' of 'a'.
0. Function: '::main' url: 'file:///test.dart' line:1 col:18
$ cat test.dart
main() { int a = 'a'; }
$ frogc test.dart
test.dart:1:18: warning: type "dart:core.String" is not assignable to "dart:core.int"
main() { int a = 'a'; }
^^^
void main() {
// 処理１
// 処理２
}
このプログラムは、処理１が終わってから処理２が実行されます。処理２が処理１の結果を受け取って処理される（処理２は処理１の結果に依存している）のであれば、この順で書くしかありません。たとえば次のような例が考えられます。
void main() {
double a, b;
a = Math.random(); // 処理１
b = a * 2; // 処理２
}
このプログラムは、処理１の結果であるaの値が定まらないと、処理２の結果であるbの値も定まりません。void main() {
// 処理２
// 処理１
}
もしこのように書けるのであれば、処理１を別の関数やクラスに追い出すこともできます。しかし逐次型プログラミングではこのような書き方はできません。void main() {
final Completer<double> comp = new Completer<double>();
final Future<double> fut = comp.future;
fut.then((double a) {
// 処理2
double b = a * 2;
print("b=${b}");
});
// 処理1
double a = Math.random();
print("a=${a}");
comp.complete(a);
}
実行例
a=0.00013735424727201462 b=0.00027470849454402924Completer<T>の型パラメーターTは、処理が終わったあとに受け取る値の型です。Completerのfutureプロパティで、そのCompleterで処理が終わったときに呼び出されるFutureのインスタンスが取得できます。このFutureインスタンスの型パラメーターもTになります。
void main() {
final Completer comp = new Completer();
final Future fut = comp.future;
fut.then((double a) {
double b = a * 2;
print("b=${b}");
});
fut.handleException((Object exception) {
print("exception=${exception}"); // exception=Error!
return true;
});
// 処理で発生したエラーをFutureに伝える。
comp.completeException("Error!");
}
void main() {
final Completer<int> comp1 = new Completer<int>();
final Completer<int> comp2 = new Completer<int>();
comp1.future.chain((int a) {
print("a=${a}");
return comp2.future;
}).then((int b) {
print("b=${b}");
});
// comp1とcomp2のcomplete順を入れ替えても結果は同じ。
// a=1
// b=2
comp1.complete(1);
comp2.complete(2);
}
void main() {
final Completer comp = new Completer();
// 単純なFuture
comp.future.then((int a) { print("a=${a}"); });
// 変換処理を伴うFuture
final Future tf = comp.future.transform((int a) => a * 2);
tf.then((int b) { print("b=${b}"); });
comp.complete(1);
}
実行結果
a=1 b=2
void main() {
final Completer<int> comp1 = new Completer<int>();
final Completer<int> comp2 = new Completer<int>();
// 複数のFutureがすべて完了するまで待つ。
final Future<List<int>> fs =
Futures.wait([ comp1.future, comp2.future ]);
fs.then((List<int> results) {
// 結果をすべて表示する。
for (int result in results) {
print("result=${result}");
}
});
// 完了
comp1.complete(1);
comp2.complete(2);
}
実行結果
result=1 result=2
