Dart 言語仕様ガイド

var name = 'Alice';          // 型推論: String
String greeting = 'Hello';   // 明示的型宣言

final birthYear = 1990;      // 一度だけ代入可（実行時定数）
const pi = 3.14159;          // コンパイル時定数

// const はコレクションも不変にする
const colors = ['red', 'green', 'blue'];
// colors.add('yellow'); // エラー: Unsupported operation

String  nonNull = 'hello';  // null 不可
String? nullable = null;    // null 許容

// ?? : null のとき右辺を使う
String display = nullable ?? 'default';

// ?. : null のとき null を返す（例外を投げない）
int? len = nullable?.length;  // null

// ! : null でないと確信するときのキャスト（nullならエラー）
String forced = nullable!;    // 実行時 Null check operator used on a null value

int    count   = 42;
double ratio   = 3.14;
bool   isReady = true;
String label   = 'Dart';
num    value   = 100;      // int か double を受け取れる

dynamic anything = 'text';
anything = 123;            // 型を後から変えられる（型チェックなし）

Object obj = 'hello';      // null 不可の最上位型
Object? any = null;        // null も受け取れる最上位型

class Config {
  late String databaseUrl;  // 後で代入することを宣言

  void init(String url) {
    databaseUrl = url;      // 最初のアクセス前に代入必須
  }
}

// late + lazy initialization（アクセス時に一度だけ評価）
late String expensive = _computeExpensiveValue();

String _computeExpensiveValue() {
  print('計算中...');
  return 'result';
}

int score = 75;

if (score >= 80) {
  print('合格');
} else if (score >= 60) {
  print('補欠');
} else {
  print('不合格');
}

// 三項演算子
String result = score >= 60 ? '合格' : '不合格';

// Dart 3: if 式（コレクション内などで使用）
var label = if (score >= 80) '優秀' else '普通';

// 従来の switch 文
String day = 'Monday';
switch (day) {
  case 'Saturday':
  case 'Sunday':
    print('週末');
    break;
  default:
    print('平日');
}

// Dart 3: switch 式（値を返す）
int code = 2;
String label = switch (code) {
  1 => '低',
  2 => '中',
  3 => '高',
  _ => '不明',
};
print(label); // 中

// C スタイル for
for (int i = 0; i < 3; i++) {
  print(i); // 0 1 2
}

// for-in（Iterable を反復）
var fruits = ['apple', 'banana', 'cherry'];
for (var fruit in fruits) {
  print(fruit);
}

// while
int n = 0;
while (n < 3) { n++; }

// do-while（必ず 1 回実行）
do {
  print('executed');
} while (false);

Object value = [1, 2, 3];

// リストパターン
switch (value) {
  case [int a, int b, int c]:
    print('3要素リスト: ${a + b + c}'); // 6
  case []:
    print('空リスト');
  default:
    print('その他');
}

// guard（when）節
int x = 42;
switch (x) {
  case int n when n > 0:
    print('正の整数: $n');
  case int n when n < 0:
    print('負の整数: $n');
  case 0:
    print('ゼロ');
}

// 名前付きオプション引数
void greet({required String name, String greeting = 'Hello'}) {
  print('${greeting}, ${name}!');
}
greet(name: 'Alice');               // Hello, Alice!
greet(name: 'Bob', greeting: 'Hi'); // Hi, Bob!

// 位置オプション引数（[] で囲む）
String join(String a, [String b = '', String c = '']) {
  return '${a}${b}${c}';
}
print(join('x'));       // x
print(join('x', 'y')); // xy

// 通常の関数
int add(int a, int b) {
  return a + b;
}

// アロー関数（=> は単一式のみ）
int addArrow(int a, int b) => a + b;

// 匿名アロー関数（クロージャ）
var square = (int n) => n * n;
print(square(5)); // 25

// メソッドでも使える
class Circle {
  double radius;
  Circle(this.radius);
  double get area => 3.14159 * radius * radius;
}

// 関数を変数に代入
Function multiply = (int a, int b) => a * b;
print(multiply(3, 4)); // 12

// 高階関数（関数を引数に受け取る）
List<int> nums = [1, 2, 3, 4, 5];
List<int> evens = nums.where((n) => n.isEven).toList(); // [2, 4]
List<int> doubled = nums.map((n) => n * 2).toList();    // [2, 4, 6, 8, 10]

