where()

• 조건(배열 요소)을 필터링 할 때 쓰는 함수다.

  변수명.where((리스트 값을 사용할 변수) => 조건).forEach(print);

• 예제

  • 코드

    void main() {
      var list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
      var filterList = list.where((e) => e % 3 != 0); // 배열에서 3의 배수가 아닌 값만 필터링한다.
      print(filterList); // (1, 2, 4, 5, 7, 8, 10) Iterable 출력
      print(filterList.toList()); // [1, 2, 4, 5, 7, 8, 10] List로 변환 후 출력
      print(filterList.toSet()); // {1, 2, 4, 5, 7, 8, 10} Set으로 변환 후 출력
    }

  firstWhere()

  • firstWhere는 요소를 반복하고 주어진 조건의 첫 번째 요소를 반환한다.

  • firstWhere과 indexWhere의 차이점은 firstWhere는 요소를 반환하고, indexWhere는 일치하는 테스트의 index를 반환하는 것이다.

    • 코드

      bool predicate(String element) {
        return element.length > 5;
      }
      
      void main() {
        List<String> items = ['Salad', 'Popcorn', 'Toast', 'Lasagne'];
      
        // 람다식 문법
        // 람다식: 메서드를 하나의 '식(expression)'으로 표현한 것
        String element1 = items.firstWhere((element) => element.length > 5);
        print(element1); // Popcorn
      
        // 리턴형 문법
        String element2 = items.firstWhere((element) {
          return element.length > 5;
        });
        print(element2); // Popcorn
      
        // 함수 적용
        String element3 = items.firstWhere(predicate);
        print(element3); // Popcorn
      
        // orElse
        String element4 = items.firstWhere(
          (element) => element.length > 10,
          orElse: () => 'None!',
        );
      
          // firstWhere 메서드는 추가로 orElse 매개변수를 사용합니다. 프레디케이트 (길이 > 10)를 만족하는 요소가 없는 경우, orElse 함수에 지정된 기본값을 반환하며, 여기에서는 'None!'입니다.
      
        print(element4); // None!
      }

  • orElse

    • firstWhere 메서드에서 사용
    • 조건을 만족하는 요소를 찾지 못할 때 사용할 기본값을 지정하는 데에 활용
    • 찾지 못한 경우에 실행되는 함수 또는 표현식

  lastWhere()

  • lastWhere는 요소를 반복하고, 주어진 조건의 마지막 요소를 반환한다.

    • 코드

      bool predicate(String element) {
        return element.length > 5;
      } // 주어진 문자열의 길이가 5보다 큰지 여부를 반환
      
      void main() {
        List<String> items = ['Salad', 'Popcorn', 'Toast', 'Lasagne', 'Taco'];
      
        // 람다식 문법
        String element1 = items.lastWhere((element) => element.length > 5);
        print(element1); // Lasagne
      
        // 리턴형 문법
        String element2 = items.lastWhere((element) {
          return element.length > 5;
        });
        print(element2); // Lasagne
      
        // 함수 적용
        String element3 = items.lastWhere(predicate);
        print(element3); // Lasagne
      
        // orElse
        String element4 = items.lastWhere(
          (element) => element.length > 10,
          orElse: () => 'None!',
        );
        print(element4); // None!
      }

map()

• map()함수는 반복되는 값을 다른 형태로 변환하는 방법을 제공하는 함수다.
• map 메서드는 iterable(배열그룹)을 대상으로 forEach를 돌린다.
• 예제
  • 코드

    void main() <{
      var list = [1, 2, 3];
      var newList = list.map((e) => e + 1); // 각 요소(e)에 1을 더한다
      print(list); // [1, 2, 3]
      print(newList); // (2, 3, 4)
    
      list[0] = 0;
    
      print(list); // [0, 2, 3]
      print(newList); // (1, 3, 4)
    
      // 결론은 깊은 복사가 아니라, 얕은 복사가 되고, 항상 newList를 출력할 때마다,
      // list컬렉션에서 (e) => e+1이 연산되서 나온다.
    
      // Dart의 List는 매개변수, '= '등으로 전달할 때, 메모리 주소 값으로 전달되어서
      // 이름이 다르더라도 한 곳에서 요소를 변경하면 모두 다 변경된다. 그래서 깊은 복사를 하려면
      // 아래, 아래 toList()를 참고
    }

