Dart #3 함수형 프로그래밍(Functional Programming)

void main() {
  List<Map<String, String>> people = [
    {
      'name': '로제',
      'group': '블랙핑크',
    },
        {
      'name': '지수',
      'group': '블랙핑크',
    },
        {
      'name': 'RM',
      'group': 'BTS',
    },
        {
      'name': '뷔',
      'group': 'BTS',
    },
  ];
  
  print(people);
  
  final blackPink = people.where((x) => x['group'] == '블랙핑크').toList();
  final BTS = people.where((x) => x['group'] == 'BTS').toList();
  
  print(blackPink[0]);
  print(BTS[0]);
}​

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

  print(blackPink);
  print(blackPink.asMap());
  print(blackPink.toSet());

  Map blackPinkMap = blackPink.asMap();

//   print(blackPinkMap.keys);
//   print(blackPinkMap.values);
  print(blackPinkMap);
  print(blackPinkMap.keys.toList());
  print(blackPinkMap.values.toList());
  
 Set blackPinkSet = blackPink.toSet();
  
  print(blackPinkSet);
  print(blackPinkSet.toList());
}

asMap() 메소드는 리스트의 각 항목을 맵(MAP)으로 변환합니다. 이 메소드는 리스트의 인덱스를 키로 사용하고, 리스트의 각 항목을 값으로 사용하는 새로운 맵 객체를 반환합니다.

void main() {
  List<String> myList = ['a', 'b', 'c'];
  Map<int, String> myMap = myList.asMap();
  
  print(myMap); // 출력: {0: 'a', 1: 'b', 2: 'c'}
}

toSet() 메소드는 리스트의 항목들을 집합(SET)으로 변환합니다. 집합은 중복 항목을 허용하지 않는 데이터 구조입니다. 따라서 이 메소드는 리스트에서 중복 항목을 제거하고, 그 항목들을 포함하는 새로운 집합 객체를 반홥합니다.

void main() {
  List<String> myList = ['a', 'b', 'c', 'c'];
  Set<String> mySet = myList.toSet();
  
  print(mySet); // 출력: {a, b, c}
}

 

- List<String> 타입의 변수에는 문자열 리스트만 할당할 수 있습니다.

- Map<int, String> 타입의 변수에는 정수를 키로하고 문자열을 값으로 하는 맵만 할당할 수 있습니다.

 

정리 Time

1. () (괄호)

- 함수 호출 : 함수를 호출할 때 사용합니다.

- 그룹화 : 수식이나 논리식에서 연산의 우선순위를 지정하기 위해 사용합니다.

 

2. {} (중괄호}

- 블록 생성 : 코드 블록을 생성하여 함수 또는 제어 흐름 구조의 본문을 정의하는데 사용합니다.

- 맵 생성 : 키-값을 저장하는 맵을 생성하는데 사용합니다.

- 네임드 파라미터 : 함수의 네임드 파라미터를 정의할 때 사용합니다.

 

3. [] (대괄호)

- 리스트 생성 : 요소들의 리스트를 생성하는데 사용합니다.

- 리스트/배열 접근 : 리스트나 배열의 특정 요소에 접근하는데 사용합니다.

- 옵션적 파라미터 : 함수에서 옵션적 파라미터를 정의할 때 사용합니다.

 

Iterable은 컬렉션을 다루는 기본 인터페이스로, 다양한 시나리오에서 유용하게 사용됩니다. Iterable 객체는 여러 개의 항목을 순회할 수 있으며, List나 Set과 같은 다른 컬렉션 타입으로 쉽게 변환할 수 있습니다.

- map, where, reduce 등의 메서드를 제공하므로 함수형 프로그래밍 스타일을 채택할 수 때 유용합니다.

- Iterable을 사용하여 한 타입의 컬렉션을 다른 타입의 컬렉션으로 쉽게 변환할 수 있습니다.

- 반복 가능한(iterable, 이터러블) 객체는 배열을 일반화한 객체입니다.

 

void main() {
  String number = '12345';
  
  final num = number.split('');
  
  final parsed = number.split('').map((x) => '$x.jpg').toList();
  
  print(num);
  print(parsed);
    
}

 

split 메서드는 문자열을 특정 패턴 또는 문자를 기준으로 여러 부분으로 나눕니다. 이 메서드는 문자열을 밉력받아 그 문자열을 기준으로 원래 문자열을 여러 개의 문자열로 나눕니다. 결가는 문자열의 리스트로 반홥됩니다.

 

 

void main() {
  Map<String, String> harryPotter = {
    'Harry Potter': '해리 포터',
    'Ron Weasley': '론 위즐리',
  };

  final result = harryPotter.map(
    // Map -> Map으로 바꾸는 방법 근데 자주 사용하지 않는다.
    (key, value) => MapEntry('Harry Potter Character $key', '해리포터 캐릭터 $value'),
  );

  print(harryPotter);
  print(result);

  final keys = harryPotter.keys.map((x) => 'HPC $x').toList(); // 특정 값만 불러서 사용
  final values = harryPotter.values.map((x) => '해리포터 $x').toList();

  print(keys);
  print(values);
}