// クロージャ（外側のスコープを捕捉）
Function makeAdder(int x) => (int y) => x + y;
var add5 = makeAdder(5);
print(add5(3)); // 8

// typedef で関数型に名前を付ける
typedef Predicate<T> = bool Function(T value);
typedef Transformer = String Function(String input);

bool isPositive(int n) => n > 0;
Predicate<int> check = isPositive;
print(check(5));  // true
print(check(-1)); // false

// typedef は通常の型エイリアスにも使える（Dart 2.13+）
typedef StringList = List<String>;
StringList names = ['Alice', 'Bob'];

// List
List<String> fruits = ['apple', 'banana'];
fruits.add('cherry');
print(fruits.length);   // 3
print(fruits[0]);       // apple

// Map
Map<String, int> scores = {'Alice': 90, 'Bob': 85};
scores['Charlie'] = 78;
print(scores['Alice']); // 90

// Set（重複なし）
Set<int> nums = {1, 2, 3, 2, 1};
print(nums); // {1, 2, 3}

// 空コレクションのリテラル
var emptyList = <String>[];
var emptyMap  = <String, int>{};
var emptySet  = <double>{};

var a = [1, 2, 3];
var b = [4, 5, 6];

// spread で結合
var combined = [...a, ...b];
print(combined); // [1, 2, 3, 4, 5, 6]

// null 安全 spread（...?）
List<int>? maybeNull;
var safe = [0, ...?maybeNull, 9];
print(safe); // [0, 9]

// Map の spread
var defaults = {'color': 'blue', 'size': 'M'};
var custom   = {'size': 'L', 'weight': 'light'};
var merged   = {...defaults, ...custom};
print(merged); // {color: blue, size: L, weight: light}

bool showAdmin = true;
List<String> menu = [
  'Home',
  'Profile',
  if (showAdmin) 'Admin',       // 条件付き追加
];
print(menu); // [Home, Profile, Admin]

// Collection for
var items = [for (int i = 1; i <= 3; i++) 'item_$i'];
print(items); // [item_1, item_2, item_3]

// 組み合わせ
var evens = [
  for (int i = 0; i <= 10; i++)
    if (i.isEven) i,
];
print(evens); // [0, 2, 4, 6, 8, 10]

Iterable<int> nums = [1, 2, 3, 4, 5];

// 遅延評価チェーン（終端操作まで実行されない）
var result = nums
    .where((n) => n.isOdd)    // [1, 3, 5]
    .map((n) => n * 10)       // [10, 30, 50]
    .toList();                // Listに具現化
print(result); // [10, 30, 50]

// 集約
int sum = nums.fold(0, (acc, n) => acc + n);
print(sum); // 15

bool hasEven = nums.any((n) => n.isEven);  // true
bool allPos  = nums.every((n) => n > 0);   // true

String name = 'Alice';
int age = 30;

// 変数の埋め込み（$ のみ）
print('Hello, $name!');          // Hello, Alice!

// 式の埋め込み（${} を使う）
print('来年は ${age + 1} 歳');    // 来年は 31 歳

// ネストした式も可能
List<int> nums = [1, 2, 3];
print('合計: ${nums.reduce((a, b) => a + b)}'); // 合計: 6

// 通常の文字列（
 は改行として解釈）
String normal = 'line1
line2';
print(normal);
// line1
// line2

// raw 文字列（
 はそのまま 2文字）
String raw = r'line1
line2';
print(raw); // line1
line2

// 正規表現で raw 文字列を使う例
RegExp pattern = RegExp(r'd{3}-d{4}');
print(pattern.hasMatch('090-1234')); // true

String poem = '''
春はあけぼの
やうやう白くなりゆく
山際少し明かりて
''';
print(poem);

String html = """
<div>
  <p>Hello, World!</p>
</div>
""";

// raw + マルチラインの組み合わせ
String regex = r'''
^[a-zA-Z0-9._%+-]+
@[a-zA-Z0-9.-]+
.[a-zA-Z]{2,}$
''';

String s = '  Hello, Dart!  ';

print(s.trim());                  // 'Hello, Dart!'
print(s.toLowerCase());           // '  hello, dart!  '
print(s.toUpperCase());           // '  HELLO, DART!  '
print(s.contains('Dart'));        // true
print(s.replaceAll('Dart', 'World')); // '  Hello, World!  '

