Dart 語言核心技術：條件判斷、迴圈與函式詳解

– 12 分鐘閱讀

Dart 的控制流程與迴圈結構賦予程式根據不同條件執行不同程式碼的能力。條件判斷式 if 和 switch 可根據變數值執行對應程式碼區塊，迴圈則允許重複執行程式碼，直到特定條件滿足為止。while 迴圈會在每次迭代開始前檢查條件，而 do-while 迴圈則在迭代結束後檢查，確保至少執行一次。for 迴圈適用於已知迭代次數的場景。break 語句用於立即跳出迴圈，continue 則跳過當前迭代，繼續下一次迴圈。函式是 Dart 中重要的程式碼組織單元，可將特定功能封裝起來，提高程式碼的重用性和可維護性。函式可以接受引數並傳回值，引數可以是必需的，也可以是選擇性的，使用 void 表示不傳回值。

解答

  1. if 陳述式：
const myAge = 25;
if (myAge >= 13 && myAge <= 19) {
  print('Teenager');
} else {
  print('Not a teenager');
}
  1. 三元運運算元：
const myAge = 25;
const answer = (myAge >= 13 && myAge <= 19) ? 'Teenager' : 'Not a teenager';
print(answer);

使用 Switch 陳述式簡化條件判斷

在 Dart 中，當您需要根據多個條件進行判斷時，使用 if-else 鏈結可以變得很冗長且難以閱讀。為瞭解決這個問題，Dart 提供了 switch 陳述式，讓您可以更清晰、更簡潔地進行條件判斷。

使用 if-else 鏈結進行條件判斷

以下是使用 if-else 鏈結進行條件判斷的例子：

int number = 3;

if (number == 0) {
  print('zero');
} else if (number == 1) {
  print('one');
} else if (number == 2) {
  print('two');
} else if (number == 3) {
  print('three');
} else if (number == 4) {
  print('four');
} else {
  print('something else');
}

這段程式碼可以正常運作，但當條件判斷變得更加複雜時，程式碼就會變得難以閱讀。

使用 switch 陳述式進行條件判斷

以下是使用 switch 陳述式進行條件判斷的例子：

int number = 3;

switch (number) {
  case 0:
    print('zero');
    break;
  case 1:
    print('one');
    break;
  case 2:
    print('two');
    break;
  case 3:
    print('three');
    break;
  case 4:
    print('four');
    break;
  default:
    print('something else');
}

這段程式碼可以產生相同的結果，但程式碼看起來更清晰、更簡潔。

使用 switch 陳述式進行字串判斷

switch 陳述式也可以用於字串判斷。以下是使用 switch 陳述式進行字串判斷的例子：

String weather = 'cloudy';

switch (weather) {
  case 'sunny':
    print('sunny');
    break;
  case 'cloudy':
    print('cloudy');
    break;
  case 'rainy':
    print('rainy');
    break;
  default:
    print('unknown');
}

這段程式碼可以根據 weather 變數的值進行判斷，並印出相應的結果。

切換語句和列舉型

在 Dart 中，切換語句（switch statement）是一種強大的控制流程工具，允許您根據變數的值執行不同的程式碼塊。列舉型（enum）則是一種用於定義有限選項的自定義型別。在本文中，我們將探討如何使用切換語句和列舉型來簡化您的程式碼。

切換語句

切換語句的基本語法如下：

switch (變數) {
  case 值1:
    // 執行程式碼
    break;
  case 值2:
    // 執行程式碼
    break;
  default:
    // 執行程式碼
    break;
}

在上面的例子中，變數 是您想要檢查的值，值1 和 值2 是可能的值，default 是當變數不匹配任何值時執行的程式碼。

列舉型

列舉型是一種用於定義有限選項的自定義型別。您可以使用 enum 關鍵字來定義一個列舉型：

enum Weather {
  sunny,
  snowy,
  cloudy,
  rainy,
}

在上面的例子中，我們定義了一個名為 Weather 的列舉型，包含四個可能的值：sunny、snowy、cloudy 和 rainy。

切換語句和列舉型的結合

