<div id="readability-page-1" class="page"><cite>DarrenKwonDev</cite>
 2021. 12. 20. 00:02
 <div>
 <div>
Dart SDK version: 2.15.1 (stable) (Tue Dec 14 13:32:21 2021 +0100) on "macos_x64" 기준으로 작성되었습니다.
</div>

변수 초기화
<pre id="code_1639918857167" data-ke-language="javascript" data-ke-type="codeblock"><code>var firstName = "Darren"; // var로 선언시 type infer됨
String lastName = "Kwon"; // 직접 타이핑 가능</code></pre>

미할당시
<pre id="code_1639921897271" data-ke-language="javascript" data-ke-type="codeblock"><code>main() {
 int? num;
 print(num); // null
}</code></pre>

plugin 사용
<pre id="code_1639918993931" data-ke-language="javascript" data-ke-type="codeblock"><code>import "dart:io";

main() {
 stdout.write("Enter your name: ");
 String? name = stdin.readLineSync();
 print("Hello, $name!");
}</code></pre>

dart의 Primitive type들 (int, double, String, bool, dynamic)
<pre id="code_1639919632210" data-ke-language="javascript" data-ke-type="codeblock"><code>main() {
 // dart의 기본 타입 : int, double, String, bool, dynamic
 int a = 100;
 var b = 200; // type infer
 print("$a, $b");

 double c = 3.14;
 var d = 1.14; // type infer

 String e = 'Hello';
 var f = 'World'; // type infer

 bool g = true;
 var h = false; // type infer

 dynamic i = 100; // runtime에 타입이 정의됨.
 i = "Hello"; // dynamic은 형이 다르게 할당할 수 있음
}</code></pre>

dynamic 타입의 런타임 타입 출력
<pre id="code_1639921771696" data-ke-language="javascript" data-ke-type="codeblock"><code>main() {
 dynamic a = 5;
 print(a.runtimeType); // int

 a = "string";
 print(a.runtimeType); // String
}</code></pre>

raw string
<pre id="code_1639920390531" data-ke-language="javascript" data-ke-type="codeblock"><code>main() {
 String s = r'hello \n wow .... \t hehkekekke'; // raw string은 \n과 같은 이스케이프도 문자 처리함
 print(s);
}</code></pre>

type conversion
<pre id="code_1639921079551" data-ke-language="javascript" data-ke-type="codeblock"><code>// assert : https://dart.dev/guides/language/language-tour#assert
// assert는 디버깅 함수이다. 조건식이 거짓인 경우 오류 메시지를 출력한다.
// flutter 에선 개발 모드일 때, 일반 dart일 땐 dart --enable-asserts [path] 꼴로 실행해야 함
main() {
 // String -&gt; int
 var one = int.parse('1');
 assert(one == 1, 'one is not int type');

 // String -&gt; double
 var float = double.parse('1.1');
 assert(float == 1.1, 'float is not double type');

 // int -&gt; String
 String str = 123.toString();
 assert(str == '123', 'str is not string type');

 // double -&gt; String
 String str2 = 1.141592.toStringAsFixed(2); // 소수점 2자리 절삭
 assert(str2 == '1.14', 'str2 is not string type');
}</code></pre>

constant
<pre id="code_1639921706672" data-ke-language="javascript" data-ke-type="codeblock"><code>main() {
 const num = 0;
 const a = true;
 const b = 'string';

 num = 5; // Constant variables can't be assigned a value.

 print(num.runtimeType); // int
 print(a.runtimeType); // bool
 print(b.runtimeType); // String
}</code></pre>

operator : 우리가 관습적으로 사용하는게 다 된다.
<pre id="code_1639922232398" data-ke-language="javascript" data-ke-type="codeblock"><code>main() {
 int a = 1 + 2; // 3
 a = a - 2; // 1
 a++; // 2
 ++a; // 3
 
 print(a == 3);
 print(a != 3);
 print(a &gt; 3);
 print(a &lt; 3);
 print(a &gt;= 3);
}</code></pre>

