Dartプログラミング、メモ

例１）
try {
  breedMoreLlamas();
} on OutOfLlamasException {
  buyMoreLlamas();
}

例２）
try {
  breedMoreLlamas();
} on OutOfLlamasException {
  // A specific exception
  buyMoreLlamas();
} on Exception catch (e) {
  // Anything else that is an exception
  print('Unknown exception: $e');
} catch (e) {
  // No specified type, handles all
  print('Something really unknown: $e');
}

４）finally
　
例外の発生に関わらずあるコードを実行させたい場合は、finally文を使用する。
　
例外が捕捉されなかった場合、例外はfinally文が実行された後で伝播される。

例１）
try {
  breedMoreLlamas();
} finally {
  // Always clean up, even if an exception is thrown.
  cleanLlamaStalls();
}

例２）
try {
  breedMoreLlamas();
} catch(e) {
  print('Error: $e');  // Handle the exception first.
} finally {
  cleanLlamaStalls();  // Then clean up.
}

（１）クラスの概要

（２）オブジェクト

querySelector('#button') // Get an object.
    ..text = 'Confirm'   // Use its members.
    ..classes.add('important')
    ..onClick.listen((e) => window.alert('Confirmed!'));

４）コンスタントコンストラクタ
　
・コンスタントコンストラクタを使ってコンパイル時の定数を作成出来る。
　
この場合は、newキーワードの代わりにconstキーワードを使用する。
　
例）
var p = const ImmutablePoint(2, 2);

class Point {
  num x;
  num y;
  num z = 0;
}

・宣言して値が割り当てられていない変数にはnullが割り当てられている。
　
●暗黙的なgetter、setterメソッド
　
・すべてのインスタンス変数は暗黙的にgetterメソッドが生成される。
・非finalのインスタンス変数は、暗黙的にsetterメソッドが生成される。
・コンストラクタやメソッドではなく、宣言した場所でインスタンス変数を初期化した場合、インスタンス変数が生成される時（コンストラクタとそのイニシャライザリストが実行される前）に値がセットされる。
例）

class Point {
  num x;
  num y;
}

main() {
  var point = new Point();
  point.x = 4;          // xの暗黙的setterメソッド使用
  assert(point.x == 4); // xの暗黙的getterメソッド使用
}

class Point {
  num x;
  num y;

  Point(num x, num y) {
    this.x = x;
    this.y = y;
  }
}

下記のように簡潔に記述する事も出来る。
Point(this.x, this.y);
　
●デフォルトコンストラクタ
　
・コンストラクタを定義されていない場合、デフォルトコンストラクタが提供される。
・デフォルトコンストラクタは引数を持たず、スーパークラスの非引数コンストラクタを呼び出す。
　
●コンストラクタの継承
　
・サブクラスは、スーパークラスからコンストラクタを継承しない。コンストラクタを定義していないサブクラスは、デフォルトコンストラクタのみを持つことになる。
　
●名前付きコンストラクタ
　
・クラス名のあとにドット'.'と識別子を付け、名前付きコンストラクタを定義し、複数のコンストラクタを持たせることができる
例）

class Point {
  num x;
  num y;

  Point(this.x, this.y);

  Point.fromJson(Map json) {
    x = json['x'];
    y = json['y'];
  }
}

●スーパークラスのコンストラクタを明示的に呼び出す
　
下記例のようにコンストラクタのボディの前にコロンとスーパークラスのコンストラクタを記述する。
例）

class Person {
  Person.fromJson(Map data) {
    print('in Person');
  }
}

class Employee extends Person {
  Employee.fromJson(Map data) : super.fromJson(data) {
    print('in Employee');
  }
}

●イニシャライザリスト
　
・コンストラクタのボディが実行される前にインスタンス変数を初期化できる。
・イニシャライザ・リストはコロン':'で始まり、カンマで区切られた個々のイニシャライザ（初期化子ともいう）のリストで構成される。
例）

class Point {
  num x;
  num y;

  Point(this.x, this.y);

  Point.fromJson(Map jsonMap)
      : x = jsonMap['x'],
        y = jsonMap['y'] {
    print('In Point.fromJson(): ($x, $y)');
  }
}

●リダイレクトコンストラクタ
　
・同じクラス内の他のコンストラクタにリダイレクト
例）

class Point {
  num x;
  num y;

