[Flutter] 다트 언어 마스터하기 – 다트 3.0 신규 문법

void main() {
  // 정확한 위치에 어떤 타입의 값이 입력될지 지정할 수 있습니다.
  // (String, int)는 첫 번째 값은 String 타입이고 두 번째 값은 int 타입입니다.
  (String, int) minji = ('민지', 20);
  // ('민지', 20) 출력
  print(minji);
}

void main() {
  // Invalid Assignment 에러
  (String, int) minji = (20, '민지');
  print(minji);
}

void main() {
  (String, int, bool) minji = ('민지', 20, true);
  // (민지, 20, true)
  print(minji);
}

void main() {
  (String, int, bool) minji = ('민지', 20, true);

  // 민지
  print(minji.$1);

  // 20
  print(minji.$2);

  // true
  print(minji.$3);
}

void main() {
  // Named Parameter 형태로 Record를 선언하는 방법이다.
  // 다른 Named Parameter와 마찬가지로 순서는 상관이 없어진다.
  ({String name, int age}) minji = (name: '민지', age: 20);

  // (age: 20, name: 민지) 출력
  print(minji);
}

void main() {
  // 아래 코드와 같지만 한줄에 해결 할 수 있다.
  // final newJeans = ['민지', '해린'];
  // final minji = newJeans[0];
  // final haerin = newJeans[1];
  final [minji, haerin] = ['민지', '해린'];

  // 민지 출력
  print(minji);

  // 해린 출력
  print(haerin);
}

void main() {
  final numbers = [1, 2, 3, 4, 5, 6, 7, 8];

  // spread operator를 사용하게 되면 중간의 값들을 버릴 수 있다.
  final [x, y, ..., z] = numbers;

  // 1 출력
  print(x);

  // 2 출력
  print(y);

  // 8 출력
  print(z);
}

void main() {
  final minjiMap = {'name': '민지', 'age': 19};
  // Map의 구조와 똑같은 구조로 Destructuring하면 된다.
  final {'name': name, 'age': age} = minjiMap;

  // name: 민지
  print('name: $name');

  // age: 19
  print('age: $age');
}

void main() {
  final minJiIdol = Idol(name: '민지', age: 19);

  final Idol(name: name3, age: age3) = minJiIdol;

  // 민지 출력
  print(name3);

  // 19 출력
  print(age3);
}

class Idol {
  final String name;
  final int age;

  Idol({
    required this.name,
    required this.age,
  });
}

void main() {
  String dayKor = '월요일';

  // switch문이 함수처럼 값을 반환합니다.
  String dayEnglish = switch (dayKor) {
    // '=>'를 사용하면 switch문 조건에 맞을 때 값을 반환할 수 있습니다.
    '월요일' => 'Monday',
    '화요일' => 'Tuesday',
    '수요일' => 'Wednesday',
    '목요일' => 'Thursday',
    '금요일' => 'Friday',
    '토요일' => 'Saturday',
    '일요일' => 'Sunday',
    // _는 default와 같은 의미로 사용됩니다.
    _ => 'Not Found',
  };

  // Monday 출력
  print(dayEnglish);
}

void switcher(dynamic anything) {
  switch (anything) {
    // 정확히 'aaa' 문자열만 매치합니다.
    case 'aaa':
      print('match: aaa');
      break;
    // 정확히 [1, 2] 리스트만 매치합니다.
    case [1, 2]:
      print('match: [1, 2]');
      break;
    // 3개의 값이 들어 있는 리스트를 모두 매치합니다.
    case [_, _, _]:
      print('match [_,_,_]');
      break;
    // 첫 번째와 두 번째 값에 int가 입력된 리스트를 매치합니다.
    case [int a, int b]:
      print('match: [int $a, int $b]');
      break;
    // 첫 번째 값에 String, 두 번째 값에 int가 입력된 Record 타입을 매치합니다.
    case (String a, int b):
      print('match: (String: $a, int: $b)');
      break;
    // 아무것도 매치되지 않을 경우 실행합니다.
    default:
      print('no match');
  }
}

void main() {
  // match: aaa 출력
  switcher('aaa');
  // match: [1, 2] 출력
  switcher([1, 2]);
  // match: [_. _. _] 출력
  switcher([3, 4, 5]);
  // match: [int 6, int 7] 출력
  switcher([6, 7]);
  // match: (String: 민지, int: 19) 출력
  switcher(('민지', 19));
  // no match 출력
  switcher(8);
}

void main(){
  // val에 입력될 수 있는 값은 true, false, null입니다.
  bool? val;

  // null 조건을 입력하지 않았기 때문에 non exhaustive switch statement 에러가 발생합
  // 니다. null case를 추가하거나 default case를 추가해야 에러가 사라집니다.
  switch(val){
    case true:
      print('true');
    case false:
      print('false');
  };
}

void main() {
  (int a, int b) val = (1, -1);

  // default가 출력됩니다. 만약에 b 값을 0 이상으로 변경하면
  // 1, _를 출력할 수 있습니다.
  switch (val) {
    case (1, _) when val.$2 > 0:
      print('1, 2');
      break;
    default:
      print('default');
  }
}

base class Parent{}

import '1_a.dart';

// 인스턴스화 가능
Parent parent = Parent();

// 가능
base class Child extends Parent{}

// subtype of base or final is not base final or sealed 에러
// base / sealed / final modifier중 하나 필요
class Child2 extends Parent{}

// subtype of base or final is not base final or sealed 에러
// base 클래스는 implement 불가능
class Child3 implements Parent{}

final class Parent{}

import '2_a.dart';

// 인스턴스화 가능
Parent parent = Parent();

// extend 불가능
class Child extends Parent{}

// implement 불가능
class Child2 implements Parent{}

interface class Parent{}

import '3_a.dart';

// 인스턴스화 가능
Parent parent = Parent();

// extend 불가능
class Child1 extends Parent{}

// implement 가능
class Child2 implements Parent{}

sealed class Parent{}

import '4_a.dart';

// 인스턴스화 불가능
Parent parent = Parent();

// extend 불가능
class Child1 extends Parent {}

// implement 불가능
class Child2 implements Parent {}

mixin class MixinExample{}

// extend 가능
class Child1 extends MixinExample{}

// mixin으로 사용 가능
class Child2 with MixinExample{}