Dart 문법(2)

## 해당 글은 강의를 들으면서 알고있던것을 적는게 아닌, 모르고 있던것을 알았을때 적어 놓은것임

< 컬렉션 >

List

여러개의 같은 타입의 값을 그룹으로 묶어서 효율적으로 관리할 수 있음

// indexOf 를 통해 특정 요소의 Index 값을 알 수 있다.
// 만약 중복 요소가 있을 경우 앞 index를 반환하고, 없으면 -1을 반환한다.
List<String> s = ['K','A','S','K'];
print(s.indexOf('K')); // 0
print(s.indexOf('G')); // -1

// add, addAll 을 통해 특정 요소를 추가할 수 있다.
// 추가적인 index값을 넣어주면, 해당 index값으로 값을 넣을 수 있다. default값은 마지막에
List<String> s = ['K','A','S','K'];
print(s.add('M'));  // ['K','A','S','K','M']
print(s.add(2,'P'));  // ['K','A','P','S','K','M']  // index 2 값으로 'P'가 들어감
print(s.addAll(3,['B','E']);  // ['K','A','P','B','E','S','K','M']  // index 2 값으로 'B','E'가 들어감

// remove, removeAt 을 통해 특정 요소를 삭제할 수 있다
// remove를 통해 삭제할 경우, 맨 앞에 있는 요소 하나만을 삭제한다.
List<String> s = ['K','A','S','K'];
print(s.remove('K')); // ['A','S','K']
print(s.removeAt(2)); // ['A','S']

// contains을 통해 특정 요소가 있는지 알 수 있다.
List<String> s = ['K','A','S','K'];
print(s.contains('K'));  // true

 

Set

중복되지 않는 값들이 묶인 형태로써, 집합과 비슷한 형태로 관리. 각 요소는 순서가 없으므로 index 값이 존재하지 않음

// Set의 선언 및 초기화 {}를 사용한다.
// '중복되지 않는' 이라는 것이 가장 중요!
// 다른 타입에서 Set으로 바꿀 경우, 중복되는 값이 자동으로 제거된다!
Set<int> numbers = {1,2,3,4,5};
var obj = <String>{};  // 타입 추론 형태로 Set를 설정하는데 요소를 넣지 않고 싶은 경우

// containsAll을 통해 여러 요소가 포함되어 있는지 한번에 판별할 수 있다.
Set<int> numbers = {1,2,3,4,5};
print(numbers.containsAll({'2','5'});  // true

// difference 를 통해 포함되지 않는 요소를 반환할 수 있다.
Set<int> nums1 = {1,2,3,4,5};
Set<int> nums2 = {2,4,5};
print(nums1.difference(nums2));  // {1,3}

 

Map

Key 값과 Value 값이 묶인 하나의 쌍으로 이루어진 형태로 관리

// Map의 선언 {}을 사용
// 각각의 Key 값은 중복될 수 없다!(고유한 특성을 가져야 하는 key) 하지만, Value 값은 중복될 수 있다.
Map<String, int> p = {'A': 2, 'B': 5};
var p = {};  // 타입 추론 형태로 Map를 설정하는데 요소를 넣지 않고 싶은 경우

// [변수이름[키이름]]을 통해 Value값을 검색할 수 있다.
Map<String, int> p = {'A': 2, 'B': 5};
print(p['B']);  // 5
print(p['C']);  // null

// [변수이름[키이름]]을 통해 Value 값을 수정할 수 있다.
Map<String, int> p = {'A': 2, 'B': 5};
p['A'] = 4;
print(p['A']);  // 4

// [변수이름[키이름]]을 통해 새로운 key 와 value를 추가 할 수 있다.
Map<String, int> p = {'A': 2, 'B': 5};
p['C'] = 8;
print(p);  // {'A': 2, 'B': 5, 'C': 8}

// remove(키이름)를 통해 요소를 삭제할 수 있다.
Map<String, int> p = {'A': 2, 'B': 5};
p.remove('A');
print(p);  // {'B': 5}

// containsKey(키이름)을 통해 특정 요소가 있는지을 알 수 있다.
Map<String, int> p = {'A': 2, 'B': 5};
print(p.containsKey('B'));  // true

// keys 를 통해 map 안에 있는 모든 키들을 알 수 있다.
// keys 는 반환할때 Iteralbe<-> 값을 반환한다.
Map<String, int> p = {'A': 2, 'B': 5};
print(p.keys);  // ('A','B')

// values를 통해 모든 value 값들을 알 수 있다.
// values 는 반환할때 Iteralbe<-> 값을 반환한다.
Map<String, int> p = {'A': 2, 'B': 5};
print(p.values);  // (2,5)

 

< 열거형 >

여러개의 상수 값을 묶은 형태

// 열거형 선언
// 열거형의 선언은 반드시 전역적으로 선언되어야 하므로, main이나 함수 안에서 선언할 수 없다!!
enum Sound {
  loud,
  small,
}

// 열거형에 포함된 값에 접근하는 방법
var mySound = Sound.loud;
print(mySound);  // Sound.loud

// index를 통해 열거형에 포함된 값의 index를 출력할 수 있다.
print(Sound.small.index);  // 1

// values를 통해 열거형에 포함된 값들을 알 수있다. List 형태로 반환한다.
print(Sound.values);  // [loud,small]

// name을 통해 열겨헝에 포함된 값의 이름을 알 수 있다.
print(Sound.loud.name);  // loud

 

< 함수 >

특정 작업을 수행하는 코드 블록

// a와 b의 값을 더하는 간단한 함수
int add(int a, int b) {
  return a + b;
}

 

< 제네릭 >

클래스나 함수에서 데이터 타입을 일반화하여 다양한 타입을 지원할 수 있게 해주는 기능

 

• 제네릭 함수

// 제네릭 함수를 선언하는 방법
// [타입 파라미터] [함수 이름]<타입 파라미터>([매개변수]) { … }
T getFirstElement<T>(List<T> list) {
  return list[0];
}

// 제네릭 함수는 특정 타입에 의존하지 않는, 여러 타입에 대응하는 함수를 짤 수 있게 만들어 준다.
// 다만, 제네릭타입인 T는 Dart에 존재하는 모든 타입을 상정하기 때문에 연산자를 사용하는 함수를 만들때는 주의해야 한다!

int getFirstNumber(List<int> numbers) {
  return numbers[0];
}
String getFirstWord(List<String> words) {
  return words[0];
}

==> 제네릭 함수형태를 적용한 모습

T getFirstElement<T>(List<T> list) {
  return list[0];
}

///
// 일부 타입 형태에서만 사용하게 만들려면, 제한이라는 방법을 사용해서 일부 타입에서만 작동하게 할 수 잇다.
// T extends num 을 통해 제네릭타입 T를 num 하위 타입으로만 제한할 수 있다.

T add<T extends num>(T a, T b) {
// 여기서 (a+b) 를 as T 로 변환해서 반환하는 이유는 a 와 b 의 타입이 다르게 들어왔을 경우에 문제가 생길 수 있기 때문
  return (a + b) as T;
}