📌 Dart 문법 정복기 1장

11 minute read

내가 Dart를 배우는 목적은 Flutter를 이용해서 개발해보고 싶은 마음 때문임.

기본적으로 Dart는 vold main () { ... }로 작동하게됨. 그리고 카멜케이스를 따른다고 함. 그냥 기본 구조는 OOP를 따르고 문법도 어느 정도 비슷하다고 생각하고 넘어가는게 좋을 듯. 그리고 필자는 이미 여러 언어를 경험했기 때문에, Dart만의 새로운 문법이나 특징이 아닌 이상 컴퓨터 문법의 고유한 특성은 작성하지 않을 것임.

Dart의 변수 선언은 매우 다양한 방식이 존재함.

var, String, bool, int, dynamic등등 매우 많은 것이 있기 때문에, 실습을 위주로 연습을 하는게 빠르게 문법을 익힐 수 있음을 알게 됨.

빠르게 기본 문법을 익혀보자.

void main() {
  var integer = 1;
  var string = '1';
  var boolean = true;
  
  int number = 1;
  String str = '1';
  bool isTrue = true;
  
  print(string + ' ' + str);
  print($string + ' ' + $str);
  print(${string + ' ' + $str}); // string을 다루는 법
}

일단 var로 변수 할당이 가능함. 그리고 따로 int, String, bool 등으로 특정 타입의 변수로 할당이 가능함. 물론 int, String, bool은 한 번 타입이 정해지면 타입을 변경하면서 변수 할당이 불가능함. var로 할당 할 때에도 타입을 지정하고 변수를 선언하면(var integer = 1;) 타입 변경이 불가능함. 이를 가능하게 하는게 dynamic임. 따라서 dynamic은 다음과 같이 작성할 수 있음.

void main() {
  dynamic name = 'Code';
  print(name); // 'Code'
  
  name = 1;
  print(name); // 1
}

하지만 만약 var의 경우에도 변수만 선언하고 타입은 모르는 경우에는 변수 타입을 변경하여 재선언이 가능함.

void main() {
  var data;
  data = 1;
  print(1) // 1
  data = '1';
  print('1') // '1'
}

다음으로 List를 선언하고 할당하는 방법도 있음. 기본적으로 아래와 같음

void main() {
  List alphabetList = [ // 선언할 때 그냥 문자열로 할당 한 것임
    'a',
    'b',
    'c'
  ];
  // 같은 방식으로 선언하고 싶으면 다음과 같이 선언하면 됨.
  List<String> numList = [ // Java, C#과 비슷함. 이와 같은 코드는 아에 타입을 지정하고 들어간 것.
    '1',
    '2',
    '3'
  ];
	// 기본적으로 index의 경우 접근하는 것은 동일 해당 원소에 직접 slicing → [idx]
  print(numList[0]); // '1'
  // 길이 메소드 length
  print(numList.length) // 3
}

이제는 Map을 알아볼 것임.

void main() {
  // python의 dictionary를 선언하는 것과 동일
  Map numList = {
    'one': '1',
    'two': '2',
    'three': '3'
  };
  // 위와 같은 의미의 코드를 짜게되면
  Map<String, String> numList2 = {
    'one': '1',
    'two': '2',
    'three': '3'
  };
  // 이렇게 짜주면 됨
  
  // 만약에 여기서 원소를 하나 추가하고 싶으면 다음과 같이 짜면 됨
  numList.addAll({
    'four': '4'
  });
  
  // 또는 특정 key의 value를 변경하고 싶으면 다음과 같이 하면 됨
  numList['one'] = '하나';
  
  // 그리고 만약에 key와 value를 삭제하고 싶으면 다음과 같이 하면 됨
  numList.remove('one');
  
  // Key value를 따로 따로 받고 싶으면 다음과 같이 코딩
  print(numList.keys.toList());
  print(numList.values.toLsit());
  // 참고로 toList()는 데이터 타입을 List로 변환하는 것임
  // 이게 그냥 하나의 변수로 선언한 객체는 사용이 불가능함.
}

이제 final, const를 알아볼것임

void main() {
  final myName1 = 'junku';
  final String myName2 = 'Devjun';
  // final은 데이터를 바꿀 수 없음. 가변적이지 않음
  
  const myName3 = 'Dev';
  const myName4 = 'Dart';
  // const도 데이터를 바꿀 수 없음. 가변적이지 않음
}