// 分割と結合
List<String> parts = 'a,b,c'.split(','); // ['a', 'b', 'c']
String joined = parts.join('-');          // 'a-b-c'

// 部分文字列
String sub = 'Hello'[1];           // 'e'（文字アクセス）
String slice = 'Hello'.substring(1, 3); // 'el'

// 数値変換
int n   = int.parse('42');
double d = double.parse('3.14');

try {
  int result = int.parse('not a number');
  print(result);
} on FormatException catch (e) {
  print('フォーマットエラー: ${e.message}');
} on RangeError {
  print('範囲エラー（詳細不要）');
} catch (e, stackTrace) {
  print('予期せぬエラー: $e');
  print(stackTrace);
} finally {
  print('必ず実行される');
}

void validateAge(int age) {
  if (age < 0) {
    throw ArgumentError.value(age, 'age', '年齢は 0 以上');
  }
  if (age > 150) {
    throw RangeError.range(age, 0, 150, 'age');
  }
}

void process(int age) {
  try {
    validateAge(age);
  } catch (e) {
    print('ログに記録: $e');
    rethrow; // 元のスタックトレースを維持したまま再送
  }
}

// Error: プログラムのバグ（キャッチ不要・修正すべき）
// AssertionError, ArgumentError, RangeError, StateError ...

// Exception: 予測可能な失敗（キャッチして回復）
// FormatException, IOException, TimeoutException ...

// カスタム例外の実装
class NetworkException implements Exception {
  final String message;
  final int statusCode;
  const NetworkException(this.message, this.statusCode);

  @override
  String toString() => 'NetworkException($statusCode): $message';
}

throw NetworkException('Not Found', 404);

void riskyOperation() {
  try {
    throw Exception('何かが失敗した');
  } catch (e, stack) {
    print('Error: $e');
    print('Stack trace:');
    print(stack);
  }
}

// 現在のスタックトレースを取得
void logCurrentTrace() {
  StackTrace trace = StackTrace.current;
  print(trace);
}

riskyOperation();

class Point {
  final double x;
  final double y;

  // 通常コンストラクタ（this.x で自動代入）
  const Point(this.x, this.y);

  // 名前付きコンストラクタ
  Point.origin() : x = 0, y = 0;

  // リダイレクトコンストラクタ
  Point.zero() : this(0, 0);

  // factory コンストラクタ（キャッシュや別コンストラクタ呼出し）
  factory Point.fromJson(Map<String, double> json) {
    return Point(json['x']!, json['y']!);
  }
}

void main() {
  var p1 = const Point(1.0, 2.0);
  var p2 = Point.origin();
  var p3 = Point.fromJson({'x': 3.0, 'y': 4.0});
}

class Temperature {
  double _celsius; // プライベートフィールド（_ プレフィックス）

  Temperature(this._celsius);

  // getter: 摂氏を華氏に変換
  double get fahrenheit => _celsius * 9 / 5 + 32;

  // setter: 値の検証付き
  set celsius(double value) {
    if (value < -273.15) throw ArgumentError('絶対零度以下は不可');
    _celsius = value;
  }

  double get celsius => _celsius;
}

var t = Temperature(100);
print(t.fahrenheit); // 212.0
t.celsius = 0;
print(t.fahrenheit); // 32.0

class Animal {
  final String name;
  Animal(this.name);

  String speak() => '...';
  void introduce() => print('$name は「${speak()}」と言う');
}

class Dog extends Animal {
  Dog(super.name); // super パラメータ（Dart 2.17+）

  @override
  String speak() => 'ワン';
}

class Cat extends Animal {
  Cat(super.name);

  @override
  String speak() => 'ニャン';
}

void main() {
  Animal(  'Bob').introduce(); // Bob は「...」と言う
  Dog(  'Pochi').introduce(); // Pochi は「ワン」と言う
  Cat(  'Tama').introduce();  // Tama は「ニャン」と言う
}

mixin Greetable {
  String get name;
  void greet() => print('Hello, I am $name!');
}

mixin Serializable {
  Map<String, dynamic> toJson();
  String serialize() => toJson().toString();
}

