Dart (6) - 새로 추가된 기능

record

• list를 규격화해서 표현할 수 있는 기능
• typescript의 tuple과 유사
• list는 타입을 보장받을 수 없음
• 만약 타입 순서와 타입을 동시에 보장하고 싶으면 일반괄호 사용하여 반환 -> 튜플 생성

void main(){
  final result = nameAndAge({
    'name': '민지',
    'age': 20,
  });
  
  print(result); // (민지, 20)
// 일반 레코드를 쓸땐 값을 순서를 기반으로 받아옴 $1 $2
  print(result.$1); // 민지
  // 리스트에선 print(result[0])이라고 했음
  // string관련 메서드 들이 나옴
  print(result.$2); //int 관련 메서드 들이 나옴 // 20 
}

(String, int) nameAndAge(Map<String,dynamic>json){
  return (json['name'] as String, json['age'] as int);
//   만약 타입 순서와 타입을 동시에 보장하고 싶으면 일반괄호 사용하여 반환 -> 튜플 생성
}

void main(){
  final result3 = getAespaType();
  
  for(final i in result3){
    print(i.$1);
    print(i.$2);
  }
  // 카리나
  // 20
  // 윈터
  // 21
}
// <String, int> 타입으로 지정할 수 있는 방법 없음 ->dynamic으로 설정
List<Map<String, dynamic>> getAespa(){
  return [
    {
      'name': '카리나',
      'age': 20,
    },
    {
      'name': '윈터',
      'age': 21,
    }
  ];
}

// record를 쓰게되면
List<(String,int)> getAespaType(){
  return [
    (
      '카리나',
      20,
    ),
    (
      '윈터',
      21,
    )
  ];
}

이름 붙이기

void main(){
  final result4 = getAespaType2();
  
  for(final i in result4){
    print(i.$1); 
    print(i.$2); 
  }
  // 카리나
  // 20
  // 윈터
  // 21
}
List<(String name, int age)> getAespaType2(){
    return [
    (
      '카리나',
      20,
    ),
    (
      '윈터',
      21,
    )
  ];
}

이름 지정해 반환하는 방법

void main(){
  // 일반 레코드를 쓸땐 값을 순서를 기반으로 받아옴 $1 $2
  // named를 쓰면 실제 이름을 갖고 값을 가져올 수 있음
  final result5 = getAespaType3();
  
  for(final i in result5){
    print(i.age);
    print(i.name);
  }
  // 20
  // 카리나
  // 21
  // 윈터
}

List<({String name, int age})> getAespaType3(){
    return [
    (
      name: '카리나',
      age: 20,
    ),
    (
      name: '윈터',
      age: 21,
    )
  ];
}

record는 순서와 타입을 보장해준다는 것이 중요 포인트, 개수는 무한할 수 있음

void main(){
  final result6 = getWinter();
  print(result6); // (윈터, 에스파, 20)
  print(result6.$2);// 에스파
}
  
  (String name, String group, int age) getWinter(){
  return ('윈터','에스파',20);
}

디스턱처링

값을 분해한 상태로 받아옴

void main(){
  // 기존 방식 
  final winter = ('윈터', 21);
  
  final name = winter.$1;
  final age = winter.$2;
  
  // 디스턱쳐링
  final (name1, age1) = ('윈터', 21);
  
  print(name1); // 윈터
  print(age1); // 21
  
  final aespa = ['카리나','윈터'];
  final [String a, String b] = aespa;
  print(a); // 카리나
  print(b); // 윈터
  
  final numbers = [1,2,3,4,5,6,7,8];
  final [x,y,...,z] = numbers;
  print(x); // 1
  print(y); // 2
  print(z); // 8
  
  final [xx, yy, ...rest, zz] = numbers;
  print(rest); // [3, 4, 5, 6, 7]
  
// ignore
  final [xxx, _, yyy, ...rest2, zzz, _] = numbers;
  print(xxx); // 1
  print(yyy); // 3
  print(zzz); // 7
  print(rest2); // [4, 5, 6]
}

map 디스턱쳐링

void main(){
  final winterMap = {'name': '원터', 'age': 21};
  final {'name': name1 , 'age': age1} = winterMap;
  
  print(name1); // 윈터
  print(age1); // 21
  
  final winterIdol = Idol(name: '윈터', age: 21);
  final Idol(name: name2, age: age2) = winterIdol;
   
  print('---------------');
  print(name2); // 윈터
  print(age2); // 21
}

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

패턴 매칭?

void main(){
  // validation
  final som = ('솜', 20);
  final (name as String, age as int) = som;
  
  print(name);
  print(age);
  
  switcher('aaa'); // match: aaa
  switcher('bbb'); // no match
  switcher(['1','2']); // match: [1,2]
  switcher([1,2,3]); // [match: _, _, _]
  switcher([5,7,1]); // [match: _, _, _]
  switcher([5,7,1,2]); // no match
  switcher([2,4]); // match: [int 2, int 4]
  switcher([2,'4']); // no match

}

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]');
    default:
      print('no match');
  }
}

void main(){
  switcher(7); // match: < 10 && > 5
  switcher(15); // no match
}

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');
  }
}

void main(){
  print(switcher2(5, true)); // match: 5
  print(switcher2(8, true)); // no match
  print(switcher2(7, true)); // match 7 and true
  print(switcher2(7, false)); // no match
  
  forLooper();
  
  ifMatcher();
}

//  switch를 화살표 함수로 작성하는 방법
String switcher2(dynamic val, bool condition)=> switch(val){
  5 => 'match: 5',
  7 when condition => 'match 7 and true',
    // 컨디션이 true이고 value가 7일 때 매치 
  _ => 'no match', // default
};

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']);
  };
  
   print('-------------');
   for(var {'name': name, 'age': age} in members){
     print(name);
     print(age);
   }
}

void ifMatcher(){
  final winter = {
    'name': '윈터',
    'age': '21',
  };
  
   print('-------------');
    if(winter case {'name': String name, 'age': int age}){ 
      // if문 조건이 충족되어야 if문 내용이 실행됨
      // 만일 age를 '21' string으로 입력했다면 validation failed 
      print(name);
      print(age);
    }
}

기타 추가 사항

• final 클래스
  • final로 클래스 선언하면 extends, implement, mixin으로 사용 불가능
  • 하나의 파일 안에서는 가능하지만 다른 파일에서 final 클래스를 불러오게 되면 불가능.
• base 클래스
  • base로 선언하면 extend는 가능하지만 implement는 불가능
  • base, sealed, final로 선언된 클래스만 extend 가능하다.
• interface 클래스
  • interface 클래스로 선언하면 implement만 가능
• sealed 클래스
  • sealed 클래스는 abstract면서 final이다
  • 패턴매치를 사용할 수 있도록 해준다.
• mixin 클래스
  • mixin은 extends나 with을 사용할 수 없다. 그렇기 때문에 mixin class도 마찬가지로 사용 불가능하다.
  • 클래스는 on 키워드를 사용할 수 없다. 그렇기 때문에 mixin class도 on 키워드를 사용할 수 없다.