[Dart] 함수형 프로그래밍

✍ Map()

void main() {
    List<String> fruit = ["사과", "바나나", "수박", "파인애플"];
    
    final newfruit = fruit.map(x) {
    	return '신선한 $x';
    }
    
    // ("신선한 사과", "신선한 바나나", "신선한 수박", "신선한 파인애플")
    print(newfruit);
    
    final newfruit2 = newfruit.map((x) => "상한 $x");
    
    // ("상한 사과", "상한 바나나", "상한 수박", "상한 파인애플")
    print(newfruit2);
    
    String number = "12345";
    
    final parsed = number.split('').map((y) => '$y.png');
    
    // ("1.png", "2.png", "3.png", "4.png", "5.png")
    print(parsed);
    
    // Map to Map
    Map<String, String> dictonary = {
    	"Harry Potter": "해리포터",
        "apple": "사과",
        "phone": "핸드폰"
    };
    
    // {"Harry Potter": "해리포터", "apple": "사과", "phone": "핸드폰"}
    dictonary.map((key, value) => MapEntry(
    	"d1 $key": "v1 $value"
    ));
}

map 함수를 사용하면 반복문(for, while)을 사용하지 않고도 간단하게 표현할 수 있다. map 함수의 결과로 새로운Iterate<T> 타입으로 결과(ex. ("1.png", "2.png", "3.png", "4.png", "5.png"))가 나온다. Iterate<T> 형식을 List, Set 등으로 바꾸는 방법은 다음과 같다.

 

void main() {
    List<String> blackPink = ["로제", "지수", "리사", "제니", "제니"];

    // List to Map
    Map blackPinkMap = blackPink.asMap();

    // List to Set
    Set blackPinkSet = blackPink.toSet();
    Set blackPinkSet2 = Set.from(blackPink);

    // key and values Iterable<T> to List
    blackPinkMap.keys.toList();
    blackPinkMap.values.toList();


    // Set to List
    List<dynamic> blabkPintList2 = blackPinkSet.toList();
    
    // Set to Map
    final newSet = blackPinkSet.map((x) => "블랙핑크 $x").toSet();
}

 

✍ where()

일종의 필터로 사용할 수 있다. where 에서 조건에 맞는 요소만 걸러준다.

void main() {
    List<Map<String, String>> people = [
    	{
            "name": "나나",
            "group": "tt"
        },
        {
            "name": "아아",
            "group": "gg"
        },
        {
            "name": "하하",
            "group": "tt"
        },
        {
            "name": "호호",
            "group": "gg"
        }
    ];
    
    // gg = [{"name": "아아", "group": "gg"}, {"name": "호호", "group": "gg"}]
    final gg = people.where((x) => x['group'] == "gg");
}

 

 

 

😶 firstWhere

where() 과 동일하며 맨 처음 조건이 맞는 요소를 반환해준다.

void main() {
  List<int> tmpIntList = [1, 3, 5, 2, 6, 10];
  
  // 2
  print(tmpIntList.firstWhere((e) => e % 2 == 0));
}

 

✍ reduce()

void main() {
    List<int> numbers = [1,3,5,6,7];

    numbers.reduce((prev, next){
        print("prev : $prev , next : $next");
        return prev + next;
    });
    
    List<String> strList = ["치킨은", "사랑", "입니다."];
    
    // 9
    final strLength = strList.reduce((p, n) => p + n).length;
}

reduce 는 처음에 prev 에는 첫번째 요소가 next 에는 두번째 요소가 들어가지만 그 다음 턴부터는 이전 결과값(return)이 prev로 들어가고 그 다음 요소 값이 next에 들어간다. 마지막 턴의 리턴값이 reduce() 함수의 리턴값이 된다. (각 턴마다 입력값에 대한 설명은 다음 그림 참고)

numbers.reduce() 동작 과정

 

여기서 주의사항이 반드시 return 값은 입력값(prev)의 데이터 타입과 일치해야 한다.

 

✍ fold()

fold() 는 fold(prev 초기값, (prev, next) {}) 형식으로 reduce() 와 비슷하지만 첫번째 턴의 (prev, next) 값이 (첫번째 요소, 두번째 요소)인 것과 다르게 fold<T>(prev 초기값, (prev, next) {}) 에서 첫번째 턴 값은 (prev 초기값, 첫번째 요소) 가 된다. 또한 반드시 reduce() 는 return 값은 입력값(prev)의 데이터 타입과 일치해야 한다.(return 값은 fold<T> 의 T 타입을 따른다.)

void main() {
    List<int> numbers = [1,3,5,7,9];
    
    // total = 0 + 1 + 3 + 5 + 7 + 9 = 
    final total = numbers.fold(0, (prev, next) => prev + next);
    
    List<String> str = ["나는", "치킨을", "사랑한다."];
    
    // strLength = 10
    final strLength = str.fold<int>(0, (p, n) => p + n.length);
}

 

✍ cascading operator (...)

기존의 List 를 합쳐 새로운 List 로 만들 때 주로 사용된다.

void main() {
    List<int> even = [2, 4, 6, 8];
    List<int> odd = [1, 3, 5, 7, 9];
    
    // [2, 4, 6, 8, 1, 3, 5, 7, 9]
    print([...even, ...odd]);
    
    // false
    print([...even] == even);	
}

 

+ 함수형 프로그래밍 활용 예시

class Person {
  final String name;
  final String group;

  Person({required this.name, required this.group});
  
  @override
  String toString() => 'Person(name : $name , group : $group)';

}

void main() {
  final List<Map<String, String>> people = [
    {'name': "지수", 'group': "블랙핑크"},
    {'name': "로제", 'group': "블랙핑크"},
    {'name': "RM", 'group': "BTS"},
    {'name': "정국", 'group': "BTS"}
  ];
  
  final bts = people.map((x) =>
    Person(name: x['name']!, group: x['group']!)
  ).where((x) => x.group == 'BTS');
  
  for(Person member in bts){
  	print(member);
  }
}