現在，我們可以使用切換語句和列舉型來簡化您的程式碼。假設我們有一個 weatherToday 變數，其型別是 Weather，我們可以使用切換語句來執行不同的程式碼塊：

const weatherToday = Weather.cloudy;

switch (weatherToday) {
  case Weather.sunny:
    print('Put on sunscreen.');
    break;
  case Weather.snowy:
    print('Get your skis.');
    break;
  case Weather.cloudy:
  case Weather.rainy:
    print('Bring an umbrella.');
    break;
}

在上面的例子中，我們使用切換語句來檢查 weatherToday 的值，並執行不同的程式碼塊。

Mermaid 圖表

以下是本文的 Mermaid 圖表：

  graph LR
    A[變數] -->|切換語句|> B[執行程式碼]
    B -->|列舉型|> C[執行不同的程式碼塊]
    C -->|default|> D[執行預設程式碼]

圖表翻譯

本圖表展示了切換語句和列舉型的工作流程。變數 A 進入切換語句 B，然後根據其值執行不同的程式碼塊 C。如果變數不匹配任何值，則執行預設程式碼 D。

控制流程

控制流程是指程式的執行順序，可以使用條件判斷、迴圈和跳躍等控制結構來改變程式的執行流程。

判斷式

判斷式是用來根據條件來決定程式的執行流程，常見的判斷式包括 if 判斷式和 switch 判斷式。

if 判斷式

if 判斷式用來根據條件來決定是否執行某段程式碼，語法如下：

if (條件) {
  // 執行程式碼
}

例如：

const firstName = 'Bob';
if (firstName == 'Bob') {
  print('Hello, Bob!');
}

switch 判斷式

switch 判斷式用來根據條件來決定執行哪一段程式碼，語法如下：

switch (變數) {
  case 值1:
    // 執行程式碼
    break;
  case 值2:
    // 執行程式碼
    break;
  default:
    // 執行程式碼
    break;
}

例如：

const weatherToday = 'cloudy';
switch (weatherToday) {
  case 'sunny':
    print('今天天氣晴朗!');
    break;
  case 'cloudy':
    print('今天天氣多雲!');
    break;
  default:
    print('今天天氣不明!');
    break;
}

列舉型別

列舉型別（enum）是用來定義一組有名稱的常數值，例如：

enum Weather {
  sunny,
  cloudy,
  rainy,
}

可以使用列舉型別來簡化程式碼，例如：

const weatherToday = Weather.cloudy;
switch (weatherToday) {
  case Weather.sunny:
    print('今天天氣晴朗!');
    break;
  case Weather.cloudy:
    print('今天天氣多雲!');
    break;
  case Weather.rainy:
    print('今天天氣雨天!');
    break;
}

避免過度使用 switch 判斷式

switch 判斷式可以很方便地處理多個條件，但是如果過度使用，程式碼可能會變得難以維護。可以使用其他程式設計技術，例如多型性（polymorphism），來取代 switch 判斷式。

挑戰

以下是一些挑戰，測試你的控制流程知識：

  1. 找到錯誤：以下程式碼有什麼錯誤？
const firstName = 'Bob';
if (firstName == 'Bob') {
  const lastName = 'Smith';
} else if (firstName == 'Ray') {
  const lastName = 'Wenderlich';
}

final fullName = firstName + ' ' + lastName;
  1. 布林挑戰：以下布林表示式的值是什麼？
true && true
false || false
(true && 1 != 2) || (4 > 3 && 100 < 1)
((10 / 2) > 3) && ((10 % 2) == 0)
  1. 音訊列舉型別：建立一個名為 AudioState 的列舉型別，具有 playing、paused 和 stopped 的值。建立一個名為 audioState 的常數，賦予它 AudioState 的值。使用 switch 判斷式根據 audioState 的值印出一條訊息。

控制流程與迴圈

在前面的章節中，您學習瞭如何使用 if 陳述式來做出簡單的決策。然而，程式碼仍然是從上到下執行，雖然可以根據不同的條件執行不同的分支。在本章中，您將學習如何使用迴圈來重複執行任務。

迴圈的必要性

想想您每天做的重複性任務：呼吸、走路、吃飯等。程式設計也是一樣，需要重複執行某些動作。Dart 提供了 while 迴圈和 for 迴圈來實作這種重複性任務。

