Dart 기초 문법

변수 선언 및 사용

기본 자료형

•

int : 정수

•

double : 실수

•

num : num > double > int

◦

abs(), ceil(), floor() 연산에 필요한 메서드가 포함되어있음

•

bool : true or false

•

String : 문자

1. 타입 추론형

// 할당하는 값에 따라서 변수의 타입이 결정됨
// 코드 가독성 및 안정성을 위하여, 난해한 타입이 아닌 경우 자제..
var aa = 'foo';
var bb = 1;

// var와 마찬가지로 할당하는 값에 따라 변수의 타입이 결정된다.
dynamic a = 1;
dynamic b = false;
dynamic c = 'aaa';

// var와 dynamic의 차이는 최초 할당한 변수에 다른 타입을 할당할 수 있는지 차이가 있다.
var z = 1;
z = 'x'; // X

dynamic y = 1;
y = 'y' // O
Dart
복사

2. 타입 선언형 (권장)

String aa = 'foo';
int bb = 1;
Dart
복사

3. Null Safety :: Dart 2.0 ~

// 기본적으로 none-nullble
String b = 'aa';

// null을 허용 하는 변수일 경우 타입 뒤에 ?를 붙인다.
// String? a = null;
String? a;

// 변수를 사용할 때, 해당 변수의 값은 절대 null이 아니라고 정의할때 변수 뒤에 !를 붙인다.
print(b!);
Dart
복사

4. final and const

// final, const 키워드 사용 시 변수의 타입 (var) 생략 가능
// 값을 변경 할 수 없는 변수. 컴파일 레벨에서 검증

// 빌드 타임에 값을 알고 있지 않아도 됨 (const과 차이).
// 예시 : DateTime.now()을 사용 가능.
final String c = 'aa';

// 값을 변경 할 수 없는 변수. 컴파일 레벨에서 검증
// 빌드 타임에 값을 알고 있어야함 (final과 차이).
// 예시 : DateTime.now()을 사용 못함.
const String d = 'aa';

final DateTime now = DateTime.now();
print(now);
Dart
복사

5. ?? and ??= :: null 인식 연산자

// ?? 좌측 변수의 값이 null이면 우측 값을 출력
print(null ?? 10);

// variable ??= value
// 좌측 변수가 null 이면 f의 값을 우측 값을 할당.
f ??= 'haha';
print(f);
Dart
복사

6. is :: 변수의 타입 확인

int g = 1;
print(g is int);
print(g is String);

print(g is! int);
print(g is! String);
Dart
복사

7. … :: spred operator

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

print([odd, even]);

final appendList = [...odd, ...even];
print(appendList);
Dart
복사

8. String Interpolation

final name = '김둘리';
final age = 31;
print('저의 이름은 ${name}이고, 나이는 ${age}살입니다.');

// 문자열 내에서 변수 값의 함수를 사용하지 않는다면 {} 생략 가능
print('저의 이름은 $name이고, 나이는 $age살입니다.');

// 문자열 내에서 변수 값의 함수를 사용할 때 {}를 생략하면 . 이후의 값이 문자로 인식
print('name length : ${name.length}'); // O
print('name length : $name.length'); // X
Dart
복사

9. 접근 제한자

Dart 에서 private 범위는 라이브러리 기준이다 (Java 기준으로 패키지)

	Dart	Java
public	AAA	public AAA
private	_AAA	private AAA

자료형 (collection)

collection : elements 라고 불리는 object들의 그룹을 나타내는 object Iterables : 연속적으로 접근할 수 있는 element들의 collection. 순서가 있어야함!

•

collection 은 empty가 될 수 있고, 많은 element를 가질수 도 있다.

•

List : element의 index를 이용하여 읽는다. Iterables 

•

Set : 같은 element가 존재할 수 없다. Not Iterables 

•

Map : key를 이용하여 element를 읽는다. Not Iterables (Linked Map is Iterables)