class Person with Greetable, Serializable {
  @override
  final String name;
  final int age;

  Person(this.name, this.age);

  @override
  Map<String, dynamic> toJson() => {'name': name, 'age': age};
}

void main() {
  var p = Person('Alice', 30);
  p.greet();           // Hello, I am Alice!
  print(p.serialize()); // {name: Alice, age: 30}
}

class Logger {
  void log(String message) => print('[LOG] $message');
}

// Logger をインターフェースとして実装（継承ではない）
class FileLogger implements Logger {
  @override
  void log(String message) {
    // ファイルへの書き込み（実際の実装は省略）
    print('[FILE] $message');
  }
}

// 複数のインターフェースを実装できる
class MultiLogger implements Logger {
  final List<Logger> _loggers = [FileLogger()];

  @override
  void log(String message) {
    for (var logger in _loggers) logger.log(message);
  }
}

// abstract class: 部分実装を持てる
abstract class Shape {
  double get area;               // 抽象メンバー（実装必須）
  double get perimeter;          // 抽象メンバー
  void describe() => print('面積: ${area.toStringAsFixed(2)}'); // 具象メソッド
}

// Dart 3: interface class（継承不可・実装のみ許可）
interface class Drawable {
  void draw() => throw UnimplementedError();
}

class Circle extends Shape implements Drawable {
  final double radius;
  Circle(this.radius);

  @override double get area      => 3.14159 * radius * radius;
  @override double get perimeter => 2 * 3.14159 * radius;
  @override void   draw()        => print('○');
}

class Animal {
  void breathe() => print('呼吸中');
}

mixin Swimmable {
  void swim() => print('泳ぎ中');
}

mixin Flyable {
  void fly() => print('飛行中');
}

abstract class Runnable {
  void run();
}

// extends: 1つの親クラスから継承
// with: 複数の mixin を適用
// implements: インターフェースとして実装（すべて override 必須）
class Duck extends Animal with Swimmable, Flyable implements Runnable {
  @override
  void run() => print('走り中');
}

void main() {
  var duck = Duck();
  duck.breathe(); // extends から
  duck.swim();    // mixin から
  duck.fly();     // mixin から
  duck.run();     // implements から
}

// sealed: 同一ライブラリ内でのみサブクラス化可能
// → switch で exhaustive チェックが効く
sealed class Result<T> {}
class Success<T> extends Result<T> { final T value; Success(this.value); }
class Failure<T> extends Result<T> { final String error; Failure(this.error); }

String describe<T>(Result<T> result) => switch (result) {
  Success(:var value) => '成功: $value',
  Failure(:var error) => '失敗: $error',
  // sealed なのでこれで exhaustive（default 不要）
};

// final: 継承も実装も不可
final class ImmutableConfig {
  final String host;
  ImmutableConfig(this.host);
}

// 型パラメータの基本
class Box<T> {
  T value;
  Box(this.value);
  T get() => value;
  void set(T newValue) { value = newValue; }
}

// 型制約: T は Comparable を実装している型に限定
T max<T extends Comparable<T>>(T a, T b) => a.compareTo(b) >= 0 ? a : b;

void main() {
  var intBox = Box<int>(42);
  print(intBox.get()); // 42

  print(max(3, 7));        // 7
  print(max('apple', 'banana')); // banana（辞書順）
}

// 型引数を明示
List<String> names = ['Alice', 'Bob'];
Map<String, List<int>> scores = {
  'Alice': [90, 85, 92],
  'Bob':   [78, 80, 76],
};

// 型推論による省略
var pairs = <String, int>{'one': 1, 'two': 2};

// ジェネリックメソッド
T firstOrDefault<T>(List<T> list, T defaultValue) {
  return list.isEmpty ? defaultValue : list.first;
}

print(firstOrDefault(<int>[], 0));          // 0
print(firstOrDefault(['a', 'b'], 'none'));   // a

class Animal {
  void eat(covariant Animal other) {
    print('Animal が食べる');
  }
}

class Dog extends Animal {
  @override
  void eat(Dog other) { // Dog に絞り込む（covariant を使っているので OK）
    print('犬同士が食べる');
  }
}

// covariant なしで引数を絞り込むと静的エラーになる
// class Cat extends Animal {
//   @override
//   void eat(Cat other) { ... } // エラー
// }