그리고 또 하나의 특징은 final은 build time 값을 몰라도 선언 가능. 근데 const는 build time 값을 모르면 선언이 불가능함.

void main() {
  final now1 = new DateTime.now(); // 선언 가능
  
  const now2 = new DateTime.now(); // 선언 불가능
  
  // DateTime.now()는 현재 시간을 의미함.
}

이제는 enum 타입임

enum Status { // 앞은 항상 대문자
  A,
  B,
  C
}

void main() {
  Status status = Status.A;
  
  switch(status) {
    case Status.A:
      print('It is A');
      break;
      
    case Status.B:
      print('It is B');
      break;
      
    default:
      print('이건 뭡니까?');
      break;       
  }
}

이제 if문임

void main() {
  int num1 = 2;
  var num2 = 2;
  
	if (num1 % 2 == 0) {
    print('짝수임');
  } else {
    print('홀수임')
  }
  
  if (num2 % 2 == 0) {
    print('짝수임');
  }
  
  // switch
  switch(num1 % 2) {
    case 1:
      print('홀수임');
      break;
    case 0:
      print('짝수임');
      break;
    default:
      print('일단 자연수는 아님');
      break;   
  }
}

다음은 for문임

void main() {
  int total = 0;
  List naturalNumberList = [1, 2, 3, 4, 5];
  
  for(int i = 0; i < naturalNumberList.length; i++) {
    total += naturalNumberList[i];
  }
  print(total);
}

위의 코드는 index slicing으로 접근하는 것이고 아래와 같이 사용도 할 수 있음.

void main() {
  int total = 0;
  List numberList = [1, 2, 3, 4, 5];
  
  for(int number in numberList) {
    total += number;
  }
  print(total); // 15
}

다음은 while 문임

void main() {
  int total = 0;
  
  while(true) {
    if(total >= 10) {
      break;
    } else {
      total ++;
    }
  }
  print(total);
} // 이렇게 짤 수도 있고 아래와 같이 짤 수도 있음

void main() {
  int total = 0;
  
  while(total < 10) {
    total ++;
  }
  print(total);
}

어떻게 짜든 마음대로 짜는 것임. do 구문임

void main() {
  int total = 0;
  
  do {
    print(total); // 그냥 while의 body 부분이 이 부분임
    total ++;
  } while(total < 100);
}

아 그리고 continue도 사용할 수 있음 이건 딱히 말은 안하겠음. 그냥 써야지. 이제 함수로 ㄱㄱ

void main() {
  
  double res = linearExp(1, 2, 3);
  print(res); // 5
  
}

// 함수 선언 ex) y = ax + b 
double linearExp(double a, double b, double x) {
  return a*x + b;
} // 옵션식으로 넣어줄수도 있음

double linearExp(double a, double x, [double b = 0]) {
  return a*x + b; // default b값이 0임.
}

위 함수 코드는 위치 파라미터라 함. 그냥 위치로 결정나는 것임. 근데 이제 name parameter가 따로 있으니까. 이것도 아래에서 확인 ㄱ

void main() {
  double res = linearExp(1, 2, b:3);
  print(res);
}

double linearExp(double a, double x, { // 중괄호로 사용하면 name parameter임.
  dynamic b
}) {
  return a * x + b;
}

근데 여기서 systax 문제는 아니지만 문제가 발생한게 있음. 지금 내가 사용하는 dartpad.dartlang.org에서 dart 문법을 연습하는 중인데, 아래와 같이 코드를 작성하면 다음과 같은 오류가 발생함.

void main() {
  double res = linearExp(1, 2, b:3);
  print(res);
}

double linearExp(double a, double x, {
  double b
}) {
  return a * x + b;
}

Error: The parameter 'b' can't have
a value of 'null' because of its type 'double',
but the implicit default value is 'null'.
  double b
         ^
Error: Compilation failed.

이런 오류가 나올 때 해결하는 방법은 클라우드 환경 내에서 null 값을 해결하는 오류를 지정하면 해결할 수 있음. 사이트 footer에 이러한 옵션을 클릭해서 헤제할 수 있으니, 해당 부분을 클릭하고 코드를 다시 시작하면 제대로 다시 작동하는 것을 확인할 수 있음. 참고 ㄱ