While 迴圈

while 迴圈會重複執行一段程式碼，直到某個布林值條件為 true。您可以這樣建立一個 while 迴圈：

while (condition) {
  // 迴圈程式碼
}

迴圈會在每次迭代時檢查條件。如果條件為 true，則執行迴圈程式碼並繼續下一次迭代。如果條件為 false，則迴圈停止。

Do-While 迴圈

do-while 迴圈是 while 迴圈的一種變體，它的條件是在迴圈結束時評估，而不是在開始時。因此，do-while 迴圈的程式碼至少會執行一次。

do {
  // 迴圈程式碼
} while (condition);

無窮迴圈

如果您建立了一個 while 迴圈，條件始終為 true，則迴圈將永遠執行，導致程式無法終止。這種情況稱為無窮迴圈。

while (true) {
  // 迴圈程式碼
}

實際範例

以下是一個簡單的 while 迴圈範例：

var sum = 1;
while (sum < 10) {
  sum += 4;
  print(sum);
}

這個迴圈會執行三次，輸出 5、9 和 13。第三次迭代後，sum 變數的值為 13，條件 sum < 10 成為 false，迴圈停止。

內容解密：

在這個範例中，while 迴圈的條件是 sum < 10。在每次迭代時，sum 變數的值會增加 4。當 sum 的值超過 10 時，條件變為 false，迴圈停止。這個迴圈展示瞭如何使用 while 迴圈來重複執行一段程式碼，直到某個條件為 true。

圖表翻譯：

  flowchart TD
    A[開始] --> B[迴圈條件]
    B --> C[迴圈程式碼]
    C --> D[條件評估]
    D --> E[迴圈停止]
    E --> F[程式終止]

這個圖表展示了 while 迴圈的流程：開始 -> 迴圈條件 -> 迴圈程式碼 -> 條件評估 -> 迴圈停止 -> 程式終止。

迴圈控制：While 迴圈和 Do-While 迴圈

在 Dart 中，迴圈是一種用於重複執行特定程式碼塊的控制結構。其中，While 迴圈和 Do-While 迴圈是兩種常用的迴圈型別。

While 迴圈

While 迴圈的基本語法如下：

while (condition) {
  // 程式碼塊
}

其中，condition 是一個布林表示式，如果為 true，則執行程式碼塊。如果為 false，則退出迴圈。

Do-While 迴圈

Do-While 迴圈的基本語法如下：

do {
  // 程式碼塊
} while (condition);

其中，condition 是一個布林表示式，如果為 true，則繼續執行程式碼塊。如果為 false，則退出迴圈。

比較 While 迴圈和 Do-While 迴圈

While 迴圈和 Do-While 迴圈都可以用於重複執行程式碼塊，但是它們之間存在一些差異。

  • While 迴圈在執行程式碼塊之前先評估條件，如果條件為 false，則不執行程式碼塊。
  • Do-While 迴圈在執行程式碼塊之後評估條件，如果條件為 true，則繼續執行程式碼塊。

以下是使用 While 迴圈和 Do-While 迴圈的例子：

// While 迴圈
var sum = 1;
while (sum < 10) {
  sum += 4;
  print(sum);
}

// Do-While 迴圈
var sum = 1;
do {
  sum += 4;
  print(sum);
} while (sum < 10);

在這個例子中，While 迴圈和 Do-While 迴圈都會執行相同的程式碼塊，但是 Do-While 迴圈可以避免重複程式碼。

跳出迴圈

在某些情況下，您可能需要跳出迴圈，可以使用 break 陳述式來實作。以下是使用 break 陳述式的例子：

var sum = 1;
while (true) {
  sum += 4;
  if (sum >= 10) {
    break;
  }
  print(sum);
}

在這個例子中，當 sum 大於或等於 10 時，迴圈會跳出。

圖表翻譯：

  flowchart TD
    A[開始] --> B[條件評估]
    B --> C[程式碼塊執行]
    C --> D[條件評估]
    D --> E[迴圈跳出]
    E --> F[結束]