void checkType<T>(List<T> list) {
  if (list is List<String>) {
    print('文字列のリスト');
  } else if (list is List<int>) {
    print('整数のリスト');
  }
}

checkType(<String>['a', 'b']); // 文字列のリスト
checkType(<int>[1, 2, 3]);     // 整数のリスト

// runtimeType で型を文字列として取得
print(<String>[].runtimeType); // List<String>
print(<int, bool>{}.runtimeType); // _Map<int, bool> など

import 'dart:async';

// async 関数は Future を返す
Future<String> fetchUser(int id) async {
  // 実際は HTTP リクエストなど
  await Future.delayed(Duration(milliseconds: 100));
  return 'User#$id';
}

void main() async {
  // await で結果を待つ
  String user = await fetchUser(42);
  print(user); // User#42

  // then チェーンでも書ける（await 推奨）
  fetchUser(1).then((u) => print(u));
}

Future<int> fetchA() async {
  await Future.delayed(Duration(milliseconds: 200));
  return 1;
}
Future<int> fetchB() async {
  await Future.delayed(Duration(milliseconds: 100));
  return 2;
}

void main() async {
  // すべての完了を待つ（並列実行）
  List<int> results = await Future.wait([fetchA(), fetchB()]);
  print(results); // [1, 2]（順序は保証）

  // 最初に完了したものだけを受け取る
  int first = await Future.any([fetchA(), fetchB()]);
  print(first); // 2（fetchB の方が早い）
}

Future<String> risky() async {
  throw Exception('ネットワークエラー');
}

// async/await + try/catch（推奨）
void handleWithAwait() async {
  try {
    String result = await risky();
    print(result);
  } catch (e) {
    print('エラー: $e');
  } finally {
    print('完了');
  }
}

// then/catchError チェーン（古い書き方）
void handleWithChain() {
  risky()
    .then((v) => print(v))
    .catchError((e) => print('エラー: $e'))
    .whenComplete(() => print('完了'));
}

import 'dart:async';

Future<String> loadData() {
  final completer = Completer<String>();

  // コールバックベースの API をラップ
  Timer(Duration(seconds: 1), () {
    if (DateTime.now().second.isEven) {
      completer.complete('データ取得成功');
    } else {
      completer.completeError(Exception('取得失敗'));
    }
  });

  return completer.future;
}

void main() async {
  try {
    final data = await loadData();
    print(data);
  } catch (e) {
    print('Error: $e');
  }
}

import 'dart:async';

void main() async {
  // StreamController でストリームを手動制御
  final controller = StreamController<int>();

  // リスナーを登録
  controller.stream.listen(
    (value) => print('受信: $value'),
    onError: (e) => print('エラー: $e'),
    onDone: () => print('完了'),
  );

  // 値を送出
  controller.add(1);
  controller.add(2);
  controller.add(3);
  controller.close(); // 完了を通知

  // Broadcast ストリーム（複数リスナー対応）
  final broadcast = StreamController<String>.broadcast();
  broadcast.stream.listen((v) => print('A: $v'));
  broadcast.stream.listen((v) => print('B: $v'));
  broadcast.add('hello');
}

// async* ジェネレータ: Stream<T> を返す
Stream<int> countDown(int from) async* {
  for (int i = from; i >= 0; i--) {
    await Future.delayed(Duration(milliseconds: 100));
    yield i; // ストリームに値を送出
  }
}

// sync* ジェネレータ: Iterable<T> を返す
Iterable<int> fibonacci() sync* {
  int a = 0, b = 1;
  while (true) {
    yield a;
    int temp = a + b;
    a = b;
    b = temp;
  }
}

void main() async {
  await for (int n in countDown(3)) {
    print(n); // 3 2 1 0
  }

  print(fibonacci().take(8).toList()); // [0, 1, 1, 2, 3, 5, 8, 13]
}

import 'dart:async';

void main() async {
  Stream<int> numbers = Stream.fromIterable([1, 2, 3, 4, 5, 6]);

  // メソッドチェーンで変換
  numbers
      .where((n) => n.isEven)   // 偶数のみ
      .map((n) => n * 10)       // 10倍
      .listen((n) => print(n)); // 20 40 60

  // await for でストリームを消費
  Stream<String> words = Stream.fromIterable(['hello', 'world']);
  await for (String w in words) {
    print(w.toUpperCase()); // HELLO WORLD
  }

  // 集約（toList / first / last）
  List<int> all = await Stream.fromIterable([1, 2, 3]).toList();
  print(all); // [1, 2, 3]
}