toList()

• 다트에서 함수형 프로그래밍을 지원하는 함수의 대부분은 Iterable라는 인터페이스 타입 인스턴스를 반환
• 실제 사용시에는 대부분 리스트 형태로 변환해야 하는 경우가 많음
• toList() 함수는 where(), map()과 같이 [Iterable] 인터페이스를 반환하는 메서드에서 사용가능
• toList는 생성되는 값들을 리스트로 만들어서 반환한다. Dart의 List는 매개변수, '= '등으로 전달할 때, 메모리 주소 값으로 전달되어 이름이 다르더라도 한 곳에서 요소를 변경하면 모두 다 변경된다. 그래서 toList를 사용한다.
  • 코드

    void main() {
      List orderList = [1, 2, 3];
      // toList() 사용
      List zeroList = orderList.toList();
    
      for (int i = 0; i < zeroList.length; i++) {
        zeroList[i] = 0;
      }
      print(orderList); // [1, 2, 3] => 원본 배열의 값이 변경되지 않는다.
      print(zeroList); // [0, 0, 0]
    }

toSet()

• 리스트에 중복된 데이터가 있을 경우 중복을 제거한 리스트를 얻고 싶을 수 있다.

• where() 함수와 toSet() 함수를 함께 사용하면 중복 데이터를 간단하게 제거 가능하다.

  • 코드

    void main() {
      final items = [1, 2, 2, 3, 3, 4, 5];
      var result = [];
      var temp = <int>{}; //set 자료구조형 선언
    
      //for문을 이용한 중복제거 짝수 리스트 구현
      for(var i = 0; i<items.length; i++) {
        if(items[i] % 2 == 0) {
          temp.add(items[i]);
        }
      }
      result= temp.toList();
      print(result);  //2, 4
    
      //where() 함수와 toSet() 함수를 이용한 중복제거 짝수 리스트 구현
      final result2 = items.where((e) => e % 2 == 0).toSet().toList(); //2, 4
    
    }

parse()

• parse()는 변환에 실패하면 예외를 발생시킨다.
• 예외 처리가 필요하며, 오류에 대한 명시적인 처리를 해야 한다.
• parse()는 num 타입에 사용할 수 있다.
• num은 Dart의 숫자 타입 중에서 int와 double을 모두 포함하는 상위 타입이다.
• tryParse()를 사용하는 것이 안전하고 예측 가능하다.
• 사용자에게 입력을 받을 때 입력이 숫자가 아닐 수 있으므로 예외 처리가 번거로울 수 있다.
• tryParse()는 실패 시에 null을 반환하여 이를 간단하게 처리할 수 있다.
• parse()는 정확한 형태의 숫자 문자열이 와야 하며, 그렇지 않으면 예외를 발생시키므로 주의해서 사용해야 한다.

    String userInput = "42";
    
    try {
      num number = num.parse(userInput);
      print('숫자로 성공적으로 변환: $number');
    } catch (e) {
      print('숫자로 변환 실패');
    }

tryParse()

• tryParse()는 Dart에서 사용되는 숫자 파싱 함수 중 하나다.
• 이 함수는 문자열을 숫자로 변환하려고 시도하고, 변환이 성공하면 숫자를 반환하고 실패하면 null을 반환한다.
• tryParse() 함수는 주로 사용자로부터 입력받은 문자열을 숫자로 변환할 때나 문자열이 유효한 숫자인지 확인할 때 유용하게 사용된다. 위 예제에서 tryParse() 함수는 문자열 "42"를 정수로 변환하고, 변환이 성공하면 숫자를 출력하고 실패하면 변환 실패 메시지를 출력한다.
  