在這個圖表中，迴圈的流程如下：

  1. 條件評估：評估迴圈的條件，如果為 true，則執行程式碼塊。
  2. 程式碼塊執行：執行程式碼塊。
  3. 條件評估：評估迴圈的條件，如果為 false，則跳出迴圈。
  4. 迴圈跳出：跳出迴圈。
  5. 結束：迴圈結束。

迴圈的世界

在程式設計中，迴圈是一個非常重要的概念。它允許我們重複執行一段程式碼，直到某個條件被滿足。在這篇文章中，我們將探討 Dart 中的迴圈，包括 while 迴圈、do-while 迴圈和 for 迴圈。

While 迴圈

While 迴圈是一種最基本的迴圈，它會重複執行一段程式碼，直到某個條件被滿足。以下是一個簡單的例子：

var sum = 0;
while (sum < 10) {
  sum += 1;
  print(sum);
}

在這個例子中，迴圈會重複執行，直到 sum 的值大於或等於 10。

Do-While 迴圈

Do-while 迴圈與 while 迴圈相似，但它會至少執行一次迴圈。以下是一個簡單的例子：

var sum = 0;
do {
  sum += 1;
  print(sum);
} while (sum < 10);

在這個例子中，迴圈會至少執行一次，然後才會檢查條件。

For 迴圈

For 迴圈是一種更常見的迴圈，它允許我們重複執行一段程式碼，直到某個條件被滿足。以下是一個簡單的例子：

for (var i = 0; i < 5; i++) {
  print(i);
}

在這個例子中，迴圈會重複執行，直到 i 的值大於或等於 5。

Break 和 Continue

在迴圈中，我們可以使用 break 和 continue 來控制迴圈的流程。break 會終止迴圈，而 continue 會跳過當前的迴圈，然後繼續下一個迴圈。以下是一個簡單的例子：

for (var i = 0; i < 5; i++) {
  if (i == 2) {
    continue;
  }
  print(i);
}

在這個例子中，迴圈會跳過 i 的值為 2 的迴圈，然後繼續下一個迴圈。

練習

現在，讓我們練習一下。請寫一個 for 迴圈，從 1 到 10，然後打印出每個數字的平方。

挑戰

最後，讓我們來做一些挑戰。請解答以下挑戰：

  1. 下一個 2 的次方：給定一個數字，請找出下一個 2 的次方。
  2. 斐波那契數列：請計算第 n 個斐波那契數字。
  3. 迴圈次數：請計算以下迴圈的次數和總和：
var sum = 0;
for (var i = 0; i <= 5; i++) {
  sum += i;
}
  1. 倒數：請打印出從 10 到 0 的倒數。
  2. 序列：請打印出 0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0 的序列。

重點

  • while 迴圈會重複執行一段程式碼，直到某個條件被滿足。
  • do-while 迴圈會至少執行一次迴圈。
  • for 迴圈會重複執行一段程式碼，直到某個條件被滿足。
  • break 會終止迴圈，而 continue 會跳過當前的迴圈，然後繼續下一個迴圈。

Dart 中的函式

函式是 Dart 中的一個基本概念，它允許你將程式碼組織成可重複使用的單元。函式可以接收引數，執行特定的任務，然後傳回結果。

函式的基本結構

在 Dart 中，函式的基本結構包括傳回型別、函式名稱、引數列表和函式體。以下是函式的基本結構：

傳回型別 函式名稱(引數列表) {
  函式體
}

函式的優點

函式有許多優點，包括：

  • 函式可以幫助你避免重複的程式碼。
  • 函式可以使你的程式碼更容易維護和修改。
  • 函式可以幫助你將複雜的任務分解成更小的、更容易管理的部分。

如何定義一個函式

以下是定義一個函式的例子：

String compliment(int number) {
  return '$number is a very nice number.';
}

在這個例子中，compliment 函式接收一個整數引數 number，然後傳回一個字串。

函式的呼叫

你可以使用函式名稱和引數列表來呼叫一個函式。以下是呼叫 compliment 函式的例子：

print(compliment(5)); // 輸出：5 is a very nice number.

函式的傳回值

函式可以傳回一個值，你可以使用 return 陳述式來指定傳回值。以下是傳回值的例子：