import 'dart:async';

void main() async {
  final controller = StreamController<int>();

  // listen の戻り値で購読を管理
  StreamSubscription<int> sub = controller.stream.listen(
    (v) => print('受信: $v'),
  );

  controller.add(1);
  controller.add(2);

  // 一時停止と再開
  sub.pause();
  controller.add(3); // バッファリングされる

  sub.resume();
  // → 受信: 3

  // 購読解除（リソース解放）
  await sub.cancel();

  controller.add(4); // 誰も受け取らない
  await controller.close();
}

Object shape = Circle(5.0);

// switch 式（値を返す）
String desc = switch (shape) {
  Circle(radius: var r) when r > 10 => '大きな円（r=$r）',
  Circle(:var radius)               => '円（r=$radius）',
  Rectangle(:var width, :var height) => '長方形 ${width}x${height}',
  _                                  => '不明な図形',
};
print(desc); // 円（r=5.0）

// 複数のパターンを | で OR 結合
int n = 5;
String kind = switch (n) {
  1 | 2 | 3 => '小さい',
  4 | 5 | 6 => '中程度',
  _         => '大きい',
};

// タプル（Record）の分解
var (name, age) = ('Alice', 30);
print('$name は $age 歳'); // Alice は 30 歳

// リストの分解
var [first, second, ...rest] = [1, 2, 3, 4, 5];
print(first); // 1
print(rest);  // [3, 4, 5]

// Map の分解
var {'name': n, 'score': s} = {'name': 'Bob', 'score': 95};
print('$n: $s'); // Bob: 95

// for ループ内での分解
var pairs = [('Alice', 1), ('Bob', 2)];
for (var (name, id) in pairs) {
  print('$id: $name');
}

// 位置フィールドの Record（タプルのように使う）
(int, String) getIdAndName() => (42, 'Alice');
var (id, name) = getIdAndName();
print('$id: $name'); // 42: Alice

// 名前付きフィールドの Record
({double lat, double lng}) location = (lat: 35.68, lng: 139.69);
print('${location.lat}, ${location.lng}'); // 35.68, 139.69

// 位置 + 名前付き混在
(int, {String name, bool active}) user = (1, name: 'Bob', active: true);

// Record は == で値比較できる
print((1, 'a') == (1, 'a')); // true

sealed class ApiResult<T> {}
class ApiSuccess<T> extends ApiResult<T> {
  final T data;
  ApiSuccess(this.data);
}
class ApiError<T> extends ApiResult<T> {
  final String message;
  final int statusCode;
  ApiError(this.message, this.statusCode);
}
class ApiLoading<T> extends ApiResult<T> {}

// exhaustive switch: すべてのサブクラスを処理しないとエラー
String render<T>(ApiResult<T> result) => switch (result) {
  ApiSuccess(:var data)                 => '成功: $data',
  ApiError(:var message, :var statusCode) => 'エラー $statusCode: $message',
  ApiLoading()                          => '読み込み中...',
  // default 不要（sealed なので網羅的）
};

// DateTime: 日付と時刻
DateTime now = DateTime.now();
DateTime future = now.add(Duration(days: 7));
print(future.toIso8601String());

DateTime birthday = DateTime(1990, 3, 15);
Duration age = now.difference(birthday);
print('生まれてから ${age.inDays} 日');

// Duration
Duration d = const Duration(hours: 2, minutes: 30);
print(d.inMinutes); // 150

// Comparator / Comparable
List<String> words = ['banana', 'apple', 'cherry'];
words.sort(); // Comparable に基づいてソート
print(words); // [apple, banana, cherry]

import 'dart:math';

void main() {
  print(pi);           // 3.141592653589793
  print(sqrt(16));     // 4.0
  print(pow(2, 10));   // 1024
  print(log(e));       // 1.0
  print(sin(pi / 2));  // 1.0

  // 最大値・最小値
  print(max(3, 7)); // 7
  print(min(3, 7)); // 3

  // 乱数
  final rng = Random();
  print(rng.nextInt(100));    // 0〜99 のランダム整数
  print(rng.nextDouble());    // 0.0〜1.0 のランダム実数
  print(rng.nextBool());      // true か false

  // セキュアな乱数
  final secure = Random.secure();
  print(secure.nextInt(256));
}