null aware operator (?. ?? ??=)
<pre id="code_1639922872406" data-ke-language="javascript" data-ke-type="codeblock"><code>// javascript
const a = {name: "darren"}
const b = a?.age ?? null // b는 null이 된다.

// dart에서도 같은 문법이 가능
int number = n?.num ?? 0;</code></pre>
<pre id="code_1639923000268" data-ke-language="javascript" data-ke-type="codeblock"><code>var number = null;
print(number ??= 100); // number가 null이므로 100할당
print(number);</code></pre>

ternary operator
<pre id="code_1639923205540" data-ke-language="javascript" data-ke-type="codeblock"><code>main() {
 int n = 100;
 n &gt; 100 ? print('n is greater than 100') : print('n is less than or equal to 100');
}</code></pre>

type checking
<pre id="code_1639923384003" data-ke-language="javascript" data-ke-type="codeblock"><code>main() {
 var x = 100;

 print(x is int); // true
 print(x is String); // false
}</code></pre>

conditional statement : 너무 직관적이고 우리가 사용하는 그대로이다.
<pre id="code_1639923502291" data-ke-language="javascript" data-ke-type="codeblock"><code>main() {
 var a = 100;

 if (a &gt; 1000) {
 print("wow");
 } else if (a &gt; 100) {
 print("amazing");
 } else {
 print("should prin there");
 }
}</code></pre>

switch statement
<pre id="code_1639923640707" data-ke-language="javascript" data-ke-type="codeblock"><code>main() {
 var a = 100;

 switch (a) {
 case 101:
 print("impossible");
 break;
 case 100:
 print("should print here");
 break;
 default:
 print("impossible");
 }
}</code></pre>

for loop
<pre id="code_1639923798665" data-ke-language="javascript" data-ke-type="codeblock"><code>main() {
 for (var i = 0; i &lt; 3; i++) {
 print(i);
 }

 for (var j in [10, 11, 12]) {
 print(j); 
 }
 
 for (var i = 0; i &lt; 10; i++) {
 if (i % 2 == 0) continue;
 print(i);
 }

 [100, 101, 102].forEach((element) { 
 print(element); 
 });
}</code></pre>

while
<pre id="code_1639924013640" data-ke-language="javascript" data-ke-type="codeblock"><code>main() {
 int num = 0;

 while (num &lt; 3) {
 print(num);
 num++;
 }
}</code></pre>

collections: list,&nbsp;set,&nbsp;map
<pre id="code_1639927058674" data-ke-language="javascript" data-ke-type="codeblock"><code>main() {
 List&lt;int&gt; list = [1, 2, 3];
 List&lt;dynamic&gt; dynamicList = [1, 2, "he"];
 List&lt;int&gt; constantList = const [1, 2]; // unmodifiable list. 즉, 변경 불가능한 list

 var list2 = list; // reference 참조 
 var deppcopiedList = [...list]; // shallow copy

 list2.add(4);
 print(list); // list2에 추가했음에도 원본 변형. [1, 2, 3, 4]
 print(deppcopiedList); // 다른 참조값이므로 원본 유지 [1, 2, 3]
}</code></pre>
<pre id="code_1639927398994" data-ke-language="javascript" data-ke-type="codeblock"><code>main() {
 Set&lt;int&gt; a = {1, 2, 3, 4, 3, 2, 1};
 print(a); // 중복이 제거된 {1, 2, 3, 4}

 var b = a; // reference 참조
 var c = {...a}; // shallow copy
 b.add(5);

 print(a); // 원본도 변경됨 {1, 2, 3, 4, 5}
 print(c); // 다른 reference 참조이므로 그대로 {1, 2, 3, 4}
}</code></pre>
<pre id="code_1639927575473" data-ke-language="javascript" data-ke-type="codeblock"><code>main() {
 Map&lt;String, int&gt; map = {"one": 1, "two": 2};
 print(map['one']);

 var copiedMap = map; // reference 참조
 var newMap = {...map}; // shallow copy

 copiedMap.clear(); // 싹 다 지우기
 print(map); // 원본에도 영향
 print(newMap); // 다른 reference 참조로 변화 없음 {one: 1, two: 2}
}</code></pre>

