Dartの基礎を勉強しました(1)~(4)のまとめ+補足

<h1>前置き</h1>
今回は[Dartの基礎を勉強しました(1)~(4)を投稿してきましたが。。。
なんとなぁ。。。く覚え切れていない。＋補足しなければならない部分が多々あったため、まとめて記載していこうという話です。

まぁ、ゆるっと始めていきましょうか。
今回はこちらを引用していきます。

https://flutternyumon.com/learn-dart-from-scratch/#index_id46

<h2>main関数</h2>
>main関数とは、Dartのプログラムを実行した際、最初に呼び出される関数です。全てのプログラムはmain関数を通して実行されます。

これを読むに重要なのは、"Dartのプログラムを実行した際、最初に呼び出される関数"ということですね。

```dart
//定義は
void main(){
  (実行したい処理)
}
```
こんな感じがDartのmain処理の基本です。
では、[Hello World!!]を表示してみましょう。
表示する時はprint関数を使用しますが、これは次に記載します。

```dart
//Hello World!!を出力してみよう
void main(){
  print('Hello World');
}
```

これが基本です。

<h2>print関数</h2>
>print関数を使えば、指定した文字列、数字(または変数)を出力できます。

もっと簡単に言えば、出力するために使う関数と覚えるのも一つの手ですね。

では、print関数の定義方法を見ていきましょうか。

```dart
//printの定義
print(出力したい文字列や数字);
```

こんな感じですね。これは特に解説しなくてもわかるかもしれないので、早速、例をコードに記載していきましょうか。

```dart
//printの例
void main(){
  String powder = 'Hello World';
  print(powder);
}

//---出力---
//Hello World
```

<h2>変数</h2>
さて、改めて"基本的な変数"を見ていきましょう。
では、始めていきましょう。

●int型：整数値
●double型：実数
●String型：文字列
●boolean型：真偽値(true/false)
●List型：複数のvalue(値)を格納できる(同じvalue(値)を格納できる)
●Set型：複数のvalue(値)を格納できる(同じvalue(値)を格納できない)
●Map型：value(値)にkeyを紐付け、複数のvalueを格納できる。

さらに定義方法を見ていきましょう。

<h3>int型</h3>
```dart
//intの定義
int 変数名 = int型のvalue;
```
これがint型ですね。
では実際に変数名などを適当に決めて、valueを入れてみましょう。

```dart
//定義例
int hoge = 115;
```

<h3>double型</h3>
さて、double型の例です。
小数のものはdouble型で、定義を行います。

```dart
//double型の定義
double 変数名 = double型のvalue;
```
こんな感じで、定義を行います。

```dart
//定義例
double hoge = 11.5;
```

<h3>String型</h3>

では、String型ですね。
こちらは文字列を定義するのに使用します。
定義する時には''で文字を囲んでください。

```dart
//String型の定義
String 変数名 = String型のvalue;
```
文字列はこの形で定義していきます。
では、例を記載していきましょう。

```dart
//定義例
String hoge = 'Hello Powder!!!!!!'; //''で文字を囲みましょう。
```

<h3>boolean型</h3>
booleanは真偽値などの判定をするのに使用します。
真なら[true]、偽なら[false]
こんな感じですね。

では、定義方法です。

```dart
//boolean型の定義
bool 変数名 = boolean型のvalue(true/false);
```
このような形ですね。
では、早速、定義例を上げていきましょう。

```dart
//定義例
bool hoge = true;
bool powder = false;
```

<h3>List型</h3>

では、リストですね。
リストは、**複数のvalue(値)を格納できる(同じvalue(値)を格納できる)**
List,Set,Mapがありますが、それぞれに微妙な違いがあります。
まぁ、少しずつでいいので違いを覚えておきましょう。

```dart
//List型の定義
List<型> 変数名 = [宣言した型のvalue];
```
この部分では、Null-safetyを気をつけていかなければなりません。
では、List型の宣言例を見ていきましょう。

```dart
//定義例
List<String> hoge = ['mass','price','sugar'];
```

<h3>Set型</h3>
Setの特徴を改めて、記載しましょう。
Setは**複数のvalue(値)を格納できる(同じvalue(値)を格納できない)**
ここで、ListとSetの違いが見えてきますね。
Listは**同じ値が格納可能**
Setは**同じ値が格納不可**

では、定義の仕方を見ていきましょう。

```dart
//Set型の定義
Set<型> 変数名 = {宣言した型のvalue};
```
定義の宣言はこんな感じですね。
では、定義例を記載していきましょうか。

```dart
//定義例
Set<String> hoge = {'Powder','Flour','Sugar'};
```
<h3>Map型</h3>
Map型はList,Setと違い、
**value(値)にkeyを紐付け、複数のvalueを格納できる**
この点は、Mapの特徴とも言えますね。
では、定義方法を見ていきましょう。

```dart
//Map型の定義
Map<keyの型, valueの型> 変数名 = {宣言したkeyの型のvalue,宣言したkeyの型のvalue};
```
これが宣言方法ですね。
"宣言したkeyの型のvalue"の部分ですが、
"宣言したKeyの型:valueの型"と見た方がわかりやすいかもしれません。

では、宣言例を見ていきましょう。

```dart
//宣言例
Map<String, int> priceList = {'Flour':120, 'Sugar':130,'Salt':125};
```

変数はこんな感じですね。
後で、変数や関数、引数、戻り値、返り値などの意味も記載しておきましょう。

<h2>定数(final/const)</h2>
>final修飾子またはconst修飾子を使えば定数をできます

さて、finalとconstの修飾子は変数を定数として宣言できますがvalueが確定するタイミングがまるで違います。

このタイミングを理解していないと大変なことになるので、注意しましょう。

では、わかりやすく？解説&引用していきましょう。
まずは宣言方法と例を見ていきましょう。

```dart
//宣言方法
final 型 変数名 = value;
const 型 変数名 = value;

//宣言例
final String hoge = "Powder";
const String test = "Sugar";
```

宣言方法については、どちらも変わりないですね。
さて、ここで細かくどうしたらエラーになってしまうか。
見ていきましょうか。

まず、finalとconstはどうすると値が決定するか。
●final：コンパイル後に処理を実行
●const：コンパイル時に処理を実行

※補足：コンパイルとは？
>コンパイルとはプログラミングで書かれた文字列をコンピューターが理解できる形式に変換することを呼びます。

<h3>finalの場合(コンパイル後に処理が実行される)</h3>
```dart
//値を直接代入する場合
final String hoge = 'Powder';

//別の変数を代入する
String Top = 'Sugar';
final String deliciousSugar = Top;
```
finalで定数を宣言する場合、別の変数の値を代入できます。

<h3>constの場合(コンパイル時に処理を実行される)</h3>
```dart
//値を直接代入する場合
const String hoge = 'Powder';

//別の変数を代入する
String Top = 'Sugar';
const String deliciousSugar = Top;//コンパイルエラーになります。
```
このようになります。
引用になりますが、理由は下記になります。
>**constで定数を宣言する場合、直接値を代入できますが、別の変数を代入できません。**

>なぜならコンパイル時ではコンピューターがまだ他の変数を把握しておらずコンパイルエラーになってしまうからです。

上記より、constの例を解説すると、定数として宣言した「deliciousSugar」に別の変数「Top」を代入しようとしても、コンピュータ自体が「Top」を変数として把握していないためコンパイルエラーが発生します。

<h2>関数</h2>
Dartの関数には、[print関数]、[main関数]以外にもあります。
●void型関数(戻り値のない関数)
●戻り値のある関数
●キーワード引数を持つ関数
●アロー関数
上記のようなものがありますね。
では、一つ一つ見ていきましょうか。

の！！前に、プログラム初心者が結構陥りやすんですが。。。
いや、私もそうなんですが。。。。
「変数？関数？え？なんでしたっ。。。。け？」
となりやすいので、初心者あるあるでしょうね。。。

まず、初心者は基本的に変数、関数などの言葉に慣れてくるのがいいですね。

そして、書く、ひたすら書く。写経しながら内容を徐々に変えていくのがいいでしょう。

さて、少し前置きが長くなりましたが、関数とは何なのか？
について、引用していきましょうか。

**関数とは？**
>**関数とは、機能を保管し再利用できるようにした部品のようなものです。**

>関数に再度使用したいコードを保管しておき、必要となった時に関数を呼びだして保管しておいたコードを使用できます。

>  (プログラム)呼び出し　=>　実行

関数は、こんな感じになります。
"機能を保管し再利用できるようにした部品のようなもの"
→関数の中に処理を書いて、それを呼び出して処理を実行します。

"関数に再度使用したいコードを保管しておき、必要となった時に関数を呼び出して保管しておいたコードを使用できます。"
→関数の中に処理を記載し、保管します。これがプログラムで言う関数を定義する意味です。

「なんで関数なんて定義するんですか。。。？」
と聞かれたら上記のように答えましょう。

また、関数を定義することで、その関数を再利用することができます。
再利用することのメリットは、必要な処理を何度も記述する必要はなく、定義した関数を呼び出すことができるためコードも見やすくなります。

では、関数を定義していきましょうか。

<h2>void型関数(パラメータなし)</h2>
```dart
//定義
void 関数名(){
  (実行したい処理)
}
```
voidは型がないものです。
また、今回はパラメータがないので関数名()で関数を定義します。

では、例を上げていきましょう。

```dart
//void型、宣言例
main(){
  powder(); //関数の呼び出しを行います。
}

//処理を記載します
void powder(){
  print('粉です。');
}

//---出力---
//粉です。
```

<h2>void型関数(パラメータあり)</h2>
```dart
//定義
void 関数名(パラメータ){
  (実行したい処理)
}
```
パラメータなし、ありの違いは関数名の()にパラメータを書きます。
違いはそこだけですね。
では、例をあげていきましょう。

```dart
//宣言例
main(){
  hoge(116, 19); //関数の呼び出しを行う
}

void hoge(int num1, int num2){
  int total = num1 + num2;
  print(total);
}
```
こんな感じですね。
hogeの中にあるパラメータ(int num1, int num2)にそれぞれ、main()の中にある数字が格納されます。
そして、関数内の処理が実行されると言うわけなんです。

動きを見ると、本当にプログラムは面白いです。
だから、プログラムは嫌いになれないんですよね。。。ﾊﾊﾊ

私の話は置いておいて次にいきましょう。

<h2>戻り値のある関数(パラメータなし)</h2>
では、戻り値とは何かから見ていきましょうか。
**戻り値とは？**
>**戻り値とは、関数の処理を終えた後に呼び出し元に返すvalue(データ)のことを呼びます。**

>イメージ的には
>(プログラム)呼び出し => 実行 => (結果)Return => 呼び出し元

※本当は「循環」のようなイメージがいいと思いますが、矢印で表すとこんな感じになります。
>この呼び出し元に値を返すことを「return」、返す値を「戻り値」と呼びます。

```dart
//定義
戻り値の型 関数名(){
  (実行したい処理)
  return 戻り値;
}

//関数の呼び出し方 &　戻り値の受け取り方
戻り値の型 オブジェクト名 = 関数名();
```
これをみて、あーこうやればいいのね
となる人はセンスがいいですね。
是非プログラマーになりましょう。

さて、話が脱線しましたね。

話を戻すと、returnの後に書いた戻り値を宣言した関数に返します。

実際に処理を返してみましょうか。

```dart
main(){
  String name = Top();
  print(name);
}

String Top(){
  return "Hello Powder!!!!";
}
```
簡単に解説すると
String型でTop関数を宣言します
そのTop関数にreturnで戻り値である["Hello Powder"]を返します。
main処理では
String型でname変数を定義します。
そして、name変数に[=]でTop関数を格納します。
最後にprint関数にname変数を入れて表示させる

と、文字にするとこんな感じでしょうか？

まぁ、今回はパラメータがなしなので、こんなものでしょう。

<h2>戻り値の関数(パラメータあり)</h2>

今度はパラメータがある場合ですね。
戻り値の型　関数名(パラメータ(intなど))
で、定義したりします。
まぁ、早速、宣言方法を見ていきましょう。

```dart
//宣言
戻り値の型 関数名(パラメータ){
  (実行したい処理)
  return　戻り値;
}

//関数の呼び出し方 & 戻り値の受け取り型
戻り値の型 オブジェクト名 = 関数名(引数);
```
・・・え？
と言われてしまっても仕方ないですね。

では、実際に例を上げていきましょう。

```dart
main(){
  int totalPrice = price(1, 9);
  print(totalPrice);  //出力は[10]
  print(price);       //出力は[Closure 'price']
}


int price(int number1, int number2){
  int totalPrice = number1 + number2;
  return totalPrice;
}
```
こんな感じですね。
ではコードを追っかけていきましょうか。

まず、int型でprice関数を宣言します。
price関数のパラメータに(number1, number2)を入れます。
price関数を宣言したところで、実行したい処理を書いていきます。
今回はint型で宣言しているので、int型でオブジェクトを書きます。
オブジェクト = number1 + number2の処理を書きます。
そして、計算結果をreturnで戻り値を変数に返します。

さて、main処理です
オブジェクト = 関数名(パラメータ);
で、処理の実行を宣言します。
最後に、print関数でオブジェクトを格納し、表示させます。

例であげたプログラムはこれだけです。
では次にいきましょう。

<h2>キーワード引数を持つ関数</h2>
さて、キーワード引数にいきます。
その前に引数とパラメータ、キーワード引数について引用してきましょうか

では、引数とパラメータとは？
>**関数を定義する際、外部のvalue(データ)を関数に渡すことで、渡したvalueを関数内で使用できます。**

>また、関数に渡すvalueを「引数」と呼び、関数を定義する際に使用する仮の引数を「パラメータ」と呼びます。

つまり、これを簡単に言うとですね。

パラメータは
**(プログラム実行前) = 実行前(パラメータ設定)**
※関数を定義する際に使用する仮の引数を「パラメータ」

引数は
**(プログラム実行)PC =(引数)=> 実行(処理)**
※関数に渡すvalueを「引数」

このようになりますね。

次に、キーワード引数とは？
>**キーワード引数とは、value単体を関数に渡す代わりに「パラメータと引数をセット」で渡す引数のことを呼びます。**

>キーワード引数を関数に使うことで、引数の順序を変えたり、パラメータに初期値を与えたりできます。

>キーワード引数を使うには、パラメータを{ }で囲みます。また、パラメータの順序を変更できます。

これを簡単に表すと、
**(プログラム実行)呼び出し =(パラメータ:引数)=> 実行**
こんな感じですね。


では、キーワード引数を持つ関数について見ていきましょう

```dart
//定義
戻り値の型 関数名({パラメータ}){
  (実行したい処理)
}

//キーワード引数の関数の呼び出し方
関数名(パラメータ:引数);
```
例を挙げてコードを追っていった方が早いですね。

```dart
main(){
  hoge(num1: 11, num2: 5);
  hoge(num2: 1, num1: 9);
}


void hoge({int? num1, required int num2}){
  int totalHoge = num1 !+ num2;
  print(totalHoge);
}
```

さて、このような形になりますね。
Null-Safetyを回避するために少々無理やり感のあるやり方をしてしまっているような・・・？

まぁ。。。いいでしょう。

では、コードを見ていきましょう。

まず、void型でhoge関数をパラメータ付きで宣言します。
次に、int型で値を格納したいのでint型でオブジェクトを定義し、処理を記載しkます。
そしてprint関数にオブジェクトを格納し、戻り値をmain関数で呼び出した後に結果を表示するようにして処理の宣言は終わりです。

main関数では、hoge関数のどのパラメータに値を入れるかを[:]を使用して格納し、実行することで計算結果が出力されると言う形になります。

<h2>パラメータに初期値を指定</h2>
パラメータに初期値を設定するにはどうすれば、良いのでしょうか？
>**キーワード引数で、初期値を指定するには「=」でパラメータに初期値を代入します。**

>初期値を指定されたパラメータは関数を呼び出す際、引数を渡さなくても関数を実行できます。

>引数を渡さなかった場合は、パラメータで指定した初期値が関数で使用され、引数を渡した場合は引数の値が関数で使用されます。

重要な部分としては、
・"キーワード引数で、初期値を指定するには「＝」でパラメータに初期値を代入します"
・"引数を渡さなかった場合は、パラメータで指定した初期値が関数で使用され、引数を渡した場合は引数の値が関数で使用されます"
この二つは、処理を確認する上で重要な部分です。
(私はこの部分を確認しないで、少し処理の確認に時間を取られたので、皆さんはしっかり確認しておきましょう)

では、定義方法を見ていきましょう。

```dart
//定義
戻り値の型 関数名({パラメータ = 初期値}){
  (実行したい処理)
}
```
こんな感じです。
では、実際の処理を見ていきましょうか。

```dart
main(){
  hoge(num1:10); // num1:10, num2:2  = 12
  hoge(num2:15); // num1:1 , num2:15 = 16
  hoge(); // num1:1 , num2:2 = 3
}

void hoge({int num1 = 1, int num2 = 2}){
  int totalHoge = num1 + num2;
  print(totalHoge);
}
```
では、解説していきましょうか。

まず、void型で関数hogeをパラメータ(初期値付き)で宣言します。
次に、int型でtotalHogeという名前でオブジェクトを宣言します。
totalHogeの中で、処理を記載します。
今回は、totalHoge = num1 + num2;という処理を入れます。
そして、処理が完了したらprint関数でtotalHogeの結果を表示する。

main関数の処理は単純です。
・hoge(num1:10)
・hoge(num2:15)
・hoge()
hoge関数を呼び出して、num1に10を入れた場合、num2に15を入れた場合で計算します。
もちろん初期値が入っているので
・num1:10を代入している場合、初期値の2とたされるので、結果は12
・num2:15を代入している場合、初期値の1とたされるので、結果は11
・num1,num2は何も代入していない場合は、初期値の1,2がたされて、結果は3
こんな感じの処理になります。

そして、初期値が入っているので、Null-safetyを回避するために対策を取る必要はありません。

こんな感じです。

<h2>アロー関数</h2>
アロー関数とは？
>アロー関数は、関数で定義したいコードを1行でまとめられる際に使用できます。

>アロー関数では、他の関数のように{ }の中に実行したいコードを書かずに、「=>」の後に実行したいコードを書きます。

>また、戻り値を返すのに「return」を宣言する必要はありません。

アロー関数でできることはこんな感じです。
簡単な処理であれば、1行にまとめられるものなんだなぁ程度でいいでしょう。

では、定義をしてみましょう。

```dart
//void型の場合
void 関数名() => 実行したい処理;

//戻り値のある場合
戻り値の型 関数名() => 処理したい処理;
```
こんな感じですね。
アロー関数は[=>]です。
では、宣言から処理を見ていきましょう。

```dart
//宣言例
main(){
  hoge();
  int totalPrice = price(num1: 1, num2:9);
  print(totalPrice);
}

void hoge() => print('Hello Powder!!!!');
int price({int? num1, required int num2}) => num1 !+ num2;
```
アロー関数で処理を1行にまとめて、実行するようにします。
そして、今回もNull-saferyを回避するために[required]と[!+]にします。
(Null-safetyの対策は、今度話しますよ。。。(多分))

では、処理などの実装を解説します。

まず、void型でhoge関数を宣言します
=>で処理を記載します。今回はprint関数で"Hello Powder!!!!"を記述します。

戻り値型で、int型 price関数をパラメータ有りで宣言します。パラメータにはint型のnum1, num2を記載します。
=>でnum1 + num2を足し合わせる処理を記載します。

main関数の処理です。
void型で宣言したhoge()を呼び出します。
int型のオブジェクトで[totalPrice]を記載して、戻り値[price]を格納します。
priceにはパラメータでは[num1,num2]にそれぞれ値を入れていきます。
そして、print関数にtotalPriceのオブジェクトを入れ、表示させます。

こんな感じです。

<h2>コールバック関数/無名関数</h2>
>無名関数はコールバック関数に使用します。

ここは、後日追記します。

```dart
//定義(引数なしの場合)
(){
  (実行したい処理)
}

//引数(引数ありの場合)
(引数){
  (実行したい処理)
}
```

<h2>演算子</h2>
演算子は以下のようになります。

●算術演算子: +, -, *, /, ~/, %, ++, -
●代入演算子: +=, -=, *=, /=, ~/=, %=
●比較演算子: >, >=, ==, <, <=, !=
●論理演算子: &&, ||, !
●型テスト演算子: is, is!
●三項演算子: (条件)?真の場合の処理:偽の場合の処理;

<h3>算術演算子</h3>
では、算術演算子について見ていきましょう。

```dart
//足し算の処理
print(1 + 9); //10

//引き算の処理
print(9 - 1); //8

//掛け算の処理
print(1 * 9); //9

//割り算の処理
print(1 / 9); //0.11111111111

//割り算(小数点以下を切り捨てる)
print(1 ~/ 9); //0

//余りの処理
print(9 % 1); //0
```
```dart
// ++を変数の頭につける場合
//1を書かなくても、強制的に1が足されます
int num = 10;
print(++num);//11
print(num);//11

// ++を変数の末尾につける場合
//処理を記述しても、すぐに実行されない
int num = 10;
print(num++);//10
print(num);//11

// --を変数の頭につける場合
//1を記述すると強制的に1が引かれる
int num = 10;
print(--num);//9
print(num);//9

// --を変数の末尾につける場合
//処理を記述しても、すぐに処理は実行されない
int num = 10;
print(num--);//10
print(num);//9
```

<h3>代入演算子</h3>
```dart
//加算して代入
int num = 10;
num += 1;
print(num); //11

//減算して代入
num = 10;
num -= 1;
print(num); //9

//乗算して代入
num = 5;
num *= 2;
print(num); //10

//除算して代入
/*
この場合は小数点がついてしまう場合があるので
double型で変数を宣言しておきましょう。
*/
double num2 = 10;
num2 /= 4;
print(num2); //2.5

//除算して代入(小数点以下を切り捨て)
num = 5;
num ~/= 2;
print(num); //2

//剰余して代入
num = 5;
num %= 2;
print(num); //1
```

<h3>比較演算子</h3>
```dart
// A > B（AがBより大きい:true)
print(5 > 1); // true

// A >= B（AがB以上:true)
print(5 >= 1); // true

// A == B（AとBが等しい:true)
print(5 == 1); // false

// A <= B（AはB以下:true)
print(5 <= 1); // false

// A < B（AはBより小さい:true)
print(5 < 1); // false

// A != B（AとBは異なる:true)
print(5 != 1); // true
```

<h3>論理演算子</h3>
```dart
// A && B（A=trueかつB=true => true）
print(true && true); // true
print(true && false); // false
print(false && false); // false

// A || B（A=trueまたはB=true => true）
print(true || true); // true
print(true || false); // true
print(false || false); // false

// !A（Aがfalse => true）
print(!false); // true
print(!true); // false
```

<h3>型テスト演算子</h3>
```dart
// A is type（Aの型がtypeで指定した型と同じ：true）
int num = 10;
print(num is int); // true
print(num is String); // false

// A is! type（Aの型がtypeで指定した型と異なる：true）
print(num is! int); // false
print(num is! String); // true
```

<h3>三項演算子</h3>
```dart
//(条件式)?真の場合の処理：偽の場合の処理;
int num = 8;
(num >= 5) ? print('5以上') : print('5より下'); // 5以上
```
<h2>条件分岐</h2>
条件分岐には次のような種類があります。

●if文
●if-else文
●else if
●switch文
●三項演算子

<h3>if文</h3>
if文はどんな時に使うのでしょうか？
>1つの条件に対し、1つの処理を実行するか否か指定できます。

```dart
//定義
if(条件式){
  (実行したい処理)
}
```
if文はこのように処理をしていきます。
if文などを使用する時はタイトル通りに条件分岐に使用します。

では、実際にコードを記述しましょう。

```dart
main(){
  //条件が真の場合
  int number = 10;
  if(number >= 5){
    print('5以上');
  }

  //条件が偽の場合
  number = 1;
  if(number >= 10){
    print('10以上');
  }
}
```

比較演算子を使用して、出力を変えてあげましょう。
ですが、if-else文を使うことでコードが綺麗になります。
条件をさらに追加したければ、else if文を使えばいいでしょう。

では、いろいろ見ていきましょうか

<h3>if-else文</h3>
>１つの条件に対し、真と偽それぞれに対して実行したい処理を指定できます。

では、定義方法です

```dart
//定義
if(条件式){
  (真の場合に実行したい処理)
}else{
  (偽の場合に実行したい処理)
}
```
こんな感じで定義を進めていきます。
では、実際にコードを書いていきましょうか。

```dart
//例
void main() {
  //条件が真の場合
  int number = 10;
  if (number >= 5) {
    print('５以上');
  }else{
    print('5より下');
  } 

  //条件が偽の場合
  number = 1;
  if (number >= 5) {
    print('10以上');
  }else{
    print('10より下');
  } 
}
```
if-else文はifで指定された条件が満たされない場合はelseで指定された処理が実行されるといった流れになります。
条件としては二つしかないので、複数の条件を指定したい場合はelse ifを使いましょう。

<h3>else if</h3>
といことで、複数の条件分岐をさせるために使用する
else ifを見ていきましょう。

>複数の条件に対し、処理を実行するか否か指定できます。

```dart
//定義
if(条件式A){
  (実行したい処理)
}
else if(条件式B){
  (実行したい処理)
}
else if(条件式C){
  (実行したい処理)
}
else{
  (実行したい処理)
}
```
では、処理で重要な部分を見ていきましょう。
else ifは、
if, else if, elseを記述しなければなりません。
また、それぞれの条件式にはしっかりと処理を書きましょう。

```dart
//宣言例
void main() {
  int number = 3;
  if (number >= 10) {
    print('10以上');
  } else if (number >= 5) {
    print('5以上');
  } else if (number >= 4) {
    print('4以上');
  } else if (number >= 0) {
    print('0以上');
  } 
  else {
    print('０より下');
  }
}
```

<h3>switch文</h3>
else ifとは少し違い、caseに値を入れ、それにあれはまった場合は処理を実行するといった文になります。

>式の評価(値)が3つ以上に枝分かれする際の条件分岐に使用します。

では、定義方法を見ていきましょう。
連続して例も挙げていきましょう。

```dart
//定義
switch(式){
  case 値A:
    (実行したい処理)
    break;
  case 値B:
    (実行したい処理)
    break;
  case 値C:
    (実行したい処理)
    break;
  default:
    (実行したい処理)
    break;
}
```

```dart
//宣言例
main() {
  String fruit = 'powder';
  switch (fruit) {
    case 'apple':
      print('リンゴ');
      break;
    case 'banana':
      print('バナナ');
      break;
    case 'grape':
      print('ぶどう');
      break;
    case 'powder':
      print('粉');
      break;
    default:
      print('リンゴ、バナナ、ぶどう、粉以外');
      break;
  }
}
```

<h3>三項演算子</h3>

三項演算子です。三項演算子は以下のような特徴があります。
>if-else文を1行のコードで表せます。

どういうこっちゃねん！？
と文を見ただけでは思う人も多いと思うので、早速宣言方法を見ていきましょう。

```dart
//定義
(条件式)?真の場合の処理：偽の場合の処理;
```

こんな感じにです。
簡単にいうと、条件式の左辺は真,右辺は偽の処理を書きます。
では、例を挙げていきましょう。

```dart
//宣言例
void main() {
  int num = 8;
  (num >= 5) ? print('5以上') : print('5より下'); 
}
```

こんな感じですね。
if文などは、条件分岐、「この場合ならA,この場合ならB,この場合ならC,それ以外ならD」といった感じで操作の自由性を上げられます。

組み合わせを変えながら、応用もしていきましょう。

<h2>反復処理</h2>
では、反復処理を見ていきましょう。

反復文はループ文とも言えます。
・この回数、処理をしてください。
・この条件に入るまで処理を繰り返してください。
上記のようにイメージすると良いかもしれませんね。

反復処理の種類は以下のようになります。
●for文
●for-in文
●forEach文
●while文
●do-while文
●break文
●continue文
このような種類があります。
反復処理(ループ処理(Loop))について、引用してみましょう。

> ループ処理とは、プログラムに繰り返し同じ処理をさせることを呼び、ループ処理には大きく分けてfor文とwhile文の2つがあります。

>**●for文：ループ処理の回数が決まっている場合**
>**●while文：ループ処理の回数が決まっていない場合**

>for文、while文どちらを使っても同じループ処理ができます。
>ただ、ループ処理の回数が決まっていたら「for文」、回数が決まっていないなら「while文」と使い分けるのが一般的です。

>また、**for文やwhile文に「break文」「continue文」を実装することで、ループ処理を強制終了したり、ループ処理の途中でループの先頭に戻ったりできます。**

では、1つ1つ見ていきましょう。

<h3>for文</h3>

for文とはどんなものなのでしょうか？
>for文とは、**条件式で指定した条件回数を満たすまで処理を続けるループ処理のことを呼びます。**
>また同じ系統のループ処理に、for-in文、forEach文があります。

>for文とは
for(初期値; 条件式; 変化式{
 　条件式が「true」の間、処理を実行 
>}
>条件式が「false」になるとループから脱出

for文の宣言方法は次のようになります。
また、続いて例文を挙げていきましょう。

```dart
//定義方法
for(初期化式; 条件式; 変化式){
  (実行したい処理)
}
```

```dart
//今回は型推論をする[var]で初期化する型を推論します
//今回の場合はint型でも通ります。
void main() {
  for (var i = 0; i < 10; i++) {
    print(i);
  }
  print('ループから脱出');
}
```

<h3>for-in文</h3>
for-in文は、ListやSetの中に格納されているものをすべて表示するために使われるといってもいいでしょう。

>**for-in文を使えば、ListやSetに格納されている全てのvalue(データ)をindex０から順に取得し、取得したvalueを使ってプログラムを実行できます。**

では、早速宣言方法と例を見ていきましょうか。

```dart
//定義方法
for (var 変数 in List/Set){
  (実行したい処理)
}
```

```dart
//今回は型推論をする[var]で初期化する型を推論します
//今回の場合はString型でも通ります。
void main() {
  List<String> mixFruit = ['apple', 'banana', 'grape', 'orange'];
  for (var fruit in mixFruit) {
    print(fruit);
  }
  print('Loopから脱出');
}
```

<h3>forEach文(List/Setの場合)</h3>
こちらもListとSet、そしてMapの中に格納されている値をすべて表示するのに使用しますね。

>**forEach文を使えば、宣言したList, Set, Mapなどに格納されている全てのvalueやkeyをindex０から順に取得し、取得したvalueを使ってプログラムを実行できます。**

>また、forEach文はList, Set, Mapのメソッドとして使用します。

では、宣言方法と例を見ていきましょう。

```dart
//定義
List/Set名.forEach((変数){
    (実行したい処理)
  }
)
```

```dart
List<String> mixFruit = ['apple', 'banana', 'grape', 'orange'];

mixFruit.forEach((fruit){
    print(fruit);
  }
);
print('Loopから脱出');
```

>forEach文(メソッド)を使用する際、引数にコールバック関数を使用します。

<h3>forEach文(Mapの場合)</h3>
では、Mapの場合を見ていきましょうか。

>List, Set同様にMapでもforEach文を使用できます。

>Mapの場合、コールバック関数の引数にkeyとvalueの順で2つの変数を代入します。

>forEach文に関数も使用できます。

```dart
//定義
List/Set名.forEach((変数key,変数value){
    (実行したい処理)
  }
)
```

```dart
void main() {
  Map<String, int> ages = {
    'Alex': 18,
    'Ben': 15,
    'Charlie': 25,
  };
  ages.forEach((name, age) {
    print("${name} is ${age} years old");
  });
  print('Loopから脱出');
}
```

<h3>while文</h3>
while文はどういったものでしょうか？
>**while文とは、指定した条件式の真偽値が「true」の間、処理を続けるループ処理のことを呼びます。**
>同じ系統のループ処理に、do-while文があります。

>while(条件式){
>  条件式が「true」の間、処理を実行
>}
>  条件式が「false」になるとループから脱出

while文はこのようになっておりますね。

では、早速while文の宣言方法、使用例を見ていきましょう。

```dart
//定義
while(条件式){
  (実行する処理)
}
```

```dart
//例
void main() {
  int num = 0;
  while (num < 5) {
    print(num);
    num++;
  }
  print('ループから脱出');
}
```

<h3>do-while文</h3>
では、do-while文を見ていきましょうか
>**while-do文は、基本while文と同じです。**

>**異なるのはdo-while文では先にプログラムを実行し、実行した後でループ処理をするかどうか条件式で判断します。**

こんな感じです。
では、宣言方法、例を見ていきましょうか。

```dart
void main() {
  int num = 0;
  do {
    print(num);
    num++;
  } while (num < 5);
  print('ループから脱出');
}
```

<h3>break文</h3>
では、break文です。
break文はなんでしょうか。

>**break文は、for文やwhile文などのLoopと共に使われ、ループ処理の際、if文などでbreak文が実行されると直ちにループを強制終了します(break文の後の処理は実行されません)。**

>Loop{
>・・・
> if(条件式){break;}
>・・・
>}
> ループから脱出

これがbreak文です。
では、宣言方法と例を見ていきましょう。

```dart
//定義(for文の場合)
for(初期値;条件式;変化式){
  ...
  if(条件式){
    ...
    break;
  }
  ...
}
```

```dart
void main() {
  for (var i = 0; i < 10; i++) {
    if (i == 5) {
      break;
    }
    print(i);
  }
}
```

<h3>continue文</h3>
continue文です。
continue文とはなんでしょうか？
>**continue文は、for文やwhile文などのLoopと共に使われ、ループ処理の際、if文などでcontinue文が実行されると直ちに、次のループ処理に移行します(continue文の後の処理は実行されません)。**

>Loop{
>・・・
> if(条件式){continue;}
>・・・
>}
> ループから脱出

こんな感じですね。
では、宣言方法、例を挙げていきましょう。

```dart
//定義(for文の場合)
for(初期値;条件式;変化式){
  ...
  if(条件式){
    ...
    continue;
  }
  ...
}
```

```dart
//例
void main() {
  for (var i = 0; i < 10; i++) {
    if (i % 2 == 0) {
      continue;
    }
    print(i);
  }
}
```

<h2>例外処理</h2>