근데 왜 dynamic은 오류가 안났는가? 생각하면 dynamic과 double의 값을 다룰 수 있는 범위가 다르기 때문임. dart에서는 모든게 객체임. double은 실수형으로 그 객체를 한정시킴. 하지만 dynamic은 그렇지 않고 다룰 수 있는 범위가 매우 범용적이기 때문에, null값에 대한 safety가 작용하지 않는 것임. 그렇다고 모든 걸 dynamic으로 할당하진 않는 걸 추천. 왜냐하면 내 생각이진 하지만, dynamic이 타입을 지정해서 값을 할당하는 다른 무엇보다 메모리를 아마 더 많이 먹을 것임. 그러니까 어쩔 수 없는 상황에서는 쓰되 그런 상황이 아니면 최대한 안쓰는 것을 지향하는게 맞는듯.

이제 typedef임.

void main() {
  calculate(1, 2, add);
  calculate(1, 2, subtract);
}

typedef Operation(int x, int y); // Operation 정하기

void add(int x, int y) { // 각각의 연산을 정하기
  print('${x + y}');
}

void subtract(int x, int y) {
  print('${x - y}');
}

void calculate(int x, int y,  Operation oper) { // 이게 작동함수임 Operation은 oper로 작동시키겠다? 이런 의미임
  oper(x, y);
}

이거 약간 코드가 cpp같은 느낌을 갖고 있음. cpp은 아직 잘 모르는 언어라서 깊게 알지는 못하지만, 해당 연산을 정하고 이를 함수로 실행하는 느낌임.

이제 class임. python의 class 문법 보다는 java의 class 느낌이 강함.

void main() {
  Name name = new Name();
  name.sayName();
}

class Name {
  String name ='SSAFY';
  
  void sayName() {
    print('저는 ${this.name}입니다.');
  }
}

그러면 이름을 넣어주는대로 할 수는 있는가? 다음과 같이 하면 됌.

void main() {
  Name name = new Name('SSAFY');
  name.sayName();
}

class Name {
  final name;
  
  
  Name( // 이 부분은 다시보면서 익혀야 할듯
    String name, // String이라는 name인데
  ) : this.name = name; // 이걸 위의 name에다가 할당해줘. 즉 이 부분은 해당 클래스를 실행하면 무조건 실행되는 부분임.
  
  void sayName() {
    print('저는 ${this.name}입니다.'); // 출력
  }
}

조금 더 활용해보면 다음과 같음

void main() {
  Name name = new Name('SSAFY', 4);
  name.sayName();
  name.sayNum();
}

class Name {
  // 클래스에서 활용할 데이터를 final로 선언. 데이터가 바뀌면 안된다?
  // 그런 이야기는 못들음
  // 가장 먼저 실행되어 사용되는 변수 이지만,
  // 다트 내에서 우선순위가 높지 않으므로 this를 사용해서 접근함.
  final name; 
  final classNum;

  // class에서 받은 애들이 어떻게 데이터화 되는지 알 수 있음.
  Name(
    String name, 
    int classNum,
  )   : this.name = name,
        this.classNum = classNum;

  // 해당 데이터를 이용한 함수 부분
  void sayName() {
    print('저는 ${this.name}입니다.');
  }
  
  void sayNum() {
    print('저는 ${this.classNum}입니다.');
  }
}

좀 더 복잡하게 설정하는 법. 약간 이때부터 문법이 꼬이기 시작함. (아나..)

void main() {
  Name name = new Name('SSAFY', 4);
  name.sayName();
  name.sayNum();
  
  Name kimssafy = new Name.fromMap({
    'name': '김싸피',
    'classNum': 4
  });
  
  kimssafy.sayName();
}

class Name {
  final name;
  final classNum;

  Name(
    String name,
    int classNum,
  )   : this.name = name,
        this.classNum = classNum;

  Name.fromMap( //  Map을 활용한 방법임.
    Map values,
  ) : this.name = values['name'],
      this.classNum = values['classNum'];
  
  void sayName() {
    print('저는 ${this.name}입니다.');
  }
  
  void sayNum() {
    print('저는 ${this.classNum}반 입니다.');
  }
}

private 변수를 사용하는법