1. List :: 순서를 가진 값을 나열 / 중복 값 허용

List<String> list = ['a', 'b', 'c'];
print(list);

List<int> list2 = [1, 3, 5];
print(list2);

// index
// 0부터 시작
print(list[0]);

list.add('d');
print(list);

list.remove('d');
print(list);

// 값으로 indexe(순서)를 가져오기
print(list.indexOf('a'));
Dart
복사

2. Map :: Key 와 Value 쌍의 집합 / 중복 값 허용

Map<String, String> dictionary = {
  'name': 'jangwon',
  'gender': 'man',
  'job': 'developer'
};

print(dictionary);

// Map에 item 추가 #1
dictionary.addAll({'hobby': 'coding'});

print(dictionary);

// Map에 item 추가 #2
dictionary['state'] = 'busy';

print(dictionary);

// Map에 item 변경 #1
dictionary.addAll({'hobby': 'sleep'});

// Map에 item 변경 #2
dictionary['state'] = 'angry';

print(dictionary);

// Map의 item 삭제
dictionary.remove('state');
print(dictionary);

// Map의 전체 item의 key 가져오기
print(dictionary.keys);

// Map의 전체 item의 value 가져오기
print(dictionary.values);

for (String k in dictionary.keys) {
  print(dictionary[k]);
}
Dart
복사

3. Set :: 값들의 집합 / 중복 값 미허용

// 중복 값을 선언해도 값이 할당되는 시점에서 중복 값을 제거해줌.
final Set<String> ids = {'aaaa', 'ssss', 'ffff', 'dddd', 'dddd'};
print(ids);

// 아이템 추가
ids.add('hhh');
print(ids);

// 아이템 삭제
ids.remove('pjw');
print(ids);

print(ids.contains('dev'));
Dart
복사

제어문

1. Loop :: for, for-in, while, do-while

// for loop
for (int i = 0; i < 5; i++) {
  print(i);
}

List<int> ilist = [10, 20, 30, 40, 50];
for (int i = 0; i < ilist.length; i++) {
  print(ilist[i]);
}

// for in loop : variable in collection
for (int n in list2) {
  print(n);
}

for (String s in ids) {
  print(s);
}

// while loop
int q = 0;
while (q < 5) {
  print('hello');
  q += 1;
  
  if (q == 3) {
    break;
  }
}
Dart
복사

2. if

if (condition) {
	// somethig....
}

if (condition) {
	// somethig....
} else {
	// somethig....
}

if (condition A ) {
	// somethig....
} else if (condition B) {
	// somethig....
} else {
	// somethig....
}
Dart
복사

3. Switch

var command = 'dart';
switch (command) {
  case 'c':
  case 'python':
  case 'java':
  case 'go':
    print("go");
    break;

  case 'dart':
    print("dart");
    continue defaultValue;

  defaultValue:
  default:
    print("default");
    break;
}
Dart
복사

함수 선언 및 사용

1. 함수

void main() {
  justPrint();
  print('');

  sum(1, 2, 3);
  print('');

  sum2(x: 1, z: 3, y: 2);
  print('');

  sum3(x: 1, z: 3, y: 2);
  print('');

  sum3(option: 'pjw', x: 1, y: 2, z: 3);
  print('');

  print(arrowTest(1));
  print(arrowTest(11));
  print('');

  Operation operation = add;
  print(operation(10, 20, 30));

  operation = subtract;
  print(operation(10, 20, 30));
  
  print(calculate(10,20,30, add));
  print(calculate(10,20,30, subtract));
}

// 함수의 기본 반환 타입은 void
justPrint() {
  print('hello world!');
}

// use case :: positional parameter
int sum(int x, int y, int z) {
  print('sum() :: arg x : $x');
  print('sum() :: arg y : $y');
  print('sum() :: arg z : $x');

  int sum = x + y + z;
  return sum;
}