  Point(this.x, this.y);

  Point.alongXAxis(num x) : this(x, 0);
}

●常数コンストラクタ
　
・constキーワードを使用。
・すべのインスタンス変数はfinalになる。
例）

class ImmutablePoint {
  final num x;
  final num y;
  const ImmutablePoint(this.x, this.y);
  static final ImmutablePoint origin =
      const ImmutablePoint(0, 0);
}

●ファクトリコンストラクタ
　
・factoryキーワードを使用。
・常にそのクラスの新しいインスタンスを生成するわけでは無い場合に使用。例えば、キャッシュからインスタンスを返したり、サブタイプのインスタンスを返す場合など。
例）

class Logger {
  final String name;
  bool mute = false;

  static final Map _cache =
      {};

  factory Logger(String name) {
    if (_cache.containsKey(name)) {
      return _cache[name];
    } else {
      final logger = new Logger._internal(name);
      _cache[name] = logger;
      return logger;
    }
  }

  Logger._internal(this.name);

import 'dart:math';

class Point {
  num x;
  num y;
  Point(this.x, this.y);

  num distanceTo(Point other) {
    var dx = x - other.x;
    var dy = y - other.y;
    return sqrt(dx * dx + dy * dy);
  }
}

●ゲッターとセッター
　
・ゲッターとセッターは、オブジェクトの属性に対するread、writeアクセスを提供する特別なメソッド。
・それぞれのインスタンス変数は、暗黙的なゲッター、セッターを持つ。
・ゲッターとセッターを使って（get、setキーワードを使用）、追加で属性を定義出来る。
例）

class Rectangle {
  num left;
  num top;
  num width;
  num height;

  Rectangle(this.left, this.top, this.width, this.height);

  num get right             => left + width;
      set right(num value)  => left = value - width;
  num get bottom            => top + height;
      set bottom(num value) => top = value - height;
}

main() {
  var rect = new Rectangle(3, 4, 20, 15);
  assert(rect.left == 3);
  rect.right = 12;
  assert(rect.left == -8);
}

●抽象メソッド（abstractメソッド）
　
・インスタンス、ゲッター、セッターメソッドをabstractにする事が出来る。
抽象メソッドをインタフェースのように定義し、実装は他のクラスで行うといったことが出来る。
　
・ボディ部がないメソッドが抽象メソッドとして扱われる。abstractキーワードは使用しない。
例）

abstract class Doer {
  // インスタンス変数やメソッドを定義
  void doSomething(); // Define an abstract method.
}

class EffectiveDoer extends Doer {
  void doSomething() {
    // 実際の処理内容を記述
  }
}

例）
abstract class AbstractContainer {
  // ...Define constructors, fields, methods...
  void updateChildren(); // Abstract method.
}

例）abstractクラスを使用する例
class SpecializedContainer extends AbstractContainer {
  // ...Define more constructors, fields, methods...

  void updateChildren() {
    // ...Implement updateChildren()...
  }