function
<pre id="code_1639927913585" data-ke-language="javascript" data-ke-type="codeblock"><code>main() {
 print(square.runtimeType); // (dynamic) =&gt; int. 함수의 타입도 찍어볼 수 있다.
 print(printSomething.runtimeType); // (dynamic) =&gt; void

 int result = addTwo(square(2));
 printSomething(result);
}

int square(var num) {
 return num * num;
}

int addTwo(int a) =&gt; a + 2; // arrow function이 가능하다.

void printSomething(var msg) =&gt; print(msg);</code></pre>

named parameters ({})와 optional parameters ([])&nbsp;
1. 일반적으로 우리가 쓰는 건 positional parameters다. 위치에 기반하기 때문이다.
2. 위치가 아닌 이름으로 구별하고 싶다면 named parameters를 사용하면 된다.
3. optional parameters는 positional parameters이면서도 단순히 옵셔널하게끔 만들 수 있다.
4. named parameters와 positional optional parameters 둘 다 사용하면 optional이라 기본값 지정 혹은 null handling이 필요.
<pre id="code_1639928544984" data-ke-language="javascript" data-ke-type="codeblock"><code>main() {
 sum(1, 2);
 sum2(a: 1, b: 2); // named parameters
 sum3(1, b: 2);
 sum4(1); // positional optional parameters
}

int sum(int a, int b) =&gt; a + b;
int sum2({int a = 0, int b = 0}) =&gt;
 a + b; // named parameters는 optional이다. 따라서 기본값을 지정하거니 null handling이 필요.
int sum3(int a, {int b = 0}) =&gt; a + b; // 부분적으로 named parameters를 사용할 수 있다.
int sum4(int a, [int b = 0]) =&gt; a + b; // positional optional parameters</code></pre>

exception과 try/catch/finally
<pre id="code_1639932418680" data-ke-language="javascript" data-ke-type="codeblock"><code>// Exception 던지기
int shouldGreaterThanZero(int val) {
 if (val &gt; 0) {
 return val;
 } else {
 throw Exception('value should greater than zero');
 }
}

// try/catch/finally
void verifyValue(var val) {
 var verifiedValue;

 try {
 verifiedValue = shouldGreaterThanZero(val);
 } catch (e) {
 print("error occured: $e");
 } finally {
 print(verifiedValue);
 }
}</code></pre>

final와 const
final&nbsp;: 런타임에 값이 지정이 되어도 상관 없음. const&nbsp;: 컴파일타임에 값이 꼭 지정되어야 한다. -&gt; 빌드 타임에 값이 정해져 있어야지, 런타임 돈 이후에 알게 되는 값은 안된다. 공통점&nbsp;: 둘 다 상수라서 초기화 이후 변경이 불가능함.
<pre id="code_1639933102190" data-ke-language="javascript" data-ke-type="codeblock"><code>main() {
 final name = 'test';
 final String name2 = "wow";
 const name3 = "ama";
 const String name4 = "ddd";
 
 final now = new DateTime.now(); // 런타임에 할당되어 괜찮으니 에러가 아님
 const now2 = new DateTime.now(); // 컴파일 시점에 알수가 없음. DateTime이 돌아야 알 것 아니냐. 그래서 에러임
}</code></pre>

enum
<pre id="code_1639933110830" data-ke-language="javascript" data-ke-type="codeblock"><code>enum Status {
 loading,
 fetched,
 done,
 error,
}

main() {
 Status status = Status.loading;

 switch (status) {
 case Status.loading:
 print('로딩중');
 break;
 case Status.fetched:
 print('페칭중');
 break;
 default:
 print('불가능');
 }
}</code></pre>

 
 
 </div></div>

HotHandCoding

DarrenKwon

Dart SDK version: 2.15.1 (stable) (Tue Dec 14 13:32:21 2021 +0100) on "macos_x64" 기준으로 작성되었습니다.
 
변수 초기화
var firstName = "Darren"; // var로 선언시 type infer됨
String lastName = "Kwon"; // 직접 타이핑 가능
 
미할당시
main() {
 int? num;
 print(num); // null
}
 