// use case :: named parameter
// 함수 호출 시 변수의 이름을 지정하여 인자값 할당하기 때문에
// 인자의 순서를 안지켜도 된다.
int sum2({required int x, required int y, required int z}) {
  print('sum2() :: arg x : $x');
  print('sum2() :: arg y : $y');
  print('sum2() :: arg z : $x');

  int sum = x + y + z;
  return sum;
}

// use case :: optional parameter
int sum3(
    {required int x,
    required int y,
    required int z,
    String? option,
    int a = 10}) {
  print('sum3() :: arg x : $x');
  print('sum3() :: arg y : $y');
  print('sum3() :: arg z : $x');
  print('sum3() :: default arg a : $a');

  if (option != null) {
    print('sum3() :: arg option : $option');
  }

  int sum = x + y + z;
  return sum;
}

// use case :: arrow function
bool arrowTest(int x, {int y = 10}) => x > y;

// use caset :: typedef
// body가 없는 함수
// signature 라고 부름
typedef Operation = int Function(int x, int y, int z);

int add(int x, int y, int z) => x + y + z;

int subtract(int x, int y, int z) => x - y - z;

int calculate(int x, int y, int z, Operation operation) {
  return operation(x, y, z);
}
Dart
복사

OOP : Object Oriented Programing 객체지향 프로그래밍

1. 클래스

void main() {
  final String name1 = '개발팀';
  final List<String> member1 = ['홍길동', '둘리', '또치'];
  Team ateam = Team(name1, member1);
  print(ateam.name);
  print(ateam.member);
  print('');

  ateam.sayHello();
  ateam.memberList();

  print('');
  print('------------------------');
  print('');

  String name2 = '디자인팀';
  List<String> member2 = ['김삼성', '이애플', '홍삼'];

  Team bteam = Team.fromList([name2, member2]);

  print(bteam.name);
  print(bteam.member);
  print('');

  bteam.sayHello();
  bteam.memberList();
  
  print(bteam.firstMember);
  bteam.firstMember = '개발자';
  
  bteam.memberList();
}

class Team {
  final String name;
  final List<String> member;

  // 기본 생성자
  // const Team(String name, List<String> member)
  //     : this.name = name,
  //       this.member = member;

  // 기본 생성자
  // 보다 간단하게 쓰기.
  const Team(this.name, this.member);

  Team.fromList(List values)
      : this.name = values[0],
        this.member = values[1];

  void sayHello() {
    print('안녕하세요. ${this.name}입니다.');
  }

  void memberList() {
    print('팀원 : ${this.member}');
  }
  
  // getter
  String get firstMember{
    return this.member[0];
  }
  
  // setter
  void set firstMember(String name) {
    this.member[0] = name;
  }
}
Dart
복사

2. 상속

void main() {
  Person person = Person(name: '개발자', age: 50);
  print(person.name);
  print(person.age);
  person.sayHello();
  
  print('---------------');
  Man man = Man('남자개발자', 31);
  man.sayHello();
  man.functionForMan();
  
  print('---------------');
  Women women = Women('여자개발자', 28);
  women.sayHello();
  women.functionForWomen();
  
  
  print('------- Type Comparison 1 --------');
  print(person is Person);
  print(person is Man);
  print(person is Women);
  
  print('------- Type Comparison 2 --------');
  print(man is Person);
  print(man is Man);
  print(man is Women);
  
  print('------- Type Comparison 3 --------');
  print(women is Person);
  print(women is Man);
  print(women is Women);
  
}

class Person {
  String name;
  int age;

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

  void sayHello() {
    print('안녕하세요. ${this.name}입니다.');
  }
}

class Man extends Person {
  Man(String name, int age) : super(name: name, age: age);
  
  void functionForMan() {
    print('저는 $age살이고, 이름은 $name입니다. 성별은 남자입니다.');
  }
}

class Women extends Person {
  Women(String name, int age) : super(name: name, age: age);
  
  void functionForWomen() {
    print('저는 $age살이고, 이름은 $name입니다. 성별은 여자입니다.');
  }
}
Dart
복사

