[flutter & Dart] Dart 문법

해당 문법의 경우, 다른 언어를 통해 이미 알고 있거나 적지 않아도 될 부분은 넘어가도록 하겠다.

데이터 타입

• int, double은 num을 상속받는다.
• var vs dynamic
  • var의 경우 compile시 타입이 결정된다.
  • dynamic의 경우 runtime시 타입이 결정된다.(특별한 경우가 아니면 사용하지 않는다.)
• const : 상수인데, compile에 결정된다. (final보다는 성능상의 이점을 가져갈 수 있다.)

Null Safety

int age = null; //X
int? age; //O

• null이 들어갈 수 있는 부분은 ?와 같이 nullable 변수를 만들어줘야 null을 대입할 수 있다.
• 또한, ?이 들어간 변수와 아닌 변수는 equal하지 않다.
• nullable이 아니도록 만들기 위해서는 다음과 같은 로직을 사용한다.

String? name;

if(name != null){
  String result = name;
}

Null 연산자 관련

String? str;
str ??= 'Hello';

//이것은 다음 코드와 같은 의미이다.

if(str == null){
  str = 'Hello';
}

• 이는 str = null이면 'Hello'를 대입하라는 의미이다.

삼항 연산자

bool isClear = true;
var weather = isClear == true ? '맑음' : '흐림';

• 이는 isClear == true이면 '맑음', false이면 '흐림'을 넣고, 그 값을 weather에 대입하라는 의미이다.

Cascade

var paint = Paint();
paint.color = 'black';
paint.strokeCap = ;

//이 코드를 다음과 같이 사용할 수 있다.

var paint = Paint()
..color = 'black'
..strokeCap = ;

• ..을 통해서 객체를 계속 받아와서 사용할 수 있다.

Type Casting

void main(){
num i = 10;
int ii = i as int;
}

• Type Casting은 as 키워드를 이용한다.

void main(){
	print(sum()); //0
}

int sum({int a = 0, int b = 0}){
	return a+b;
}

• 이런식으로 {}라고 named_parameter를 사용하면 명시를 한채로 사용이 가능하다.

Lamdba & Fuction

int sum(int a, int b) => a+b;

void main(){
	print(calc(10, 5, (a,b) => a+b));
}

int calc(int a, int b, {required Fuctional(int, int) callback}){
	return callback(a,b);
}

//main 내부에서 내용이 길어진다면
void main(){
	print(calc(10, 5, callback : (a,b){
    return a+b;
    });
}

• required를 사용하면 디폴트 값이 존재하지 않아도 된다.

List, for

void main(){
  List<int> items = [1,2,3];

  for(int item in items){ //in을 사용해서 표현이 가능하다.
  	print(item);
  }
}

//forEach
items.forEach((e) {
	print(e);
})
//이런식으로 알맹이 하나하나를 print를 하겠다는 의미이다.

//lamdba식
item.forEach((e) => print(e));

item.forEach(print);

//요소로 집어넣기
void main(){
  List<int> items = [1,2,3];
  List<int> addItems = [..items, 5, ...items, 6];
  //리스트간의 결합을 할때, 스프레드 연산자를 이용해서 추가가 가능하다.
  
  //bool과의 결합, 한 줄로 되어 있는 if문만 허용한다.
  Boolean isRainy = false;
  List<int> items = [1,2,3, if(isRainy) 4];
}

Map

//value의 경우, 어떤 값이 올지 모르기 때문에 dynamic을 써준다.
void map(){
Map<String, dynamic> john = {
	'name' : 'john',
    'age' : 40,
};

Class

String globalVar = 'global';

void main(){
	print(globalVar);
}

• 이런식으로 밖에 선언하면 어디에서나 사용이 가능하다.

늦은 초기화

class Point{
	int _x;
    int _y;
    int? z;
    late final int a; //final 사용 가능
    
    Point(this._x, this._y, [this.z]){
    	a = _x = _y;
    }
}

• 이런식으로 late 키워드를 달아주면 늦은 초기화가 가능하다.
  • a = _x = _y;여서 a 같은 경우는 일단 생성자가 실행이 되어야만 값이 정해지기 때문이다.

상속

void main(){
	Dog dog = Dog();
    Cat cat = Cat();
    
    Animal dog1 = Dog();
    Animal cat1 = Cat();
    
    dog.walk();
    cat.walk();
    dog1.walk();
    cat1.walk();
}

abstract class Animal{
	void walk(){
    	print('walk');
    }
}

class Dog extends Animal{
}

class Cat extends Animal{
	@override
    void walk(){
    	print('살금 살금');
    }
}

• 기능이 확장되도록 상속 클래스를 abstract로 정의가 가능하다.(interface랑 같은듯)

void main(){
	SuperHero superHero = SuperHero();
    Hero hero = SuperHero();
    Moveable moveable = SuperHero();
    Drawable drawable= SuperHero();
}

mixin Moveable(){
	int i = 0;
	void move(){
    }
}

mixin Drawable(){
	void draw(){
	}
}

class Hero{}
class SuperHero extends Hero with Moveable, Drawable{}

• mixin은 다중상속의 기능을 한다.
  - 기능정리를 해 두는 것이 보통이다.
• 상속은 하나만 받을 수 있기 때문에, with을 이용해서 여러개를 받을 수 있도록 한다.

Generic

void main(){
	var box = Box<int>(10);
    var box2 = Box<String>('ddd');
}

class Box<T>{
	T value;
    
    Box(this.value);
}

Future

void main(){
	var delay = Future.delayed(Duration(seconds:3));
    
    delay.then((value) => print('3초 지남'))
    	.catchError((e) => print(e));
    hello().then((value) => print(value));
}
Future<Stirng> hello() async{
	await Future.delayed(Duration(second:3));
	return 'Hello';
}

• Dart 에서 비동기 처리를 하는 방법은, Future를 사용해서 딜레이를 걸 수 있다.
• await는 반드시 future안에 또 다른 future가 있을 경우에만 사용이 가능하다.

Stream

void main(){
	var stream = Stream.fromIterable([1,2,3]);
    
    stream.listen((event){
    	print(event);
    });
}

• 데이터의 흐름을 표현한다.