plugin 사용
import "dart:io";
main() {
 stdout.write("Enter your name: ");
 String? name = stdin.readLineSync();
 print("Hello, $name!");
}
 
dart의 Primitive type들 (int, double, String, bool, dynamic)
main() {
 // dart의 기본 타입 : int, double, String, bool, dynamic
 int a = 100;
 var b = 200; // type infer
 print("$a, $b");
 double c = 3.14;
 var d = 1.14; // type infer
 String e = 'Hello';
 var f = 'World'; // type infer
 bool g = true;
 var h = false; // type infer
 dynamic i = 100; // runtime에 타입이 정의됨.
 i = "Hello"; // dynamic은 형이 다르게 할당할 수 있음
}
 
dynamic 타입의 런타임 타입 출력
main() {
 dynamic a = 5;
 print(a.runtimeType); // int
 a = "string";
 print(a.runtimeType); // String
}
 
raw string
main() {
 String s = r'hello \n wow .... \t hehkekekke'; // raw string은 \n과 같은 이스케이프도 문자 처리함
 print(s);
}
 
type conversion
// assert : https://dart.dev/guides/language/language-tour#assert
// assert는 디버깅 함수이다. 조건식이 거짓인 경우 오류 메시지를 출력한다.
// flutter 에선 개발 모드일 때, 일반 dart일 땐 dart --enable-asserts [path] 꼴로 실행해야 함
main() {
 // String -> int
 var one = int.parse('1');
 assert(one == 1, 'one is not int type');
 // String -> double
 var float = double.parse('1.1');
 assert(float == 1.1, 'float is not double type');
 // int -> String
 String str = 123.toString();
 assert(str == '123', 'str is not string type');
 // double -> String
 String str2 = 1.141592.toStringAsFixed(2); // 소수점 2자리 절삭
 assert(str2 == '1.14', 'str2 is not string type');
}
 
constant
main() {
 const num = 0;
 const a = true;
 const b = 'string';
 num = 5; // Constant variables can't be assigned a value.
 print(num.runtimeType); // int
 print(a.runtimeType); // bool
 print(b.runtimeType); // String
}
 
operator : 우리가 관습적으로 사용하는게 다 된다.
main() {
 int a = 1 + 2; // 3
 a = a - 2; // 1
 a++; // 2
 ++a; // 3
 
 print(a == 3);
 print(a != 3);
 print(a > 3);
 print(a < 3);
 print(a >= 3);
}
 
null aware operator (?. ?? ??=)
// javascript
const a = {name: "darren"}
const b = a?.age ?? null // b는 null이 된다.
// dart에서도 같은 문법이 가능
int number = n?.num ?? 0;
var number = null;
print(number ??= 100); // number가 null이므로 100할당
print(number);
 
ternary operator
main() {
 int n = 100;
 n > 100 ? print('n is greater than 100') : print('n is less than or equal to 100');
}
 
type checking
main() {
 var x = 100;
 print(x is int); // true
 print(x is String); // false
}
 
conditional statement : 너무 직관적이고 우리가 사용하는 그대로이다.
main() {
 var a = 100;
 if (a > 1000) {
 print("wow");
 } else if (a > 100) {
 print("amazing");
 } else {
 print("should prin there");
 }
}
 
switch statement
main() {
 var a = 100;
 switch (a) {
 case 101:
 print("impossible");
 break;
 case 100:
 print("should print here");
 break;
 default:
 print("impossible");
 }
}
 
for loop
main() {
 for (var i = 0; i < 3; i++) {
 print(i);
 }
 for (var j in [10, 11, 12]) {
 print(j); 
 }
 
 for (var i = 0; i < 10; i++) {
 if (i % 2 == 0) continue;
 print(i);
 }
 [100, 101, 102].forEach((element) { 
 print(element); 
 });
}
 
while
main() {
 int num = 0;
 while (num < 3) {
 print(num);
 num++;
 }
}
 
