[Flutter] 3.함수형 프로그래밍

✅ 값 형태 변환

List<String> newJeans = ['하니', '민지', '혜린', '다니엘', '해인', '해인'];

print(newJeans); // [ 하니, 민지, 혜린, 다니엘, 해인, 해인 ]
print(newJeans.asMap()); // { 0:하니, 1:민지, 2:혜린, 3:다니엘, 4:해인, 5:해인 }
print(newJeans.toSet()); // { 하니, 민지, 혜린, 다니엘, 해인 } => 중복 제거

Map newJeansMap = newJeans.asMap();

print(newJeansMap.keys); // (0, 1, 2, 3, 4, 5)
print(newJeansMap.values); // (하니, 민지, 혜린, 다니엘, 해인, 해인)

// .toList(): List 형태로 변환
print(newJeansMap.keys.toList()); // [0, 1, 2, 3, 4, 5]

// List -> Set {}
Set newJeansSet = Set.from(newJeans);

// Set -> List []
print(newJeansSet.toList());

List<String> newJeans = ['하니', '민지', '혜린', '다니엘', '해인'];

// map(): 또 다른 형태로 변경
final newNewJeans = newJeans.map((x) {
	return '뉴진스 $x';
})

// === 위와 동일 (좀 더 간략한 코드)
final newNewJeans2 = newJeans.map((x) => '뉴진스 $x');

// iterable
print(newNewJeans); // (뉴진스 하니, 뉴진스 민지, 뉴진스 혜린, 뉴진스 다니엘, 뉴진스 해인)
print(newNewJeans.toList()); // [뉴진스 하니, 뉴진스 민지, 뉴진스 혜린, 뉴진스 다니엘, 뉴진스 해인]

// map울 사용하면 새로운 List newJeans가 계속 만들어짐
print(newJeans == newJeans); // true
print(newNewJeans == newJeans); // false
print(newNewJeans == newNewJeans2); // false

String number = '13579';

final parsed = number.split('').map((x) => '$x.jpg').toList();

print(parsed); // [1.jpg, 3.jpg, 5.jpg, 7.jpg, 9.jpg]

‣ Map → Map

Map<String, String> fruits = {
	'apple': '사과',
	'peach': '복숭아',
	'banana': '바나나'
};

final result = fruits.map((key, value) => MapEntry('KEY $key', 'VALUES $values'));

print(fruits); // { apple: 사과, peach: 복숭아, banana: 바나나 }
print(result); // { KEY apple: VALUES 사과, KEY peach: VALUES 복숭아, KEY banana: VALUES 바나나 }

‣ Keys / Values → List

final keys = fruits.keys.map((x) => 'FRUIT $x').toList();
final values = fruits.values.map((x) => '과일 $x').toList();

print(keys); // [FRUIT apple, FRUIT peach, FRUIT banana]
print(values); // [과일 사과, 과일 복숭아, 과일 바나나]

‣ Set → Set

Set newJeansSet = {'하니', '민지', '혜린', '해인', '다니엘'};

final newSet = newJeansSet.map((x) => '뉴진스 $x').toSet();

print(newSet); // {뉴진스 하니, 뉴진스 민지, 뉴진스 혜린, 뉴진스 해인, 뉴진스 다니엘}

---

✅ where

: 조건절

List<Map<String, String>> people = [
	{'name': '하니', 'group': '뉴진스'},
	{'name': '민지', 'group': '뉴진스'},
	{'name': 'v', 'group': 'BTS'},
	{'name': 'jk', 'group': 'BTS'},
]

final bts = people.where((x) => x['group'] == 'BTS').toList();
print(bts); // [{name: v, group: BTS}, {name: jk, group: BTS}]

---

✅ reduce

: 값 누적 계산

• req, res return type 동일해야 함 (만약 다르다면 error)

List<int> numbers = [1, 3, 5, 7, 9];

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

---

✅ fold

• reduce와 기능은 동일하지만 req, res return type이 동일하지 않아도 됨
  → return type 지정해야 함
• 첫번째 값은 1번째 parameter에 지정해야 함

// 첫번째 parameter인 0이 첫번째 시작 값
final sum = numbers.fold<int>(0, (prev, next) => prev + next);
print(sum); // 25

List<String> words = ['안녕하세요, ', '오늘은 ', '일요일입니다'];

final count = words.fold<int>(0, (prev, next) => prev + next.length);
print(count); // 17 (공백 포함)

---

✅ cascading operator : ...

List<int> even = [2, 4, 6, 8];
List<int> odd = [1, 3, 5, 7];

print([...even, ...odd]); // [2, 4, 6, 8, 1, 3, 5, 7]
print(event); // [2, 4, 6, 8]
print([...even]); // [2, 4, 6, 8]
print(even == [...even]); // false <- 완전히 새로운 리스트에다가 값을 풀어 넣을 수 있음

---

✅ 함수형 프로그래밍 장점

1. 새로운 값 생성 가능
2. 여러 개의 함수들 체이닝 → 새로운 형태 생성 가능
3. 코드 간결해짐

🧚‍♀️ 배운 개념 mix해서 코드로 함수형 프로그래밍 장점 알아보기

List<Map<String, String>> people = [
	{'name': '하니', 'group': '뉴진스'},
	{'name': '민지', 'group': '뉴진스'},
	{'name': 'v', 'group': 'BTS'},
	{'name': 'jk', 'group': 'BTS'},
]

// name, group 각각의 값이 존재하다는 것을 확실하게 하기 위해 ! 추가 -> ! 붙이지 않으면 error
final parsedPeople = people.map((x) => Person(name: x['name']!, group: x['group']!)).toList();

print(parsedPeople); // [Instance of 'Person', Instance of 'Person', Instance of 'Person', Instance of 'Person']

// Map의 경우 자유도가 높음 -> class로 변환하면 데이터 구조 신뢰할 수 있게 됨 -> 오타 걱정 필요없음
class Person {
	final String name;
	final String group;
	
	Person({
		required this.name,
		required this.group,
	});
	
	@override
	String toString() {
		return 'Person(name: $name, group: $group)';
	};
}

// @override 추가 후
print(parsedPeople); // [Person(name: 하니, group: 뉴진스), Person(name: 민지, group: 뉴진스), Person(name: v, group: BTS), Person(name: jk, group: BTS)]

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

final bts = parsedPeople.where((x) => x.group == 'BTS');
print(bts); // (Person(name: v, group: BTS), Person(name: jk, group: BTS))

// === 위의 parsedPeople, bts를 체이닝해서 한번에 작성 가능!

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