[Dart/TypeScript] Similarities and Differences. Static typing with type inference, single inheritance, abstract classes, Mixin, asynchronous

// 型推論
var number = 42; // `number`はintと推論される
number = 100;    // 再代入可能
final name = 'Alice'; // `name`はStringと推論される

// 変数修飾子
const int x = 10; // コンパイル時定数。その後再代入不可能
final int x = 10; // 実行時定数。その後再代入不可能
late int x;
void main() {
  x = 10; // 初期化が遅延されているため、実行時に初期化
  print(x); // 10
}
late var number = getNumber(); // 実行時に初期化されるが、再代入可能

int add(int a, int b) {
  return a + b;
}

// 型推論
let number = 42; // `number`は`number`型と推論される
number = 39; //再代入可能
const name = 'Alice'; // `name`は`string`型と推論される
name = 'Bob'; //エラー。再代入不可

// 変数修飾子
const PI = 3.14; // コンパイル時定数

class Example {
    readonly constantValue: number = 10;　// クラスのプロパティとしてのreadonly
}
const example = new Example();
// example.constantValue = 15; // エラー: cannot assign to 'constantValue' because it is a read-only property.


// add関数のパラメータ`x`と`y`、戻り値は型推論により`any`型とされる
function add(x, y) {
  return x + y;
}

// add関数のパラメータに型注釈を追加（推奨）
function add(x: number, y: number) {
  return x + y; // 戻り値は`number`型と推論される
}

// オプション引数
// 引数がなくても呼び出せる(デフォルトの値が使われる)
void func1(String param1, [int param2=0]){
  print("$param1,$param2");
}
// 名前つき引数
// 名前を指定して呼び出せる
void func2({String? param1, int? param2}){
  print("$param1,$param2");
}
// 必須引数
// 必ず引数を渡すことを強制できる
void func3({required String param1, required int param2}){
  print("$param1,$param2");
}
void main() {
  func1("func1");
  func2(param1:"func2");
  func3(param1:"func3",param2:3);
}

// 出力結果
// func1,0
// func2,null
// func3,3

// オプション引数
// 引数がない場合、undefinedがデフォルト値として使われる
function func1(param1: string, param2?: number) {
  console.log(`${param1}, ${param2}`);
}

// 名前付き引数（オブジェクトを引数として使用）
// 引数の順番に関係なく、名前で指定して値を渡すことができる
function func2({param1, param2}: {param1?: string, param2?: number}) {
  console.log(`${param1}, ${param2}`);
}

// 必須引数
// 引数の前に`?`をつけないと、その引数は必須となる
function func3(param1: string, param2: number) {
  console.log(`${param1}, ${param2}`);
}

func1("func1");
func2({param1: "func2"});
func3("func3", 3);

abstract class Shape { // 抽象クラス定義
  void draw(); // 抽象メソッド
  void move() {
    print('Moving a shape');
  } // 具体的なメソッド実装
}

class Circle extends Shape { // サブクラス定義
  void draw() {
    print('Drawing a circle');
  } // 抽象メソッドの具体的な実装
}

void main() {
  var circle = Circle();
	var circle = new Circle(); //newキーワードは使っても使わなくても良い。上記と同じ
	var shape = Shape();  // エラー: 抽象クラスのインスタンスを生成しようとしている
  circle.draw(); // "Drawing a circle" を出力
  circle.move(); // "Moving a shape" を出力

mixin Painter {
  void paint() {
    print('Painting...');
  }
}

mixin Writer {
  void write() {
    print('Writing...');
  }
}

class Artist with Painter, Writer {}

void main() {
  final artist = Artist();
  artist.paint();  // "Painting..." を出力
  artist.write();  // "Writing..." を出力
}

interface Shape {
  draw(): void; // メソッドのシグネチャ
  move(): void; // メソッドのシグネチャ
}

class Circle implements Shape {
  draw() {
    console.log('Drawing a circle');
  } // インターフェイスで定義されたメソッドの実装

  move() {
    console.log('Moving a circle');
  } // インターフェイスで定義されたメソッドの実装
}

let circle = new Circle();
circle.draw(); // "Drawing a circle" を出力
circle.move(); // "Moving a circle" を出力

class Student {
  fullName: string;
  constructor(
    public firstName: string,
    public middleInitial: string,
    public lastName: string
  ) {
    this.fullName = firstName + " " + middleInitial + " " + lastName;
  }
  getFullName(): string {
    return `${this.firstName} ${this.lastName}`;
  }
}

interface Person {
  firstName: string;
  lastName: string;
  getFullName(): string;
}

function greeter(person: Person) {
  return "Hello, " + person.firstName + " " + person.lastName;
}

let user = new Student("Jane", "M.", "User");

document.body.textContent = greeter(user);

Future fetchUserData() {
  // 擬似的にユーザーデータの取得を非同期で行う例
  return Future.delayed(Duration(seconds: 2), () {
    return 'User data';
  });
}

void main() async {
  print('Fetching user data...');
  String userData = await fetchUserData();
  print(userData); // 2秒後に'User data'が出力される
}

function fetchUserData(): Promise {
  // 擬似的にユーザーデータの取得を非同期で行う例
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve('User data');
    }, 2000);
  });
}

async function main() {
  console.log('Fetching user data...');
  const userData = await fetchUserData();
  console.log(userData); // 2秒後に'User data'が出力される
}

main();