collections: list, set, map
main() {
 List<int> list = [1, 2, 3];
 List<dynamic> dynamicList = [1, 2, "he"];
 List<int> constantList = const [1, 2]; // unmodifiable list. 즉, 변경 불가능한 list
 var list2 = list; // reference 참조 
 var deppcopiedList = [...list]; // shallow copy
 list2.add(4);
 print(list); // list2에 추가했음에도 원본 변형. [1, 2, 3, 4]
 print(deppcopiedList); // 다른 참조값이므로 원본 유지 [1, 2, 3]
}
main() {
 Set<int> a = {1, 2, 3, 4, 3, 2, 1};
 print(a); // 중복이 제거된 {1, 2, 3, 4}
 var b = a; // reference 참조
 var c = {...a}; // shallow copy
 b.add(5);
 print(a); // 원본도 변경됨 {1, 2, 3, 4, 5}
 print(c); // 다른 reference 참조이므로 그대로 {1, 2, 3, 4}
}
main() {
 Map<String, int> map = {"one": 1, "two": 2};
 print(map['one']);
 var copiedMap = map; // reference 참조
 var newMap = {...map}; // shallow copy
 copiedMap.clear(); // 싹 다 지우기
 print(map); // 원본에도 영향
 print(newMap); // 다른 reference 참조로 변화 없음 {one: 1, two: 2}
}
 
function
main() {
 print(square.runtimeType); // (dynamic) => int. 함수의 타입도 찍어볼 수 있다.
 print(printSomething.runtimeType); // (dynamic) => void
 int result = addTwo(square(2));
 printSomething(result);
}
int square(var num) {
 return num * num;
}
int addTwo(int a) => a + 2; // arrow function이 가능하다.
void printSomething(var msg) => print(msg);
 
named parameters ({})와 optional parameters ([]) 
1. 일반적으로 우리가 쓰는 건 positional parameters다. 위치에 기반하기 때문이다.
2. 위치가 아닌 이름으로 구별하고 싶다면 named parameters를 사용하면 된다.
3. optional parameters는 positional parameters이면서도 단순히 옵셔널하게끔 만들 수 있다.
4. named parameters와 positional optional parameters 둘 다 사용하면 optional이라 기본값 지정 혹은 null handling이 필요.
main() {
 sum(1, 2);
 sum2(a: 1, b: 2); // named parameters
 sum3(1, b: 2);
 sum4(1); // positional optional parameters
}
int sum(int a, int b) => a + b;
int sum2({int a = 0, int b = 0}) =>
 a + b; // named parameters는 optional이다. 따라서 기본값을 지정하거니 null handling이 필요.
int sum3(int a, {int b = 0}) => a + b; // 부분적으로 named parameters를 사용할 수 있다.
int sum4(int a, [int b = 0]) => a + b; // positional optional parameters
 
exception과 try/catch/finally
// Exception 던지기
int shouldGreaterThanZero(int val) {
 if (val > 0) {
 return val;
 } else {
 throw Exception('value should greater than zero');
 }
}
// try/catch/finally
void verifyValue(var val) {
 var verifiedValue;
 try {
 verifiedValue = shouldGreaterThanZero(val);
 } catch (e) {
 print("error occured: $e");
 } finally {
 print(verifiedValue);
 }
}
 
final와 const
final : 런타임에 값이 지정이 되어도 상관 없음.
const : 컴파일타임에 값이 꼭 지정되어야 한다. -> 빌드 타임에 값이 정해져 있어야지, 런타임 돈 이후에 알게 되는 값은 안된다.
공통점 : 둘 다 상수라서 초기화 이후 변경이 불가능함.
main() {
 final name = 'test';
 final String name2 = "wow";
 const name3 = "ama";
 const String name4 = "ddd";
 
 final now = new DateTime.now(); // 런타임에 할당되어 괜찮으니 에러가 아님
 const now2 = new DateTime.now(); // 컴파일 시점에 알수가 없음. DateTime이 돌아야 알 것 아니냐. 그래서 에러임
}
 
enum
enum Status {
 loading,
 fetched,
 done,
 error,
}
main() {
 Status status = Status.loading;
 switch (status) {
 case Status.loading:
 print('로딩중');
 break;
 case Status.fetched:
 print('페칭중');
 break;
 default:
 print('불가능');
 }
}

dart 기본기

댓글