int add(int a, int b) {
  return a + b;
}

在這個例子中，add 函式傳回兩個整數引數的和。

函式的引數

函式可以接收引數，你可以使用引數列表來指定引數。以下是引數的例子：

void greet(String name) {
  print('Hello, $name!');
}

在這個例子中，greet 函式接收一個字串引數 name，然後打印出一個問候訊息。

函式的範圍

函式的範圍是指函式可以被呼叫的位置。函式可以被定義在全域範圍或區域性範圍。以下是範圍的例子：

// 全域範圍
void foo() {
  print('foo');
}

// 區域性範圍
void bar() {
  void baz() {
    print('baz');
  }
  baz();
}

在這個例子中，foo 函式被定義在全域範圍，可以被任何地方呼叫。baz 函式被定義在 bar 函式的區域性範圍，只可以被 bar 函式呼叫。

Dart 中的函式

Dart 中的函式是可重用的程式碼塊，能夠接收引數並傳回值。函式的基本結構包括傳回型別、函式名稱、引數和函式體。

函式的基本結構

傳回型別 函式名稱(引數) {
  // 函式體
}

例如：

String compliment(int number) {
  return '$number is a very nice number.';
}

函式的呼叫

函式可以透過其名稱和引數來呼叫。例如：

void main() {
  const input = 12;
  final output = compliment(input);
  print(output);
}

多引數函式

Dart 中的函式可以接收多個引數。例如：

void helloPersonAndPet(String person, String pet) {
  print('Hello, $person, and your furry friend, $pet!');
}

選擇性引數

Dart 中的函式可以有選擇性引數。選擇性引數需要被放在引數列表的末尾，並且需要被方括號 [] 包圍。例如：

String fullName(String first, String last, [String? title]) {
  if (title != null) {
    return '$title $first $last';
  } else {
    return '$first $last';
  }
}

函式的傳回值

函式可以傳回任何型別的值，包括 void。如果函式不傳回任何值，則需要使用 void 作為傳回型別。

內容解密：

上述程式碼展示了 Dart 中的函式的基本結構和使用方法。函式的名稱、引數和傳回值都是非常重要的部分，需要被正確地定義和使用。函式的體內可以包含任何合法的 Dart 程式碼，包括變數的定義、控制流程的使用等。

圖表翻譯：

  flowchart TD
    A[函式定義] --> B[函式呼叫]
    B --> C[函式體]
    C --> D[傳回值]
    D --> E[輸出]

上述圖表展示了函式的呼叫和執行過程。函式的定義是第一步，然後是函式的呼叫，接著是函式體的執行，最後是傳回值的輸出。

Dart 中的函式：基礎篇

在 Dart 中，函式是用來封裝一段可重複使用的程式碼的單元。它可以接受引數，執行特定的操作，並傳回結果。在本章中，我們將探討 Dart 中函式的基礎知識，包括函式的定義、呼叫、引數和傳回值。

從程式碼的組織、執行效率以及程式碼的可讀性等多個維度分析，Dart 的控制流程和迴圈結構提供了一套完整且高效的機制來引導程式執行。if-else、switch、while、do-while 和 for 迴圈的組合應用，可以滿足絕大部分的程式邏輯需求。然而，必須注意避免過度使用 switch 或巢狀過多的條件判斷，以免降低程式碼的可維護性。Dart 的函式機制，配合選擇性引數和明確的傳回型別，則進一步提升了程式碼的模組化和可重用性，有效降低了程式碼的冗餘度並提升了開發效率。展望未來，隨著 Dart 語言的持續發展，預計其控制流程和迴圈機制將會更加完善，並與非同步程式設計、泛型程式設計等特性更緊密地結合，為開發者提供更強大的程式碼組織和控制能力。對於追求高效、簡潔和可維護程式碼的開發者而言，深入理解並善用 Dart 的這些特性至關重要。玄貓認為，Dart 在控制流程和函式設計方面的優勢，使其在處理複雜業務邏輯和構建大型應用程式時更具競爭力。

玄貓

玄貓

技術愛好者，專注於分享程式開發、雲端技術與 AI 應用的心得體會。