this와 super의 차이? this : 자기 자신을 지칭 (class) super : 상속 혹은 구현 대상인 부모 객체를 지칭 (extends or implements)

3. 메서드 오버라이딩

void main() {
  TimesTwo tt = TimesTwo(2);
  print(tt.calculate());

  TimesFour tf = TimesFour(2);
  print(tf.calculate());
}

class TimesTwo {
  final int number;

  TimesTwo(this.number);

  int calculate() {
    return number * 2;
  }
}

class TimesFour extends TimesTwo {
  TimesFour(int number) : super(number);

  @override
  int calculate() {
    // return super.number * 4; // fm
    // return number * 4;
    return super.calculate() * 2;
  }
}
Dart
복사

4. Static

void main() {
  // Person : class
  // a : instance
  Person a = Person('김기사');
  Person b = Person('오사장');

  a.printNameAndCountry();
  b.printNameAndCountry();
  print('');

  Person.country = '한국';
  a.printNameAndCountry();
  b.printNameAndCountry();
  print('');

  Person c = Person('박비서');
  b.printNameAndCountry();
  print('');
  
  Person.printCountry();
}

// static : instanse가 아닌 class에 귀속된다.
class Person {
  static String? country;
  final String name;

  Person(this.name);

  void printNameAndCountry() {
    print('제 이름은 $name입니다. 국적은 $country입니다.');
  }

  static void printCountry() {
    print('우리의 국적은 $country입니다.');
  }
}
Dart
복사

5. Interface

void main() {
  Man man = Man('둘리');
  man.sayHello();

  Women women = Women('하니');
  women.sayHello();
  print('');

  print('------- Type Comparison 1 --------');
  print(man is PersonInterface);
  print(man is Man);
  print(man is Women);

  print('------- Type Comparison 1 --------');
  print(women is PersonInterface);
  print(women is Man);
  print(women is Women);
}

// Interface : 유사한 객체의 구조를 정의하여 강제화하는 역할
abstract class PersonInterface {
  String name;

  PersonInterface(this.name);

  void sayHello();
}

class Man implements PersonInterface {
  String name;

  Man(this.name);

  @override
  void sayHello() {
    print('안녕하세요. 저는 남자이고, 이름은 $name라고 합니다.');
  }
}

class Women implements PersonInterface {
  String name;

  Women(this.name);

  @override
  void sayHello() {
    print('안녕하세요. 저는 여자이고 이름은 $name라고 합니다.');
  }
}
Dart
복사

6. Generic :: 타입을 외부에서 주입 받을 때 사용. (인스턴스화 시점)

void main() {
  Person<String> a = Person('a', '치킨');
  a.printIdType();
  print('');

  Person<int> b = Person(1, '피자');
  b.printIdType();
  print('');

  Person2<String, String> c = Person2('c', '감자');
  c.printIdAndNameType();
  print('');

  Person2<int, String> d = Person2(4, '고구마');
  d.printIdAndNameType();
  print('');
}

// generic type은 원하는 단어로 설정 가능 : T, X, 고구마 등..
class Person<T> {
  final T id;
  final String name;

  Person(this.id, this.name);

  void printIdType() {
    print(id.runtimeType);
  }
}

// generic Type은 원하는 만큼 추가할 수 있다.
class Person2<T, X> {
  final T id;
  final X name;

  Person2(this.id, this.name);

  void printIdAndNameType() {
    print('id : ${id.runtimeType}, name : ${name.runtimeType}');
  }
}
Dart
복사

7. Setter/Getter

import 'dart:math';

class Person {
  late final String _name;
  
  String get name => _name;
  set name(String value) => _name = value;
}

void main() {
 
  Person p = Person();
  p.name = 'banana'; // 필드 접근과 동일하게 접근
  print(p.name);
  
}
Dart
복사

8. Parameter

•

named parameter

num add({
    required int x, 
    required int y
  }) {
  return x + y;
}