void main() {
  Name name = new Name('SSAFY', 4, 1000);
  name.sayName();
  name.sayNum();
  name.sayId();
  
  Name kimssafy = new Name.fromMap({
    'name': '김싸피',
    'classNum': 4,
    'id': 1000,
  });
  
  kimssafy.sayName();
  kimssafy.sayNum();
  kimssafy.sayId();
}

class Name {
  final name;
  final classNum;
  final _id;
  // 언더 바를 쓰면 _id는 private variable임

  Name(
    String name,
    int classNum,
    int id,
  )   : this.name = name,
        this.classNum = classNum,
        this._id = id;

  Name.fromMap(
    Map values,
  ) : this.name = values['name'],
      this.classNum = values['classNum'],
      this._id = values['id'];
  
  void sayName() {
    print('저는 ${this.name}입니다.');
  }
  
  void sayNum() {
    print('저는 ${this.classNum}반 입니다.');
  }
  
  void sayId() {
    print('저의 번호는 ${this._id}번 입니다.');
  }
}

위의 코드를 실행하면 실행됨.. 🤭🤭🤭🤭🤭🤭🤭🤭

원래 되면 안됨. private 변수는 스코프가 있어서 가져올 수 없음. 근데 가져옴…. 왜??

dart에서는 한 파일 내에서 작동하는 class를 한정으로 private 변수를 가져옴. 엄청난 특징임. 이건 기억해야함.

그니까 다른 dart 파일 내에서 이를 작동시키면 _id를 가져오지 못함. 기억하셈. 즉 파일 단위로 private 변수가 다뤄짐.

이제 getter와 setter임. 위의 코드의 class에서 아래 코드만 추가시키면 됨. 근데 final _id를 int _id로 바꾸는건 센스임 final은 변수 못바꿈.

void main() {
 
  Name kimssafy = new Name('kimssafy', 1, 20);
  
  print(kimssafy.id);
  kimssafy.id = 100000;
  print(kimssafy.id);
  
}

class Name {
  //...
  get id {
    return this._id;
  }
  
  set id(int id) {
    this._id = id;
  }
}

extends는 다음과 같음

void main() {
  ClassNum kimssafy = new ClassNum('kimssafy', 1, 20);
  kimssafy.sayClassNum();
}

class Name {
  // ...
}

class ClassNum extends Name {
  ClassNum(
    String name,
    int classNum,
    int _id,
  ) : super(
          name,
          classNum,
          _id,
        );
  
  void sayClassNum() {
    print("저는 ${this.classNum}반 입니다.");
  }
}

그 다음은 method overriding임

void main() {
  Parent parent = new Parent(3);
  
  int result = parent.square();
  
  print(result);
  
  Child child = new Child(3);
  
  int result2 = child.square();
  
  print(result2);
  
}

class Parent {
  final int number;

  Parent(
    int number,
  ) : this.number = number;
  
  int square() {
    return this.number * this.number;
  }
}

class Child extends Parent {
  Child(
    int number,
  ) : super(number);
  
  @override
  int square() {
    return this.number + this.number;
  }
}

// 아래와 같이 짤수도 있음.
class Parent {
  final int number;

  Parent(
    int number,
  ) : this.number = number;
  
  int square() {
    return this.number * this.number;
  }
}

class Child extends Parent {
  Child(
    int number,
  ) : super(number);
  
  @override
  int square() {
    int result = super.square();
    
    return result + result 
  }
}
// Child child = new Child(3)을 넣고
// int result2 = child.square();
// print(result2) // 18임

다음으로 스태틱임

void main() {
  Employee kimssafy = new Employee('김싸피');
  Employee parkssafy = new Employee('박싸피');
  
  Employee.community = 'SSAFY';
  
  print('--김싸피--');
  kimssafy.printNmaeAndBuilding();
  
  print('--박싸피--');
  parkssafy.printNmaeAndBuilding();
  
  Employee.community = '멀티캠퍼스';
  
  print('--김싸피--');
  kimssafy.printNmaeAndBuilding();
  
  print('--박싸피--');
  parkssafy.printNmaeAndBuilding();
  
  Employee.printBuilding();
}

class Employee {
  static String community;
  String name;

  Employee(
    String name,
  ) : this.name = name;
  
