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

기본 함수를 통해서 형변환을 할 수 있다.

void main() {
  List<String> blackPink = ['로제', '지수', '리사', '제니', '제니'];
  
  print(blackPink);
  print(blackPink.asMap());
  print(blackPink.toSet());
  
  Map blackPinkMap = blackPink.asMap();
  
  print(blackPinkMap.keys.toList());
  print(blackPinkMap.values.toList());
  
  Set blackPinkSet = blackPink.toSet();
  
  print(blackPinkSet.toList());
}  

map를 사용하여 list로 형변환 하여 새로운 list 만들기

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

  final newBlackPink = blackPink.map((x) {
    return '블랙핑크 $x';
  });

  print(blackPink);
  print(newBlackPink.toList());

  final newBlackPink2 = blackPink.map((x) => '블랙핑크 $x');
  print(newBlackPink2.toList());

  print(blackPink == blackPink);true
  print(blackPink == newBlackPink);false
  print(newBlackPink == newBlackPink2); false

  //1.jpg, 2.jpg, 3.jpg, 4.jpg, 5.jpg
  String number = '12345';

  final parsed = number.split('').map((x) => '$x.jpg').toList();
  print(parsed);
}
//split 함수는 문자를 나누는 기본 함수

map를 사용하여 map을 list로 형변환 하여 새로운 list 만들기

void main() {
  Map<String, String> harryPotter = {
    'Harry Potter': '해리포터',
    'Ron Weasley': '론 위즐리',
    'Hermione Granger': '헤르미온느 그레인저'
  };
  final result = harryPotter.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);
}

map를 사용하여 set을 새로운 set로 만들기

void main() {
  Set names = {'Code Factory', 'Flutter', 'name', 'Flutter'};

  final newSet = names.map((x) => '이름 - $x').toSet();

  print(newSet);
}

where를 사용하여 필터링하여 새로운 list를 만들기

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);
  print(bts);
}

reduce 리스트의 모든 합을 구하는 함수(집계 함수)

아래와 같이 화살표 함수로 단축하여 나타낼 수 있다.

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

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

문자 형식에도 사용할 수 있다.

void main() {
  List<String> words = ['안녕하세요 ', '저희는 ', '블랙핑크 입니다.'];

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

fold

아래와 같이 화살표 함수로 단축하여 나타낼 수 있다.

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

  final sum = numbers.fold<int>(0, (prev, next) => prev + next);
  print(sum);
}

문자 형식에도 사용할 수 있다.

reduce화 다르게 문자 형식을 변환하여 나타낼 수 있다.

받은 정보를 구조화 하여 활용 하기

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

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

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

  final bts = parsedPeople.where(
    (x) => x.group == 'BTS',
  );
  print(bts);
}

// 구조화 하기 위한 클래스
class Person {
  final String name;
  final String group;

  Person({
    required this.name,
    required this.group,
  });
  @override
  String toString() {
    //toString() 함수를 사용하여 객체를 문자열 표현해 준다.
    return 'Person(name: $name, group: $group)';
  }
}

함수형 프로그래밍은 원하는 값을 구하기 위해 아래와 같이 함수를 이어서 작성 할 수 있다.

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

  final result = people
      .map((x) => Person(
            name: x['name']!,
            group: x['group']!,
          ))
      .where((x) => x.group == 'BTS');

  print(result);
}

// 정보를 구조화 하기 위한 클래스
class Person {
  final String name;
  final String group;

  Person({
    required this.name,
    required this.group,
  });
  @override
  String toString() {
    //toString() 함수를 사용하여 객체를 문자열 표현해 준다.
    return 'Person(name: $name, group: $group)';
  }
}