1
void main() {
2
  final result = nameAndAge({
3
    'name': '민지',
4
    'age': 20,
5
  });
6

7
  print(result); // (민지, 20)
8
  print(result.$1); // 민지
9
  print(result.$2); // 20
10

11
  final result3 = getNewJeansWithType();
12
  for (final item in result3) {
13
    print(item.$1);
14
    print(item.$2);
15
  }
16

17
  final result4 = getNewJeansWithType2();
18
  for (final item in result4) {
19
    print(item.$1);
20
    print(item.$2);
21
  }
22

23
  print('-------------------------------');
24

25
  final result5 = getNewJeansWithType3();
26
  for (final item in result5) {
27
    print(item.name);
28
    print(item.age);
29
  }
30

31
  final result6 = getMinji();
32
  print(result6);
33
}
34

35
// Record
36
(String, int) nameAndAge(Map<String, dynamic> json) {
37
  return (
38
    json['name'] as String,
39
    json['age'] as int,
40
  );
41
}
42

43
List<Map<String, dynamic>> getNewJeans() {
44
  return [
45
    {'name': '민지', 'age': 20},
46
    {'name': '해린', 'age': 18},
47
  ];
48
}
49

50
List<(String, int)> getNewJeansWithType() {
51
  return [
52
    ('민지', 20),
53
    ('해린', 18),
54
  ];
55
}
56

57
List<(String name, int age)> getNewJeansWithType2() {
58
  return [
59
    ('민지', 20),
60
    ('해린', 18),
61
  ];
62
}
63

64
List<({String name, int age})> getNewJeansWithType3() {
65
  return [
66
    (name: '민지', age: 20),
67
    (name: '해린', age: 18),
68
  ];
69
}
70

71
(String name, String group, int age) getMinji() {
72
  return ('민지', '뉴진스', 20);
73
}

1
void main() {
2
  final (name, age) = ('민지', 20);
3
  print(name);
4
  print(age);
5

6
  final newJeans = ['민지', '해린'];
7
  final [String a, String b] = newJeans;
8
  print(a);
9
  print(b);
10

11
  final numbers = [1, 2, 3, 4, 5, 6, 7, 8];
12
  final [x, y, ..., z] = numbers;
13
  print(x);
14
  print(y);
15
  print(z);
16

17
  final [xx, yy, ...rest, zz] = numbers;
18
  print(xx);
19
  print(yy);
20
  print(zz);
21
  print(rest); // [3, 4, 5, 6, 7]
22

23
  // _ : 무시
24
  final [xxx, _, yyy, ...rest2, zzz, _] = numbers;
25
  print(xxx); // 1
26
  print(yyy); // 3
27
  print(zzz); // 8
28
  print(rest2); // [4, 5, 6, 7]
29

30
  final minJiMap = {
31
    'name': '민지',
32
    'age': 20,
33
  };
34
  final {'name': name3, 'age': age3} = minJiMap;
35
  print(name3);
36
  print(age3);
37

38
  print('-------------------');
39
  final minJiIdol = Idol(name: '민지', age: 20);
40
  final Idol(name: name4, age: age4) = minJiIdol;
41
  print(name4);
42
  print(age4);
43
}
44

45
class Idol {
46
  final String name;
47
  final int age;
48

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

1
void main() {
2
  // Validation(유효성 검사)
3
  final minJi = ('민지', 20);
4

5
  final (name as String, age as int) = minJi;
6

7
  print(name);
8
  print(age);
9

10
  // switcher('aaa');
11
  // switcher('bbb');
12
  // switcher(['1', '2']);
13
  // switcher([1, 2, 3]);
14
  // switcher([4, 5, 6]);
15
  // switcher([4, 5, 6, 7]);
16
  // switcher([6, 9]);
17
  // switcher([6, '9']);
18
  switcher(7);
19
  switcher(17);
20

21
  print(switcher2(5, true));
22
  print(switcher2(7, true));
23
  print(switcher2(7, false));
24

25
  forLooper();
26

27
  ifMatcher();
28
}
29

30
void switcher(dynamic anything) {
31
  switch (anything) {
32
    case 'aaa':
33
      print('match : aaa');
34
      break;
35
    case ['1', '2']:
36
      print('match : 1, 2');
37
      break;
38
    case [_, _, _]:
39
      print('match : [_, _, _]');
40
      break;
41
    case [int a, int b]:
42
      print('match : [int $a, int $b]');
43
      break;
44
    case < 10 && > 5:
45
      print('match : < 10 && > 5');
46
      break;
47
    default:
48
      print('no match');
49
  }
50
}
51

52
String switcher2(dynamic val, bool condition) => switch(val) {
53
  5 => 'match: 5',
54
  7 when condition => 'match 7 and true',
55
  _ => 'no match',
56
}
57

58
void forLooper() {
59
  final List<Map<String, dynamic>> members = [
60
    {'name': '민지', 'age': 20},
61
    {'name': '민호', 'age': 30},
62
  ];
63

64
  for(final member in members) {
65
    print(member['name']);
66
    print(member['age']);
67
  }
68

69
  print('-------------------');
70

71
  for(var {'name': name, 'age': age} in members) {
72
    print(name);
73
    print(age);
74
  }
75
}
76

77
void ifMatcher() {
78
  final minJi = {
79
    'name': '민지',
80
    'age': 20,
81
  };
82

83
  print('-------------------');
84

85
  if(minJi case {'name': String name, 'age': int age }) {
86
    print(name);
87
    print(age);
88
  }
89
}

1
// final로 클래스를 선언하면,
2
// 다른 파일에서 extends, implements, mixin을 사용할 수 없다.
3
final class Person {
4
  final String name;
5
  final int age;
6

7
  Person({
8
    required this.name,
9
    required this.age,
10
  })
11
}

1
// base로 선언하면 extends는 가능하지만, implements는 불가능하다.
2
// base, sealed, final로 선언된 클래스만 extends가 가능하다.
3
base class Person {
4
  final String name;
5
  final int age;
6

7
  Person({
8
    required this.name,
9
    required this.age,
10
  })
11
}

1
// interface로 선언하면 implements만 가능하다.
2
interface class Person {
3
  final String name;
4
  final int age;
5

6
  Person({
7
    required this.name,
8
    required this.age,
9
  })
10
}

1
// sealed 클래스는 abstract이면서, final이다.
2
// 그리고 패턴매칭을 사용할 수 있도록 해준다.
3
sealed class Person{}
4

5
class Idol extends Person {}
6

7
class Engineer extends Person {}
8

9
class Chef extends Person {}
10

11
String whoIsHe(Person person) => switch(person) {
12
  Idol i => '아이돌',
13
  Engineer e => '엔지니어',
14
  _ => '나머지',
15
};

1
// Minxin Class
2
// 1) mixin은 extends나 with을 사용할 수 없다.
3
//    그렇기 떄문에 mixin class도 마찬가지로 사용 불가능하다.
4
// 2) 클래스는 on 키워드를 사용할 수 없다.
5
//    그렇기 떄문에 mixin class도 on z키워드를 사용할 수 없다.
6
mixin class AnimalMixin {
7
  String bark() {
8
    return '멍멍';
9
  }
10
}