# 4.9 控制流 (Control Flow)

### `if` 表达式 (`if`expressions)

Sway supports *if*, *else*, and *else if* expressions that allow you to branch your code depending on conditions.

Sway 支持 *if*、*else* 和 *else if* 表达式，允许你根据条件分支代码。

For example:\
例如：

```
fn main() {
    let number = 6;

    if number % 4 == 0 {
        // do something
    } else if number % 3 == 0 {
        // do something else
    } else {
        // do something else
    }
}

```

#### 在 `let` 语句中使用 `if` (Using `if` in a `let` statement)

Like Rust, `if`s are expressions in Sway. What this means is you can use `if` expressions on the right side of a `let` statement to assign the outcome to a variable.

与 Rust 一样，`if` 是 Sway 中的表达式。这意味着您可以在 `let` 语句的右侧使用 `if` 表达式将结果分配给变量。

```
let my_data = if some_bool < 10 { foo() } else { bar() };

```

Note that all branches of the `if` expression must return a value of the same type.

请注意，`if` 表达式的所有分支都必须返回相同类型的值。

#### `match` 表达式 （`match` expressions)

Sway supports advanced pattern matching through exhaustive `match` expressions. Unlike an `if` statement, a `match` expression asserts **at compile** time that all possible patterns have been matched. If you don't handle all the patterns, you will get compiler error indicating that your `match` expression is non-exhaustive.

Sway 通过详尽的`match 匹配`表达式支持高级模式匹配。与 `if` 语句不同，`match` 表达式断言在编译时\*\*所有可能的模式都已匹配。如果您不处理所有模式，您将收到编译器错误，表明您的`match 匹配`表达式是非穷尽的。

The basic syntax of a `match` statement is as follows:

`match` 语句的基本语法如下：

```
let result = match expression {
    pattern1 => code_to_execute_if_expression_matches_pattern1,
    pattern2 => code_to_execute_if_expression_matches_pattern2,
    pattern3 | pattern4 => code_to_execute_if_expression_matches_pattern3_or_pattern4
    ...
    _ => code_to_execute_if_expression_matches_no_pattern,
}

```

Some examples of how you can use a match statement:

有关如何使用匹配语句的一些示例：

```
script;

// helper functions for our example
fn on_even(num: u64) {
    // do something with even numbers
}
fn on_odd(num: u64) {
    // do something with odd numbers
}

fn main(num: u64) -> u64 {
    // Match as an expression
    let is_even = match num % 2 {
        0 => true,
        _ => false,
    };

    // Match as control flow
    let x = 12;
    match x {
        5 => on_odd(x),
        _ => on_even(x),
    };

    // Match an enum
    enum Weather {
        Sunny: (),
        Rainy: (),
        Cloudy: (),
        Snowy: (),
    }
    let current_weather = Weather::Sunny;
    let avg_temp = match current_weather {
        Weather::Sunny => 80,
        Weather::Rainy => 50,
        Weather::Cloudy => 60,
        Weather::Snowy => 20,
    };

    let is_sunny = match current_weather {
        Weather::Sunny => true,
        Weather::Rainy | Weather::Cloudy | Weather::Snowy => false,
    };

    // match expression used for a return
    let outside_temp = Weather::Sunny;
    match outside_temp {
        Weather::Sunny => 80,
        Weather::Rainy => 50,
        Weather::Cloudy => 60,
        Weather::Snowy => 20,
    }
}

```

### 循环 (Loops)

#### `while`

Loops in Sway are currently limited to `while` loops. This is what they look like:

Sway 中的循环目前仅限于`while`循环。他们看起来像这样：

```
while counter < 10 {
    counter = counter + 1;
}

```

You need the `while` keyword, some condition (`value < 10` in this case) which will be evaluated each iteration, and a block of code inside the curly braces (`{...}`) to execute each iteration.

您需要 `while` 关键字、每次迭代都会评估的某些条件（在本例中为 `value < 10`），以及花括号内的代码块（`{...}`）来执行每次迭代。

#### `break` 和 `continue` （`break` and `continue`）

`break` and `continue` keywords are available to use inside the body of a `while` loop. The purpose of the `break` statement is to break out of a loop early:

`break` 和 `continue` 关键字可在 while 循环体内使用。 `break` 语句的目的是尽早跳出循环：

```
fn break_example() -> u64 {
    let mut counter = 1;
    let mut sum = 0;
    let num = 10;
    while true {
        if counter > num {
            break;
        }
        sum += counter;
        counter += 1;
    }
    sum // 1 + 2 + .. + 10 = 55
}

```

The purpose of the `continue` statement is to skip a portion of a loop in an iteration and jump directly into the next iteration:

`continue` 语句的目的是跳过迭代中的一部分循环并直接跳转到下一次迭代：

```
fn continue_example() -> u64 {
    let mut counter = 0;
    let mut sum = 0;
    let num = 10;
    while counter < num {
        counter += 1;
        if counter % 2 == 0 {
            continue;
        }
        sum += counter;
    }
    sum // 1 + 3 + .. + 9 = 25
}

```

#### 嵌套循环 (Nested loops)

You can also use nested `while` loops if needed:

如果需要，您还可以使用嵌套的 `while` 循环：

```
while condition_1 == true {
    // do stuff...
    while condition_2 == true {
        // do more stuff...
    }
}

```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://zenofchain.gitbook.io/sway-bian-cheng-yu-yan-geng-xin-zhong-the-sway-programming-languageupdatin/4.-sway-yu-yan-ji-chu-sway-language-basics/4.9-kong-zhi-liu-control-flow.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.