• tryParse() 함수는 int, double과 같은 숫자 타입에 사용할 수 있다. 문자열이 유효한 숫자가 아닌 경우에는 null을 반환한다.

  void main() {
    String userInput = "42";
  
    // 문자열을 정수로 변환 시도
    int? number = int.tryParse(userInput);
  
    // 변환 결과 확인
    if (number != null) {
      print('숫자로 성공적으로 변환: $number');
    } else {
      print('숫자로 변환 실패');
    }
  }

sort()

• list에 sort() 메서드를 사용해서 값을 정렬 할 수 있다. 반환 값은 0보다 작거나, 0이거나, 0보다 커야되고, 해당 값을 기준으로 정렬한다. 문자열을 비교하는 경우에는 compareTo() 메서드를 사용한다.
• 예제
  • 코드1

    void main() {
      // list 정렬, 숫자
      var sortNumbers = [100, 22, 55, 333, 1, 128, 1024, 32, 989];
    
    	// 리스트 정렬, 비교 함수로 (a, b) => a - b 사용
      sortNumbers.sort((a, b) => a - b);
    	// 비교 함수의 반환값이 음수면 a가 b보다 작다는 의미이므로 a를 앞으로 배치
      // 비교 함수의 반환값이 0이면 a와 b가 같다는 의미이므로 순서 변경 없음
      // 비교 함수의 반환값이 양수면 a가 b보다 크다는 의미이므로 b를 앞으로 배치
    
      print(sortNumbers); // [1, 22, 32, 55, 100, 128, 333, 989, 1024]
    
      // list 정렬, 문자
      var sortFruits = [
        'kiwis',
        'bananas',
        'apples',
        'oranges',
        'watermelons',
        'mangos',
        'durians',
      ];
      sortFruits.sort((a, b) => a.compareTo(b));
      print(
          sortFruits); // [apples, bananas, durians, kiwis, mangos, oranges, watermelons]
    }

fold()

• 배열의 조건을 누적시켜서 반환한다.

• index는 numbers 값의 index 값이고, 첫 번째 파라미터 0번부터 element 자리의 numbers 값을 할당하면서 반복된다. 그리고 total 파라미터 자리에는 이전에 리턴 받은 결과 값이 누적되는 방식이다.

  • 코드

    void main() {
      List<int> numbers = [0, 1, 2, 3, 4, 5];
    
      int sum = numbers.fold(0, (total, element) {
        // 0은 첫번 째로 시작할 값이고, total은 이전에 리턴해 준 값이다.
        // 괄호(기능수행역역) 안에서 반복한다.
        return total + element;
      });
      print(sum);
    
      // fold메서드가 진행되는 과정
      // index = 0
      // element = 0
      // total = 0
      // return = 0 + 0 => 0
    
      // index = 1
      // element = 1
      // total = 0
      // return = 0 + 1 => 1
    
      // index = 2
      // element = 2
      // total = 1
      // return = 1 + 2 => 3
    
      // index = 3
      // element = 3
      // total = 3
      // return = 3 + 3 => 6
    }

reduce()

• reduce() 함수는 반복 요소를 줄여가면서 결과를 만들때 사용하는 함수다.

• 항상 2개의 인수를 받고, 반환값은 인수와 같은 타입이어야 한다.

• reduce 메서드는 fold와 큰 차이가 없고, fold에서는 시작 값 0을 지정하는데, reduce에서는 생략한다.

  • 코드

    void main() {
        // 정수형 리스트 생성
      List<int> numbers = [0, 1, 2, 3, 4, 5];
    
        // reduce 함수를 사용하여 리스트의 합을 계산
      int sum = numbers.reduce((total, element) {
        return total + element;
      });
      print(sum); // 15
    
      // 람다식 간소화
      int sum2 = numbers.reduce((total, element) => total + element);
      print(sum2); // 15
    }