void main() {
  print(add(x: 1, y: 2));  
}
output : 3
Dart
복사

•

default parameter

num add(
    int x, 
    int y
  ) {
  return x + y;
}

void main() {
  print(add(1, 2));  
}
output: 3
Dart
복사

•

optional parameter

num add(
    int x, 
    int y,
    {int? z} // {int z = 10}
  ) {
  return x + y + (z ?? 0);
}

void main() {
  print(add(1, 2));  
}
output: 3

or 

void main() {
	print(add(1, 2, z:5));
}
output : 8
Dart
복사

9. Mixin

•

with 키워드를 사용하여 상속하지 않고 다른 클래스의 기능을 가져오거나 오버라이드할 수 있음

class Cat implemets Animal {
  
  @override
  void eat() {
    print("고양이가 음식을 먹습니다")
  }
  
}

class PersianCat extends Cat with Biology {
  
}
Dart
복사

함수형 프로그래밍 Dart는 객체지향 프로그래밍과 함수형 프로그래밍의 특성을 모두 제공한다.

1. 일급 객체 :: 함수를 값으로 사용

void main() {
	var a = some;
	a('hello, world!');
}

void some(String text){
	print(text);
}
Dart
복사

2. 익명 함수 :: Anonymous Function

() {}

or

(value) {
	return value + " true";
}
Dart
복사

3. Arrow Function :: 중요

final newList = list.map((x) {
  return 'dev $x';
});
print(newList);
print(newList.toList());
print('');

// use arrow fuction
final newList2 = list.map((x) => 'dev $x');
print(newList2);
print(newList2.toList());
print('');

// map() 함수는 새로운 객체를 반환함을 확인
print(newList == newList2);
print('');
Dart
복사

4. 함수형 프로그래밍 활용 사례

String to List

// 1234 -> [1.png, 2.png, 3.png, 4.png]
String number = '1234';
print(number);

final parsed = number.split('').map((x) => '$x.png').toList();
print(parsed);
Dart
복사

List to Map :: asMap()

List<String> list = ['a', 'b', 'c', 'd', 'd'];
Map map = list.asMap();
print(map.keys);
print(map.values);
Dart
복사

List to Set to List

List<String> list = ['a', 'b', 'c', 'd', 'd'];
Set set = Set.from(list);
print(set.toList());
print('');
Dart
복사

Map to Map

Map<String, String> fruits = {'apple': '사과', 'banana': '바나나', 'grape': '포도'};

final newFruits = fruits.map(
  (key, value) => MapEntry('Fruits $key', '과일 $value'),
);

print(fruits);
print(newFruits);
Dart
복사

Map to List :: toList()

Map<String, String> fruits = {'apple': '사과', 'banana': '바나나', 'grape': '포도'};
final keys = fruits.keys.map((x) => 'Fruits $x').toList();
final values = fruits.values.map((x) => '과일 $x').toList();
print(keys);
print(values);
Dart
복사

Set to Set

  Set set = {
    '사과',
    '바나나',
    '포도',
  };
  print(set);

  final newSet = set.map((x) => 'New $x').toSet();
  print(newSet);
Dart
복사

where()

List<Map<String, String>> people = [
  {'name': '김기사', 'country': 'korea'},
  {'name': '박사장', 'country': 'korea'},
  {'name': '샤오미', 'country': 'china'},
  {'name': '잡스', 'country': 'usa'}
];

// where() return bool
// 필터링 할 때 사용
final korean = people.where((x) => x['country'] == 'korea').toList();
print(korean)
Dart
복사

reduce()

List<int> number = [1, 3, 5, 7, 9];
// reduce() 컬렉션의 아이템을 모두 더하는 함수
// reduce() 함수는 인자 값의 타입과 return 타입이 동일해아햔다.
final sumAll = number.reduce((prev, next) {
  print('-----------');
  print('previous : $prev');
  print('next : $next');
  print('total : ${prev + next}');

  return prev + next;
});
print(sumAll);
Dart
복사