  // Abstract method causes a warning but
  // doesn't prevent instantiation.
  void doSomething();
}

●暗黙的なインターフェイス(implicit interface)
　
・すべてのクラスは、そのクラスと実装するインタフェースのすべてのインスタンスメンバーを含むインタフェースを暗黙的に定義している。
・あるクラスBを継承せず、BのAPIをサポートするクラスAを作成したい場合、クラスAはBのインタフェースを実装する必要がある。
・一つのクラスは、implementsを使って宣言することによって複数のインタフェースを実装できる。

例）
class Person {
  final _name;
  Person(this._name);
  String greet(who) => 'Hello, $who. I am $_name.';
}

//Personインタフェースを実装
class Imposter implements Person {
  final _name = "";
  String greet(who) => 'Hi $who. Do you know who I am?';
}

greetBob(Person person) => person.greet('bob');

main() {
  print(greetBob(new Person('kathy')));
  print(greetBob(new Imposter()));
}

例）複数のインタフェースを実装
class Point implements Comparable, Location {
// ...
}

例）
class Television {
  void turnOn() {
    _illuminateDisplay();
    _activateIrSensor();
  }
  // ...
}

class SmartTelevision extends Television {
  void turnOn() {
    super.turnOn();
    _bootNetworkInterface();
    _initializeMemory();
    _upgradeApps();
  }
  // ...
}

●オーバーライド
　
・サブクラスは、インスタンスメソッド、ゲッター、セッターをオーバーライドできる。

例）ObjectクラスのnoSuchMethod()をオーバーライドする例
class A {
  void noSuchMethod(Invocation mirror) {
    print('You tried to use a non-existent member:' +
          '${mirror.memberName}');
  }
}

●@overrideアノテーション
　
あるメンバをオーバーライドしていることを明示的に示すのに@overrideアノテーションを指定する事が出来る。

例）
class A {
  @override
  void noSuchMethod(Invocation mirror) {
    // ...
  }
}

●@proxyアノテーション
　
上記例で、noSuchMethod()をすべてのゲッター、セッター、メソッドに対して使用する場合は、@proxyアノテーションを指定すると警告を回避できる。

@proxy
class A {
  void noSuchMethod(Invocation mirror) {
    // ...
  }
}

例）
enum Color {
  red,
  green,
  blue
}

●indexゲッター
　
enumで定義した各値は、0から始まるindexゲッターを持つ。
　
例）
assert(Color.red.index == 0);
assert(Color.green.index == 1);
assert(Color.blue.index == 2);
　
●enum内のすべての値を取得
　
valuesを使って取得
例）
List<Color> colors = Color.values;
assert(colors[2] == Color.blue);
　
●switch文
　

例）
enum Color {
  red,
  green,
  blue
}
// ...
Color aColor = Color.blue;
switch (aColor) {
  case Color.red:
    print('Red as roses!');
    break;
  case Color.green:
    print('Green as grass!');
    break;
  default: // Without this, you see a WARNING.
    print(aColor);  // 'Color.blue'
}

●enumの制限
　
・サブクラス、ミックスイン、enumの実装は出来ない。
・enumを明示的にインスタンス化できない。

例）
class Musician extends Performer with Musical {
  // ...
}

class Maestro extends Person
    with Musical, Aggressive, Demented {
  Maestro(String maestroName) {
    name = maestroName;
    canConduct = true;
  }
}

abstract class Musical {
  bool canPlayPiano = false;
  bool canCompose = false;
  bool canConduct = false;

  void entertainMe() {
    if (canPlayPiano) {
      print('Playing piano');
    } else if (canConduct) {
      print('Waving hands');
    } else {
      print('Humming to self');
    }
  }
}

例）
class Color {
  static const red = const Color('red');
  final String name;      // インスタンス変数
  const Color(this.name); // A constant constructor.
}

main() {
  assert(Color.red.name == 'red');
}

※クラス変数は使用されるまで初期化されない。
　
●クラスメソッド
　
・クラスメソッドはインスタンス上では実行されない。thisキーワードを使ってアクセスする事も出来ない。
　

例）
import 'dart:math';

class Point {
  num x;
  num y;
  Point(this.x, this.y);

