04. 다트 3.0 신규 문법

void main() {
  // 정확한 위치에 어떤 타입의 값이 입력될지 지정할 수 있음.
  (String, int) roo = ('roo', 10);
  
  print(roo); // 결괏값: ('roo', 10)
}

void main() {
  (String, int, bool) roo = ('roo', 10, true);
  
  print(roo.$1); // roo
  print(roo.$2); // 10
  print(roo.$3); // true
}

void main() {
  ({String name, int age}) roo = (name: 'roo', age: 10);
  
  print(roo); // (age: 10, name: roo)
}

void main() {
  final [roo, loo] = ['roo', 'loo'];
  
  print(roo); // roo
  print(loo); // loo
}

void main() {
  final numbers = [1, 2, 3, 4, 5, 6, 7, 8];
  
  // 스프레드 연산자를 사용해서 중간의 값들을 버리기
  final [x, y, ..., z] = numbers;
  
  print(x); // 1
  print(y); // 2
  print(z); // 8
}

void main() {
  final rooMap = {'name': 'roo', 'age': 10};
  // 위 구조와 같은 구조로 구조 분해하기
  final {'name': name, 'age': age} = rooMap;
 
  print('name: $name'); // name: roo
  print('age: $age'); // age: 10
}

void main() {
  final roo = Idol(name: 'roo', age: 10);
  
  // 클래스의 생성자 구조와 똑같이 구조 분해하기
  final Idol(name: name, age: age) = roo;
  
  print(name);
  print(age);
}

void main() {
  String dayKor = '월요일';
 
  // switch문이 함수처럼 값을 반환함.
  String dayEnglish = switch (dayKor) {
    // '=>'를 사용하면 switch 문 조건에 맞을 때 값을 반환할 수 있음.
    '월요일' => 'Monday',
    '화요일' => 'Tuesday',
    // _ 는 default와 같은 의미로 사용됨.
    _ => 'Not Found',
  };
 
  print(dayEnglish); // Monday
}

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() {
  switcher('aaa');
  switcher([1, 2]);
  switcher([3, 4, 5]);
  switcher([6, 7]);
  switcher(('roo', 10));
  switcher(8) 
}
 
// 결괏값:
// match: aaa
// match [1, 2]
// match [_,_,_]
// match: [int 6, int 7]
// match: (String: roo, int: 10)
// no match

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, _');
      break;
    default:
      print('default');
  }
}

// lib/4.4/1_a.dart
base class Parent {}

// lib/4.4/1_b.dart
import '1_a.dart';
 
// 인스턴스화 가능
Parent parent = Parent();
 
// rksmd
base class Child extends Parent {}
 
// subtype of base or final is not base final or sealed 에러 출력
// base / sealed / final 제한자 중 하나가 필요.
class Child2 extends Parent {}
 
// subtype of base or final is not base final or sealed 에러 출력
// base 클래스는 implement가 불가능.
class Child3 implements Parent {}

// lib/4.4/2_a.dart
final class Parent {}

// lib/4.4/2_b.dart
import '2_a.dart';
 
// 인스턴스화 가능
Parent parent = Parent();
 
// extend 불가능
class Child extends Parent {}
 
// implement 불가능
class Child2 implements Parent {}

// lib/4.4/3_a.dart
interface class Parent {}

// lib/4.4/3_b.dart
import '3_a.dart';
 
// 인스턴스화 가능
Parent parent = Parent();
 
// extend 불가능
class Child1 extends Parent {};
 
// implement 가능
class Child2 implements Parent {}

// lib/4.4/4_a.dart
sealed class Parent{}

import '4_a.dart';
 
// 인스턴스화 불가능
Parent parent = Parent();
 
// extend 불가능
class Child1 extends Parent {}
 
// implements 불가능
class Child2 implements Parent {}

// lib/4.4/5.dart
mixin class MixinExample {}
 
// extend 가능
class Child1 extends MixinExample {}
 
// mixin으로 사용 가능
class Child2 with MixinExample {}