  void printNmaeAndBuilding() {
    print('제 이름은 $name입니다. $community 에서 공부하고 있습니다.');
  }
  
  static void printBuilding() {
    print('저희는 $community 에서 공부하고 있습니다.');
  }
}

다음은 다트의 인터페이스임. 조금 특이함. 왜냐면 class를 인터페이스로 활용할 수 있음.

void main() {
  ClassNum kimssafy = new ClassNum(4);
  kimssafy.sayClassNum();
  
  new ClassNum(4)
  	..sayClassNum()
  	..sayGroup();
}

class ClassNumInterface {
  void sayClassNum() {}
}

class ClassNum implements ClassNumInterface {
  int classNum;
  String group = '알고리즘 스터디';

  ClassNum(
    int classNum,
  ) : this.classNum = classNum;

  void sayClassNum() {
    print('저는 ${this.classNum}반 입니다.');
  }
  
  void sayGroup() {
    print('저는 ${this.group}을 하고 있습니다.');
    
  }
}

클래스를 곧바로 인터페이스로 활용함. 와우,,,,

그 다음은 getters임.

void main() {
  List ssafy = [
    1,
    2,
    3,
    4,
    5,
  ];
  
  // getters
  print(ssafy.first); // 첫원소
  print(ssafy.isEmpty); // 비었는가?
  print(ssafy.isNotEmpty); // 안 비었는가?
  print(ssafy.length); // 길이
  print(ssafy.last); // 마지막 원소
  print(ssafy.reversed); // 리버스
}

void main() {
  List ssafy = [
    1,
    2,
    3,
    4,
    5,
  ];
  
  // 추가
  ssafy.add(6);
  print(ssafy); // [1, 2, 3, 4 ,5 ,6]
  
  // 한 번에 추가
  ssafy.addAll([7, 8, 9]);
  print(ssafy); // [1, 2, 3, 4 ,5 ,6, 7, 8]
}

void main() {
  List memberList = [
    {
      'id':1,
      'name': 'kimssafy'
    },
    {
      'id':2,
      'name': 'parkssafy'
    },
    {
      'id':3,
      'name': 'leessafy'
    }
  ];
  
  var item = memberList.firstWhere((item) => item['id'] == 1);
  print(item);
  
  var index1 = memberList.indexWhere((item) => item['id'] == 1);
  print(index1);
  
  var index2 = [10, 20, 30].indexOf(20);
  print(index2);
  
  var contains = [10, 20, 30].contains(30);
  print(contains);
}

리스트에 관한 여러가지 루핑 법

void main() {
  List memberList = [
    {
      'id':1,
      'name': 'kimssafy',
      'group': 1
    },
    {
      'id':2,
      'name': 'parkssafy',
      'group': 4
    },
    {
      'id':3,
      'name': 'leessafy',
      'group': 2
    }
  ];
  
  memberList.forEach((item) { // js랑 같음
    print(item);
  });
  
  var newList = memberList.map((item) {
    return item['name']; // name만 다 뽑기
  });
  
  print(newList);
  
  var fold = memberList.fold(0, (t, e) {// t와 e의 변수 타입이 똑같지 않아도 괜찮음
    return t + e['id']; // t는 0부터 시작 e의 id값을 다 더하기
  });
  
  print(fold); 
  
  var reduce = [1, 2, 3, 4, 5].reduce((t, i) => t + i); // lambda 함수와 비슷
  // t와 i의 변수 타입이 똑같아야함, t에 1, 2, 3, 4, 5 다 더하기
  print(reduce); 
}

리스트를 다루는 다양한 방법들

void main() {
  List numberList = [10, 20, 30, 40, 50];
  
  numberList.remove(10); // 10을 지움
  print(numberList);
  
  numberList.removeAt(1); // 인데스가 1인걸 지움
  print(numberList);
  
  numberList.removeWhere((e) => e == 50); // 값이 50이면 삭제
  print(numberList);
  
  List numberList2 = [10, 20, 30, 40, 50];
  
  numberList2.shuffle(); // 섞임
  print(numberList2);
}

Share on

Twitter Facebook LinkedIn

Park Jun Kyu

📌 Dart 문법 정복기 1장

Share on

You may also enjoy

📌 파일시스템

📌 가상메모리

Viewbinding

📌 CPU 스케줄러(Scheduler)3 & 병행제어1