import 'dart:convert';

void main() {
  // JSON エンコード
  Map<String, dynamic> data = {
    'name': 'Alice',
    'age': 30,
    'hobbies': ['reading', 'coding'],
  };
  String json = jsonEncode(data);
  print(json);
  // {"name":"Alice","age":30,"hobbies":["reading","coding"]}

  // JSON デコード
  String jsonStr = '{"score": 100, "pass": true}';
  Map<String, dynamic> decoded = jsonDecode(jsonStr);
  print(decoded['score']); // 100

  // UTF-8 エンコード
  List<int> bytes = utf8.encode('こんにちは');
  print(bytes);
  print(utf8.decode(bytes)); // こんにちは

  // Base64
  String b64 = base64Encode(bytes);
  print(b64);
}

import 'dart:io';

// ファイルの読み書き
Future<void> fileExample() async {
  // 書き込み
  final file = File('example.txt');
  await file.writeAsString('Hello, Dart IO!
');

  // 読み込み
  String content = await file.readAsString();
  print(content);

  // 行ごとに読む
  List<String> lines = await file.readAsLines();
  for (var line in lines) print(line);
}

// HTTP クライアント（基本）
Future<void> httpExample() async {
  final client = HttpClient();
  final req = await client.getUrl(Uri.parse('https://example.com'));
  final res = await req.close();
  print('Status: ${res.statusCode}');
  client.close();
}

# pubspec.yaml の例
name: my_app
description: A Dart application
version: 1.0.0

environment:
  sdk: '>=3.0.0 <4.0.0'

dependencies:
  http: ^1.1.0          # ^ = パッチ・マイナーアップを許容
  path: any             # any = バージョン制約なし

dev_dependencies:
  test: ^1.24.0         # テストフレームワーク
  lints: ^3.0.0         # 静的解析ルール

# Flutter の場合は flutter セクションも追加
# flutter:
#   assets:
#     - assets/images/

# 依存パッケージを取得（pubspec.lock を生成）
dart pub get

# バージョン制約内で最新にアップグレード
dart pub upgrade

# 特定のパッケージだけアップグレード
dart pub upgrade http

# パッケージを追加（pubspec.yaml を自動更新）
dart pub add http
dart pub add --dev test

# パッケージを削除
dart pub remove http

# 使われていない依存を確認
dart pub deps

// dart: — SDK 組み込みライブラリ（インストール不要）
import 'dart:core';       // 自動インポート（通常は不要）
import 'dart:async';
import 'dart:convert';
import 'dart:io';
import 'dart:math';

// package: — pub パッケージ（pubspec.yaml に追加済み）
import 'package:http/http.dart' as http;
import 'package:path/path.dart';

// 自プロジェクト内のファイル（package: または相対パス）
import 'package:my_app/src/utils.dart';
import '../utils.dart'; // 相対パス

// 特定の識別子だけインポート
import 'dart:math' show Random, pi;
import 'dart:io' hide File; // File を除外

# 標準的な Dart パッケージ/アプリの構成
my_package/
├── pubspec.yaml          # パッケージ設定
├── pubspec.lock          # 依存ロックファイル
├── analysis_options.yaml # 静的解析設定
├── lib/
│   ├── my_package.dart   # 公開 API のエントリポイント
│   └── src/              # 実装詳細（外部から直接インポート非推奨）
│       ├── feature_a.dart
│       └── feature_b.dart
├── bin/
│   └── main.dart         # 実行可能スクリプト（dart run）
└── test/
    └── my_package_test.dart

// 型推論の例
var count = 0;          // int と推論
var name = 'Alice';     // String と推論
var items = [1, 2, 3];  // List<int> と推論

// 複雑な推論
var map = {'a': 1, 'b': 2};  // Map<String, int>

// 戻り値型の推論（ローカル関数）
var double = (int n) => n * 2;  // int Function(int)

// 型推論が効かないケース（明示が必要）
var empty = [];          // List<dynamic>（推論できない）
var empty2 = <String>[]; // 明示で List<String>

// dynamic: 型チェックなし（危険）
dynamic d = 'hello';
print(d.toUpperCase()); // OK（コンパイル時チェックなし）
d = 42;
// print(d.toUpperCase()); // 実行時エラー: NoSuchMethodError

// Object?: 型の最上位（型チェックあり）
Object? o = 'hello';
// print(o.toUpperCase()); // コンパイルエラー: Object? にそのメソッドはない
if (o is String) {
  print(o.toUpperCase()); // Type Promotion で String として使える
}

// dynamic を使っても良いケース
// - JSON decode の結果（Map<String, dynamic>）
// - 型消去が起きる既存 API との接続部分
Map<String, dynamic> json = jsonDecode('{"n": 1}') as Map<String, dynamic>;

void process(Object? value) {
  // null チェックで non-null に昇格
  if (value == null) return;
  // ここでは value は Object（non-null）

  // is チェックで具体的な型に昇格
  if (value is String) {
    print(value.toUpperCase()); // String として使える
    return;
  }
  if (value is int) {
    print(value.isEven); // int として使える
    return;
  }
}

// &&、||、三項演算子でも有効
void check(String? s) {
  // s != null の後、s は String に昇格
  if (s != null && s.isNotEmpty) {
    print(s.length); // OK
  }
}

Object obj = 'Hello, Dart!';

// is: 型検査（Type Promotion も発生）
if (obj is String) {
  print(obj.length); // 12（String として使える）
}

// is!: 否定の型検査
if (obj is! int) {
  print('整数ではない');
}

// as: 強制キャスト（型が合わないと TypeError）
String s = obj as String; // obj が String でなければ実行時エラー
print(s.toUpperCase());   // HELLO, DART!

// 安全なキャスト（is で確認してから as）
dynamic unknown = 42;
if (unknown is int) {
  int n = unknown; // Type Promotion で as 不要
  print(n + 1);   // 43
}

# --- 開発時（JIT）---
# Hot Reload: コードを変更して r キーで即反映（状態を保持）
# Hot Restart: アプリを再起動して最初からやり直し
flutter run   # JIT モードで起動
dart run      # CLI ツールを JIT で実行

# --- 本番（AOT）---
# ネイティブバイナリにコンパイル（起動速度・サイズが最適化）
flutter build apk           # Android
flutter build ios           # iOS
flutter build web           # Web（dart2js または dart compile js）
dart compile exe bin/main.dart  # CLI ツールをネイティブ実行ファイルに

import 'package:flutter/material.dart';

// StatefulWidget: 内部状態を持つ Widget
class Counter extends StatefulWidget {
  const Counter({super.key});
  @override
  State<Counter> createState() => _CounterState();
}

class _CounterState extends State<Counter> {
  int _count = 0;

  @override
  Widget build(BuildContext context) {
    return Column(
      children: [
        Text('Count: $_count'),
        ElevatedButton(
          // setState でビルドを再実行
          onPressed: () => setState(() => _count++),
          child: const Text('Increment'),
        ),
      ],
    );
  }
}

// freezed の使用例（コード生成後）
// part 'user.freezed.dart';
// @freezed
// class User with _$User {
//   const factory User({
//     required int id,
//     required String name,
//     required String? email,
//   }) = _User;
// }

// 生成されるメリット:
// - copyWith（部分更新）
// - == / hashCode の自動実装
// - toJson / fromJson（json_serializable 連携）
// - sealed union 型（パターンマッチ対応）

// riverpod の例（コード生成スタイル）
// @riverpod
// Future<List<User>> userList(UserListRef ref) async {
//   final repo = ref.watch(userRepositoryProvider);
//   return repo.fetchAll();
// }

# ネイティブ実行ファイル（AOT コンパイル・依存なし）
dart compile exe bin/main.dart -o bin/main

# AOT スナップショット（Dart VM が必要）
dart compile aot-snapshot bin/main.dart

# JavaScript（Web デプロイ用）
dart compile js -O2 -o web/main.js bin/main.dart

# JIT スナップショット（起動が速くなる）
dart compile jit-snapshot bin/main.dart

# WebAssembly（実験的）
# dart compile wasm bin/main.dart

# Flutter Web は自動的に dart2js か dart2wasm を使用
# flutter build web --web-renderer canvaskit
# flutter build web --wasm