  static num distanceBetween(Point a, Point b) {
    var dx = a.x - b.x;
    var dy = a.y - b.y;
    return sqrt(dx * dx + dy * dy);
  }
}

main() {
  var a = new Point(2, 2);
  var b = new Point(4, 4);
  var distance = Point.distanceBetween(a, b);
  assert(distance  2.8);
}

※共通して広範囲に使用されるユーティリティなどはクラスメソッドの代わりにトップレベル関数を使用する事を検討する。
　
※クラスメソッドをコンパイル時定数として使用する事が出来る。例えば、constantコンストラクタの引数としてクラスメソッドを渡す事が出来る。

（String型でリストを使用する場合）
new List<String>();

（指定しない場合）
new List();

この場合Dartは、下記のようにdynamic（未知：unknow）という意味の型が指定されたと解釈する。
new List<dynamic>();
　
●間違ってリスト内に数値を追加した場合にミスである事をチェックできる
　
例）
var names = new List<String>();
names.addAll(['Seth', 'Kathy', 'Lars']);
// ...
names.add(42); // Fails in checked mode (succeeds in production mode).
　
●コードの重複を軽減できる

（総称型を使用しない場合）
abstract class ObjectCache {
  Object getByKey(String key);
  setByKey(String key, Object value);
}
abstract class StringCache {
  String getByKey(String key);
  setByKey(String key, String value);
}

（総称型を使用する場合）
abstract class Cache<T> {
  T getByKey(String key);
  setByKey(String key, T value);
}

●Listとmapでの使用例

var names = <String>['Seth', 'Kathy', 'Lars'];
var pages = <String, String>{
  'index.html': 'Homepage',
  'robots.txt': 'Hints for web robots',
  'humans.txt': 'We are people, not machines'
};

●型テストの為の演算子であるisが使える
　
コンストラクタ内では、型パラメタは実行時に必要であり、それらは実行時に渡されるので、型テストの為の演算子であるisが使える
　
new List<String>() is List<Object> // true: 各文字列はオブジェクトである
new List<Object>() is List<String> // false: 総てのオブジェクトが文字列ではない

例）
import 'package:deferred/hello.dart' deferred as hello;

hello.loadLibrary().then((_) {
  hello.printGreeting();
});

●ライブラリの宣言
　
・"library"を使ってライブラリの名前を指定。
・"part"を使ってライブラリ内に追加で組み入れるファイルを指定。
ライブラリ宣言をしたファイル内に"part fileUri"を使って追加するファイルのパスを指定し、追加するファイル内には"part of identifier"を使ってインポート先のライブラリ名を指定する。

例）
library ballgame;

import 'dart:html';
// ...Other imports go here...

part 'ball.dart';
part 'util.dart';

（bail.dart）
part of ballgame;
// ...Code goes here...

（util.dart）
part of ballgame;
// ...Code goes here...

checkVersion() async {
  var version = await lookUpVersion();
  if (version == expectedVersion) {
    // Do something.
  } else {
    // Do something else.
  }
}

●v1.8で非同期サポートを使用する方法
　
Dartエディタ、dartanalyzer、Dart VM（dart）で非同期サポートを使用する場合、設定を有効にする必要がある。
　
"Preferences"→"Experimental"→"Enable Async Support"
　
※v1.8のDart-to-JSコンパイラ(dart2js)は、非同期をサポートしていない。下記対応が必要。
https://github.com/dart-lang/async_await#async-await-transformer
　
●asyncで関数を宣言
　
例）同期処理から非同期に定義しなおす
String lookUpVersionSync() => '1.0.0';
　　↓
Future<String> lookUpVersion() async => '1.0.0';
　
※関数内でFuture APIを使用する必要はない。Dartが必要に応じてFutureオブジェクトを生成する。
　

例）main関数内全体で利用する場合
main() async {
  checkVersion();
  print('In main: version is ${await lookUpVersion()}');
}

●awaitを使用
　
書式
await expression
　
・"expression"の値は、Future型でなければならず、オブジェクトをリターンするpromiseである。
"await expression"の値は、このリターンされたオブジェクト。

String logger(String msg) {
  var today = new DateTime.now();
  return '${today.toLocal()}-${msg}';
}
void main() {
  var log1 = logger;
  var addLog1 = 1 + log1('My test message1');
  print(addLog1);
}

②typedefを使用した場合
　
下記コードでは、typedefを使用しているので型の情報が維持されて、Dartエディタで警告が発生する。

String logger(String msg) {
  var today = new DateTime.now();
  return '${today.toLocal()}-${msg}';
}
typedef String AliLog(String msg);

void main() {
  AliLog log2 = logger;
  var addLog2 = 2 + log2('My test message2');
  print(addLog2);
}

２）関数を他の関数の引数として渡す例

String logger(String msg) {
  var today = new DateTime.now();
  return '${today.toLocal()}-${msg}';
}
typedef String AliLog(String msg);

num logLength(String msg,log) {
  return log(msg).length;
}

void main() {
  var length = logLength('My test message',logger);
  print(length);
}

３）任意の関数の型をチェック
　
・typedefは単に別名であるので、任意の関数の型をチェックする事も出来る。

例）
typedef int Compare(int a, int b);

int sort(int a, int b) => a - b;

main() {
  assert(sort is Compare); // True!
}

４）サンプルコード
　
Select文でデータを取得し、表示してみました。

import 'package:sqljocky/sqljocky.dart';

void main () {
  var pool = new ConnectionPool(
    host: 'localhost',
    user: 'dbuser',
    password: 'xxxxx',
    db: 'db_name',
    max: 5
  );

  pool.query("select id,total from sample").then((results) {
    results.forEach((row) {
      print('id: ${row[0]}, total: ${row[1]}');
    });
  });
}