[Flutter] 5. Dart 3.0 update

✅ Record

final result = nameAndAge({
	'name': '하니',
	'age': 20,
});

print(result); // (하니, 20) -> tuple: 타입 순서 보장
print(result.$1); // 하니
print(result.$2); // 20

// ------------------------

// Record: type & type 순서 보장 받을 수 있음
(String, int) nameAndAge(Map<String, dynamic> json) {
	return (json['name'] as String, json['age'] as int);
}

// 1
List<Map<String, dynamic>> getNewJeans() {
	return [
		{'name': '하니', 'age': 20},
		{'name': '민지', 'age': 21},
	];
}

// 2
List<(String, int)> getNewJeansWithType() {
	return [
		('하니', 20),
		('민지', 21),
	];
}

final result3 = getNewJeansWithType();

for (final item in result3) {
	print(item.$1);
	print(item.$2);
}

// 3
List<({String name, int age})> getNewJeansWithType2() {
	return [
		(name: '하니', age: 20),
		(name: '민지', age: 21),
	];
}

---

✅ Destructuring

final (name, age) = ('하니', 20);

print(name); // 하니
print(age); // 20

final newJenas = ['하니', '민지'];
final [String a, String b] = newJeans;

print(a); // 하니
print(b); // 민지

final numbers = [1, 2, 3, 4, 5, 6, 7, 8];
final [x, y, ..., z] = numbers; 
// ... -> 중간 값들은 먹어버리고, 한 곳에만 사용 가능

final [xx, yy, ...rest, zz] = numbers;
// ...rest: 먹어버리는 값들에 이름을 지정해주면 다른 곳에서 가져다 사용 가능

print(xx); // 1
print(yy); // 2
print(zz); // 8
print(rest); // [3, 4, 5, 6, 7]

// ---------------------------------------------

// _ : 값 완전히 무시
final [xxx, _, yyy, ...rest2, zzz, _] = numbers;

print(xxx); // 1
print(yyy); // 3
print(zzz); // 7
print(rest2); // [4, 5, 6]

final haniMap = {'name': '하니', 'age': 20};
final {'name': NAME, 'age': AGE} = haniMap;

print(NAME); // 하니
print(AGE); // 20

class Idol {
	final String name;
	final int age;
	
	Idol({
		required this.name,
		required this.age,
	})
}

final haniIdol = Idol(name: '하니', age: 20);
final Idol(name: NAME2, age: AGE2) = haniIdol;

print(NAME2); // 하니
print(AGE2); // 20

---

✅ Pattern Matching

// validation
final hani = ('하니', 20);
final (name as String, age as int) = hani;

print(name); // 하니
print(age);  // 20

void switcher(dynamic anything) {
	switch(anything) {
		case 'aaa':
			print('match: aaa');
    case ['1', '2']:
      print('match: [1, 2]');
    case [_, _, _]:
      print('match: [_, _, _]');
    case [int a, int b]:
      print('match: [int $a, int $b]');
    case < 10 && > 5:
	    print('match: < 10 && > 5');
    default:
	    print('no match');
	}
}

switcher('aaa'); // match: aaa
switcher([1, 2]); // no match
switcher([1, 2, 3]); // match: [_, _, _]
switcher(7); // match: < 10 && > 5

// ----------------------------------

String switcher2(dynamic val, bool condition) => switch (val) {
	5 => 'match: 5',
	7 when condition => 'match 7 and true',
	_ => 'no match', // default
}

print(switcher2(5, true)); // match: 5
print(switcher2(7, true)); // match 7 and true
print(switcher2(7, false)); // no match

void forLooper() {
	final List<Map<String, dynamic>> members = [
		{'name': '하니', 'age': 20},
		{'name': '민지', 'age': 21},
	];
	
	for (final member in members) {
		print(member['name']);
		print(member['age']);
	}
	
	// === 코드 동작 동일
	
	for (var {'name': NAME, 'age': AGE} in members) {
		print(NAME);
		print(AGE);
	}
}

void ifMatcher() {
	final hani = { 'name': '하니', 'age': 20 };

	if (hani case {'name': String name, 'age': int age}) {
		print(name);
		print(age);
	}
}

---

• final로 클래스 선언하면 extends, implement, mixin으로 사용 불가

• base로 선언하면 extend 가능 ⭕️, implement 불가능 ❌

  base class person {
  	final String name;
  	final int age;
  	
  	Person({
  		required this.name,
  		required this.age,
  	});
  }

• interface로 선언하면 implement만 가능

• sealed 클래스: abstract이면서 final / 패턴매칭 사용할 수 있도록 해줌

---

Mixin Class

1. mixin은 extends나 with 사용 불가 ❌ → 그러므로 mixin class도 사용 불가 ❌
2. 클래스는 on 키워드 사용 불가 ❌ → 그러므로 mixin class도 on 키워드 사용 불가 ❌

mixin class AnimalMixin {
	String bark() {
		return '멍멍';
	}
}

class Dog with AnimalMixin {}