reduce() :: use arrow function

List<int> number = [1, 3, 5, 7, 9];
// return 구문을 생략할 수 있다
final sumAllsimple = number.reduce((prev, next) => prev + next);
print(sumAllsimple
Dart
복사

fold()

List<int> number = [1, 3, 5, 7, 9];
// fold() reduce와 유사하지만, return을 지정할 수 있다.
final sumAll2 = number.fold<int>(0, (prev, next) => prev + next);
print(sumAll2);
Dart
복사

fold() :: 인자 값과 reurn 타입이 다른 케이스

List<String> strList = ['안녕하세요 ', '저는 ', '한국 사람입니다.'];
final wordsLength = strList.fold<int>(0, (prev, next) => prev + next.length);
print(wordsLength);
Dart
복사

Map to Class

void main() {
  List<Map<String, String>> people2 = [
    {'name': '김기사', 'country': 'korea'},
    {'name': '박사장', 'country': 'korea'},
    {'name': '샤오미', 'country': 'china'},
    {'name': '잡스', 'country': 'usa'}
  ];

  // Map to Class
  // 안전한 프로그래밍을 위하여 구조화가 필수
  final parsedPeople = people2.map(
    (x) => People(name: x['name']!, country: x['country']!),
  );

  print(people2);
  print(parsedPeople);

  // class로 변환하였기 때문에, 자동완성기능을 활용할 수도 있다. (컴파일이 되기 때문에..)
  final korean2 = parsedPeople.where((x) => x.country == 'korea');

  print(korean2);

  // map() 과 where() 를 연달아서... 메서드 체이닝
  final result = people
      .map(
        (x) => People(name: x['name']!, country: x['country']!),
      )
      .where((x) => x.country == 'korea');

  print(result);
}

class People {
  final String name;
  final String country;

  People({required this.name, required this.country});

  @override
  String toString() {
    return 'People(name:$name, country: $country)';
  }
}
Dart
복사

비동기 프로그래밍

1. Future

// Future - 미래
// 미래에 받아올 값
Future<String> name = Future.value('둘리');
Future<int> number = Future.value(1);
Future<bool> isTrue = Future.value(true);

// delayed - 지연되다
// 2개의 파라미터
// 1번 파라미터 : 지연할 기간
// 2번 파라미터 : 지연 시간이 지난 후 실행 할 함수
Future.delayed(Duration(seconds: 2), () {
	print('Delay 끝');
});
Dart
복사

활용 사례

void main() {
  print('함수 시작');

  addNumbers(1, 1);
  addNumbers(2, 2);
}

void addNumbers(int number1, int number2) {
  print('계산 시작 : $number1 + $number2');

  // 서버 시뮬레이션
  Future.delayed(Duration(seconds: 2), () {
    print('계산 완료 : $number1 + $number2 = ${number1 + number2}');
  });

  print('함수 완료 : $number1 + $number2');
}

[Console]

함수 시작
계산 시작 : 1 + 1
함수 완료 : 1 + 1
계산 시작 : 2 + 2
함수 완료 : 2 + 2
계산 완료 : 1 + 1 = 2
계산 완료 : 2 + 2 = 4
Dart
복사

2. await

// await : 비동기 로직 중 논리적으로 응답을 기다린후 진행되어야 하는 함수에 선언
// await 는 Future를 리턴하는 함수에만 정의 할 수 있다.
// async : await 키워드를 작성할 함수에 정의해야함 (파라미터와 함수 body 사이)
void addNumbers(int number1, int number2) async {
  print('계산 시작 : $number1 + $number2');

  // 서버 시뮬레이션
  await Future.delayed(Duration(seconds: 2), () {
    print('계산 완료 : $number1 + $number2 = ${number1 + number2}');
  });

  print('함수 완료 : $number1 + $number2');
}
Dart
복사

활용 사례 #1

void main() {
  print('함수 시작');

  addNumbers(1, 1);
  addNumbers(2, 2);
}

void addNumbers(int number1, int number2) async {
  print('계산 시작 : $number1 + $number2');

  // 서버 시뮬레이션
  await Future.delayed(Duration(seconds: 2), () {
    print('계산 완료 : $number1 + $number2 = ${number1 + number2}');
  });

  print('함수 완료 : $number1 + $number2');
}

[Console]
함수 시작
계산 시작 : 1 + 1
계산 시작 : 2 + 2
계산 완료 : 1 + 1 = 2
함수 완료 : 1 + 1
계산 완료 : 2 + 2 = 4
함수 완료 : 2 + 2
Dart
복사

활용 사례 #2

void main() async {
  print('함수 시작');

  await addNumbers(1, 1);
  await addNumbers(2, 2);
}

Future<void> addNumbers(int number1, int number2) async {
  print('계산 시작 : $number1 + $number2');

  // 서버 시뮬레이션
  await Future.delayed(Duration(seconds: 2), () {
    print('계산 완료 : $number1 + $number2 = ${number1 + number2}');
  });

  print('함수 완료 : $number1 + $number2');
}

[Console]
함수 시작
계산 시작 : 1 + 1
계산 완료 : 1 + 1 = 2
함수 완료 : 1 + 1
계산 시작 : 2 + 2
계산 완료 : 2 + 2 = 4
함수 완료 : 2 + 2
Dart
복사

활용 사례 #3

void main() {
  print('함수 시작');

  final result1 = await addNumbers(1, 1);
  final result2 = await addNumbers(2, 2);

  print('result1 : $result1');
  print('result2 : $result2');
  print('number1 + number2 : ${result1 + result2}');
}

Future<int> addNumbers(int number1, int number2) async {
  print('계산 시작 : $number1 + $number2');

  // 서버 시뮬레이션
  await Future.delayed(Duration(seconds: 2), () {
    print('계산 완료 : $number1 + $number2 = ${number1 + number2}');
  });

  print('함수 완료 : $number1 + $number2');

  return number1 + number2;
}

[Console]
함수 시작
계산 시작 : 1 + 1
계산 완료 : 1 + 1 = 2
함수 완료 : 1 + 1
계산 시작 : 2 + 2
계산 완료 : 2 + 2 = 4
함수 완료 : 2 + 2
result1 : 2
result2 : 4
number1 + number2 : 6
Dart
복사

3. Stream

import 'dart:async';

void main() {
  final controller = StreamController();
  final stream = controller.stream;

  final streamListener1 = stream.listen((val) {
    print('Listener1 : $val');
  });

  controller.sink.add(1);
  controller.sink.add(2);
  controller.sink.add(3);
  controller.sink.add(4);
  controller.sink.add(5);
}

[Console]
Listener1 : 1
Listener1 : 2
Listener1 : 3
Listener1 : 4
Listener1 : 5
Dart
복사

활용 사례 #2

import 'dart:async';

void main() {
  final controller = StreamController();
  final stream = controller.stream.asBroadcastStream();

  final streamListener1 = stream.listen((val) {
    print('Listener1 : $val');
  });
  
  final streamListener2 = stream.listen((val) {
    print('Listener2 : $val');
  });

  controller.sink.add(1);
  controller.sink.add(2);
  controller.sink.add(3);
  controller.sink.add(4);
  controller.sink.add(5);
}

[Console]
Listener1 : 1
Listener2 : 1
Listener1 : 2
Listener2 : 2
Listener1 : 3
Listener2 : 3
Listener1 : 4
Listener2 : 4
Listener1 : 5
Listener2 : 5
Dart
복사

활용 사례 # 3

import 'dart:async';

void main() {
  final controller = StreamController();
  final stream = controller.stream.asBroadcastStream();

  final streamListener1 = stream.where((val) => val % 2 == 1).listen((val) {
    print('Listener1 : $val');
  });

  final streamListener2 = stream.where((val) => val % 2 == 0).listen((val) {
    print('Listener2 : $val');
  });

  controller.sink.add(1);
  controller.sink.add(2);
  controller.sink.add(3);
  controller.sink.add(4);
  controller.sink.add(5);
}

[Console]
Listener1 : 1
Listener2 : 2
Listener1 : 3
Listener2 : 4
Listener1 : 5
Dart
복사

활용 사례 # 4

import 'dart:async';

void main() {

  calculate(1).listen((val) {
    print('calculate(1) : $val');
  });
}

// int calculate(int number) {
//   for (int i =0; i < 5; i++) {
//     return i * number;
//   }
// }

Stream<int> calculate(int number) async* {
  for (int i =0; i < 5; i++) {
    yield i * number;
  }
}

[Console]
calculate(1) : 0
calculate(1) : 1
calculate(1) : 2
calculate(1) : 3
calculate(1) : 4
Dart
복사

활용 사례 # 5

import 'dart:async';

void main() {

  calculate(1).listen((val) {
    print('calculate(1) : $val');
  });
  
  calculate(2).listen((val) {
    print('calculate(2) : $val');
  });
}

Stream<int> calculate(int number) async* {
  for (int i =0; i < 5; i++) {
    yield i * number;
    
    await Future.delayed(Duration(seconds: 1));
  }
}

[Console]
calculate(1) : 0
calculate(2) : 0
calculate(1) : 1
calculate(2) : 2
calculate(1) : 2
calculate(2) : 4
calculate(1) : 3
calculate(2) : 6
calculate(1) : 4
calculate(2) : 8
Dart
복사

활용 사례 # 6

import 'dart:async';

void main() {
  playAllStream().listen((val) {
    print(val);
  });
}

Stream<int> playAllStream() async* {
  yield* calculate(1);
  yield* calculate(1000);
}

Stream<int> calculate(int number) async* {
  for (int i = 0; i < 5; i++) {
    yield i * number;

    await Future.delayed(Duration(seconds: 1));
  }
}

[Console]
0
1
2
3
4
0
1000
2000
3000
4000
Dart
복사

시간 제어 '시각'은 한 시점을 가리키는 말이고, '시간은' 시각과 시각 사이의 양을 나타내는 말

1. DateTime :: 일반적인 날짜 객체 (시각)

// 현재 시각 구하기
DateTime now = DateTime.now();

// DateTime 객체의 getter
print(now);
print(now.year);
print(now.month);
print(now.day);
print(now.hour);
print(now.minute);
print(now.second);
print(now.millisecond);
Dart
복사

•

DateTime 생성자의 named parameter를 주입하여 특정 시각 구하기

DateTime specificDay = DateTime(
    2017,
    01,
    02
  );
  
print(specificDay); // 출력 값 : 2017-01-02 00:00:00.000
Dart
복사

2. Duration :: 특정 시간

// 시간 자체를 의미 (1시간, 30분 등)
// 비동기 프로그램등에서 지연시간을 설정할 때 주로 사용
Duration duration = Duration(seconds: 60);
  
print(duration);
print(duration.inDays); // duration의 시간은 1분이므로, 0을 출력
print(duration.inHours);
print(duration.inMinutes); // duration의 시간은 1분이므로, 1을 출력
print(duration.inSeconds);
print(duration.inMilliseconds);
Dart
복사

3. 날짜 비교

// DateTime 클래스에서 제공하는 difference 함수를 활용
final difference = now.difference(specificDay);

print(difference);
print(difference.inDays);
print(difference.inHours);
print(difference.inMinutes);
Dart
복사

4. 날짜 더하기 및 빼기

// DateTime 클래스에서 제공하는 add, subtract 함수를 활용
print(now); // 2022-09-25 01:26:34.919
print(now.add(Duration(hours: 10))); // 2022-09-25 11:26:34.919
print(now.subtract(Duration(seconds: 20))); // 2022-09-25 01:26:14.919
Dart
복사