void main(){
  // { } -> 이러한표기법은 'Set'내의 각 요소가 고유하다는 것을 강조하며, 순서가 없다는 것을 나타냅니다.
  Set blackPinkSet = {
    '지수',
    '제니',
    '로제',
    '리사'
  };
  
  final newSet = blackPinkSet.map((x) => '블랙핑크 $x').toSet();
  
  print(newSet);

}

void main() {
  List<Map<String, String>> people = [
    {
      'name': '로제',
      'group': '블랙핑크',
    },
        {
      'name': '지수',
      'group': '블랙핑크',
    },
        {
      'name': 'RM',
      'group': 'BTS',
    },
        {
      'name': '뷔',
      'group': 'BTS',
    },
  ];
  
  print(people);
  
  final blackPink = people.where((x) => x['group'] == '블랙핑크').toList();
  final BTS = people.where((x) => x['group'] == 'BTS').toList();
  // 조건을 걸어서 출력할 수 있다.
  
  print(blackPink[0]);
  print(BTS[0]);
}

 

reduce 메서드는 리스트나 Iterable의 모든 요소들을 단일 값으로 결합하는 데 사용됩니다. 이 메서드는 컬렉션의 첫 번째 요소에서 시작하여, 지정된 함수를 사용하여 컬렉션의 나머지 요소들과 결합합니다.

reduce 메서드를 사용할 때, 반환 타입은 입력 컬렉션의 요소 타입과 일치해야 합니다. 함수의 반환 타입과 입력 컬렉션의 요소 타입이 다르면 오류가 발생합니다.

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

//   final result = numbers.reduce((prev, next){
//     print('============');
//     print('previous : $prev');
//     print('next : $next');
//     print('total : ${prev + next}');
//     return prev + next;
//   });

  final result = numbers.reduce((prev, next) => prev + next);

  print(result);

  List<String> words = ['안녕하세요', '저는', '코드팩토리입니다'];

  final sentence = words.reduce((prev, next) => prev + next);

  print(sentence);

  // 꼭 알아야 할 것 reduce는 같은 타입을 지정해야 한다는 것
//   String인데 출력이 int로 나오면 안되는것처럼
}

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

//   final sum = numbers.fold<int>(0, (prev, next) {
//     print('-------------');
//     print('prev : $prev');
//     print('next : $next');
//     print('total : ${prev + next}');

//     return prev + next;
//   });

  final sum = numbers.fold<int>(0, (prev, next) {
    print('-------------');
    print('prev : $prev');
    print('next : $next');
    print('total : ${prev + next}');

    return prev + next;
  });

  print(sum);

  List<String> words = ['안녕하세요 ', '저는 ', '코드팩토리입니다.'];

  final sentence = words.fold<String>('', (prev, next) => prev + next);
  
  print(sentence);
  
  final count = words.fold<int>(0,(prev, next) => prev + next.length);
  
  print(count);
}

fold메서드는 reduce 메서드와 유사하게 작동하지만, 두 가지 주요 차이점이 있습니다.

1. fold 는 초기값을 받아, 그 값에서 출발하여 모든 요소들을 결합하게 됩니다.

2. fold 메서드를 사용하면 반환 타입이 입력 컬렉션의 요소 타입과 달라도 됩니다.

fold 메서드는 두 개의 매개변수를 가진 함수와 초기값을 인자로 받습니다. 함수의 첫 번째 매개변수는 누적값이고, 두 번째 매개변수는 현재 요소의 값입니다.

 

 

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

Spread Operator('...') : 리스트나 콜렉션의 모든 요소를 현재 위치에 개별적으로 삽입합니다. 여러 콜렉션을 결합하거나 콜렉션을 새 콜랙션에 복사할 때 유용합니다.

 

void main() {
  List<Map<String, String>> people = [
    {
      'name': '로제',
      'group': '블랙핑크',
    },
    {
      'name': '지수',
      'group': '블랙핑크',
    },
    {
      'name': 'RM',
      'group': 'BTS',
    },
    {
      'name': '뷔',
      'group': 'BTS',
    },
  ];

  print(people);

  final parsePeople = people
      .map((x) => Person(
            name: x['name']!,
            group: x['group']!,
          ))
      .toList();

  print(parsePeople);

  for (Person person in parsePeople) {
    print(person.name);
    print(person.group);
  }

  final bts = parsePeople.where((x) => x.group == 'BTS').toList();

  print(bts);

  final result = people
      .map(
        (x) => Person(
          name: x['name']!,
          group: x['group']!,
        ),
      )
      .where((x) => x.group == 'BTS')
      .fold<int>(0, (prev, next) => prev + next.name.length);
  print(result);
}

class Person {
  final String name;
  final String group;

  Person({
    required this.name,
    required this.group,
  });

  @override
  String toString() {
    return 'Person(name : $name group : $group)';
  }
}