1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

let n = 7
let label = if n % 2 == 0 { "even" } else { "odd" }   // if 是表达式
print(label)                                           // odd
let size = switch n {                                  // switch 也是表达式
case 1...5: "small"
case 6...10: "medium"
default: "large"
}
print(size)                                            // medium

enum Shape { case circle(Double), square(Double) }
func area(of shape: Shape) -> Double {
    switch shape {                                     // 穷尽性由编译器检查
    case .circle(let r): 3.14 * r * r
    case .square(let a): a * a
    }
}
print(area(of: .circle(1.0)))                          // 3.14

let opt: Int? = 5
if let v = opt { print(v) }                            // 5
guard let w = opt else { fatalError() }                // guard 提前退出
print(w)                                               // 5

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

package main

import "fmt"

func main() {
	n := 7
	if r := n % 2; r == 0 {          // if 可以带初始化语句
		fmt.Println("even")
	} else {
		fmt.Println("odd")           // odd
	}
	label := "odd"                    // 没有三元，只能写 if
	if n%2 == 0 {
		label = "even"
	}
	fmt.Println(label)                // odd

	switch d := 3; d {                // 默认不穿透
	case 1:
		fmt.Println("one")
	case 2, 3:
		fmt.Println("two-or-three")   // two-or-three
	default:
		fmt.Println("other")
	}
	switch 1 {
	case 1:
		fmt.Println("one")
		fallthrough                   // 显式穿透
	case 2:
		fmt.Println("two")            // two
	}
	switch {                          // 无标签 switch == switch true
	case n > 5:
		fmt.Println("big")            // big
	}
	var x any = 42
	switch v := x.(type) {            // 类型 switch
	case int:
		fmt.Println("int", v)         // int 42
	case string:
		fmt.Println("string", v)
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

# ---- 条件分支与模式匹配 ----
n = 7
label = "even" if n % 2 == 0 else "odd"      # 条件表达式
print(label)                                  # odd

def classify(command: str) -> str:
    match command.split():                    # 结构化模式匹配（3.10+）
        case ["go", direction]:               # 序列模式 + 捕获
            return f"go {direction}"
        case ["go", _]:                       # _ 是通配，不绑定
            return "go nowhere"
        case ["look"] if n > 5:               # 守卫
            return "look closely"
        case _:                               # 兜底，match 不检查穷尽
            return "unknown"

print(classify("go north"))                   # go north
print(classify("go"))                         # go nowhere
print(classify("look"))                       # look closely
print(classify("dance"))                      # unknown

point = (0, 3)
match point:                                  # 捕获与或模式
    case (0, 0):
        print("origin")
    case (0, y) | (y, 0):
        print(f"on axis at {y}")              # on axis at 3
    case _:
        print("elsewhere")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

enum class Level { LOW, MID, HIGH }

fun label(n: Int): String = when (n) {            // when 是表达式
    0 -> "zero"
    in 1..5 -> "small"
    in 6..10 if n % 2 == 1 -> "odd medium"        // 守卫条件：2.1 预览、2.2 稳定
    else -> "big or even"                         // 有主语时需要兜底
}

fun describe(x: Any): String = when (x) {         // 类型分支
    is String -> "string of ${x.length}"
    is Int -> "int $x"
    else -> "other"
}

fun levelName(l: Level): String = when (l) {      // enum 穷尽，无需 else
    Level.LOW -> "low"
    Level.MID -> "mid"
    Level.HIGH -> "high"
}

fun main() {
    println(label(7))             // odd medium
    println(describe("abc"))      // string of 3
    println(levelName(Level.MID)) // mid
    val n = 7
    println(if (n % 2 == 0) "even" else "odd")   // Kotlin 没有三元运算符，用 if 表达式
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

sealed interface Shape permits Circle, Square {}
record Circle(double r) implements Shape {}
record Square(double a) implements Shape {}

public class Ctrl {
    static double area(Shape s) {
        return switch (s) {                            // switch 表达式，必须穷尽
            case Circle c -> 3.14 * c.r() * c.r();
            case Square q -> q.a() * q.a();
        };
    }

    static String kind(Object o) {
        return switch (o) {
            case null -> "null";                       // null 标签（21 起）
            case Integer i when i > 10 -> "big int";   // 守卫子句
            case Integer i -> "int " + i;
            case String s -> "string " + s.length();
            default -> "other";
        };
    }

    public static void main(String[] args) {
        System.out.println(area(new Circle(1.0)));     // 3.14
        System.out.println(kind(42));                  // big int
        System.out.println(kind("abc"));               // string 3
        int n = 7;
        String label = n % 2 == 0 ? "even" : "odd";    // 三元运算符
        System.out.println(label);                     // odd
        switch (n) {
            case 1: System.out.println("one"); break;
            default: System.out.println("other");      // other
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

#include <cstdio>
enum class Color { red, green, blue };

int main() {
    int n = 7;
    const char* label = (n % 2 == 0) ? "even" : "odd";        // 三元
    std::printf("%s\n", label);                               // odd
    if (int k = n * 2; k > 10) std::printf("big %d\n", k);    // big 14
    else std::printf("small %d\n", k);                        // k 的作用域在 if/else 内

    switch (n) {                                              // 只能整型/枚举
        case 1: std::printf("one\n"); break;
        case 2:
        case 3: std::printf("two-or-three\n"); break;          // 多标签共用
        default: std::printf("other\n"); break;                // other
    }

    if constexpr (sizeof(void*) == 8) std::printf("64-bit\n"); // 编译期分支
    else std::printf("32-bit\n");                              // 64-bit

    Color c = Color::green;
    switch (c) {
        case Color::red: std::printf("red\n"); break;
        case Color::green: std::printf("green\n"); break;      // green
        case Color::blue: std::printf("blue\n"); break;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

#include <stdio.h>

int main(void) {
    int n = 7;
    const char *label = (n % 2 == 0) ? "even" : "odd";   /* 三元运算符 */
    printf("%s\n", label);                               /* odd */

    switch (n) {                                         /* C 只有 switch 语句 */
    case 1: puts("one"); break;
    case 2:
    case 3: puts("two-or-three"); break;                 /* 多个标签共用一段代码 */
    default: puts("other"); break;                       /* other */
    }
    switch (1) {                                         /* 穿透是默认行为 */
    case 1: puts("one");                                 /* 故意不写 break */
    case 2: puts("two"); break;                          /* one 然后 two */
    }
    if (n > 5)
        if (n > 10) puts("gt10");
        else puts("5..10");                              /* 悬垂 else 绑定最近的 if */
    /* ✅ 想让 else 绑定外层 if 就加大括号 */
    if (n > 5) {
        if (n > 10) puts("gt10");
    } else {
        puts("5 or less");
    }
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

function classify(n)
    if n < 0
        "negative"
    elseif n == 0
        "zero"
    else
        "positive"
    end                       # if 块的值 = 最后一条语句的值
end
println(classify(7))           # positive
println(classify(-1))          # negative

n = 7
println(n % 2 == 0 ? "even" : "odd")   # odd（三元不是惰性语法糖，是表达式）

# 没有 switch/match：多重派发是惯用替代
describe(::Int) = "int"
describe(::AbstractString) = "string"
describe(::AbstractFloat) = "float"
println(describe(1.5))         # float
println(describe("x"))         # string

# ifelse 是普通函数，两个分支都会被求值
println(ifelse(n > 5, "big", "small"))   # big

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

using System;

record Point(int X, int Y);

class Ctrl {
    static string Describe(object o) => o switch {        // switch 表达式
        null => "null",
        int i when i > 10 => "big int",                   // 守卫
        int i => $"int {i}",
        Point { X: 0, Y: 0 } => "origin",                 // 属性模式
        Point (0, var y) => $"on y-axis at {y}",          // 位置模式
        string s => $"string of {s.Length}",
        _ => "other",                                     // 丢弃模式兜底
    };

    static void Main() {
        Console.WriteLine(Describe(42));                   // big int
        Console.WriteLine(Describe(new Point(0, 3)));        // on y-axis at 3
        Console.WriteLine(Describe("abc"));                 // string of 3
        int n = 7;
        string label = n % 2 == 0 ? "even" : "odd";
        Console.WriteLine(label);                           // odd
        switch (n) {
            case 1:
                Console.WriteLine("one");
                break;
            case 2:
                goto case 3;                                // 显式跳到别的 case
            case 3:
                Console.WriteLine("two-or-three");
                break;
            default:
                Console.WriteLine("other");                 // other
                break;
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

sealed class Shape {}
class Circle extends Shape { final double r; Circle(this.r); }
class Square extends Shape { final double a; Square(this.a); }

double area(Shape s) => switch (s) {          // switch 表达式 + 穷尽检查
  Circle(r: var r) => 3.14 * r * r,           // 对象模式解构
  Square(a: var a) => a * a,
};

String classify(Object o) => switch (o) {
  int n when n > 10 => 'big int',             // 守卫
  int n => 'int $n',
  [int a, int b] => 'pair $a,$b',             // 列表模式
  String s => 'string ${s.length}',
  _ => 'other',
};

void main() {
  print(area(Circle(1.0)));                   // 3.14
  print(classify(42));                        // big int
  print(classify([1, 2]));                    // pair 1,2
  var n = 7;
  print(n % 2 == 0 ? 'even' : 'odd');         // odd
  if (n case > 5) print('big');               // if-case：模式直接写在条件里
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

n <- 7
label <- if (n %% 2 == 0) "even" else "odd"    # if 是表达式
print(label)                                    # [1] "odd"

# ⚠️ else 必须和 if 处在同一个表达式里
# 下面这样写会报 "unexpected else"：
#   if (n > 0) { "pos" }
#   else { "neg" }
x <- 1
if (x > 0) {
  res <- "positive"
} else {
  res <- "non-positive"
}
print(res)                                      # [1] "positive"

ifelse(c(1, 2, 3) > 1, "big", "small")          # 向量化：[1] "small" "big" "big"

switch("b", a = 1, b = 2, c = 3)                # [1] 2（按名字）
switch(2, "one", "two", "three")                # [1] "two"（按位置）

# 没有模式匹配：用 if/else 链或 switch 模拟
grade <- function(score) {
  if (score >= 90) "A" else if (score >= 60) "pass" else "fail"
}
print(grade(75))                                # [1] "pass"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

const std = @import("std");
const Shape = union(enum) { circle: f64, square: f64 };

fn area(s: Shape) f64 {
    return switch (s) {                 // switch 表达式，必须覆盖所有 tag
        .circle => |r| 3.14 * r * r,    // 捕获负载
        .square => |a| a * a,
    };
}

fn classify(n: i32) []const u8 {
    return switch (n) {                 // 支持多重值与范围
        0 => "zero",
        1, 2, 3 => "small",
        4...10 => "medium",
        else => if (n < 0) "negative" else "big",   // if 也是表达式
    };
}

pub fn main() void {
    std.debug.print("{d}\n", .{area(.{ .circle = 1.0 })});   // 3.14
    std.debug.print("{s}\n", .{classify(7)});                // medium
    const maybe: ?i32 = 5;
    if (maybe) |v| {                                         // 解包 optional
        std.debug.print("{d}\n", .{v});                      // 5
    } else {
        std.debug.print("none\n", .{});
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

local n = 7
print(n % 2 == 0 and "even" or "odd")     -- odd（三元模拟）
if 0 then print("0 是真值") end            -- 0 是真值（只有 false/nil 为假）

if n < 0 then
  print("negative")
elseif n == 0 then
  print("zero")
else
  print("positive")                        -- positive
end

-- 没有 switch：表分派是最接近的替代
local name = { [1] = "one", [2] = "two", [3] = "three" }
print(name[n] or "other")                  -- other

-- ⚠️ and/or 三元在候选值为 false/nil 时失效
local v = nil
print(true and v or "fallback")            -- fallback（不是 nil）
-- ✅ 用显式 if 或 (cond and {a} or {b})[1] 之类的包装
local r
if true then r = v else r = "fallback" end
print(r)                                   -- nil

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

type Shape =
  | { kind: "circle"; r: number }
  | { kind: "square"; a: number };

function area(s: Shape): number {
  switch (s.kind) {                     // 判别联合：按 kind 收窄
    case "circle": return 3.14 * s.r * s.r;
    case "square": return s.a * s.a;
    default: {
      const never: never = s;           // 穷尽检查：漏一个就编译报错
      throw new Error(`unhandled ${JSON.stringify(never)}`);
    }
  }
}
console.log(area({ kind: "circle", r: 1 }));   // 3.14

const n: number = 7;
console.log(n % 2 === 0 ? "even" : "odd");     // odd
const user: { address?: { city?: string } } = {};
console.log(user.address?.city ?? "unknown");  // unknown（?. 与 ??）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

const n = 7;
console.log(n % 2 === 0 ? "even" : "odd");    // odd
switch (n) {                                   // 用 === 比较
  case 1: console.log("one"); break;
  case 2:
  case 3: console.log("two-or-three"); break;
  default: console.log("other");               // other
}
// switch (true)：把任意条件放进 case
switch (true) {
  case n > 10: console.log("big"); break;
  case n > 5: console.log("medium"); break;    // medium
  default: console.log("small");
}
const user = { address: null };
console.log(user.address?.city ?? "unknown");   // unknown
console.log(user.address && user.address.city); // null（旧写法）
console.log(0 || "fallback", 0 ?? "fallback");  // fallback 0（?? 只认 null/undefined）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

<?php
$n = 7;
echo $n % 2 === 0 ? "even" : "odd", "\n";      // odd

switch ($n) {                                   // 松散比较 + 穿透
    case 1: echo "one\n"; break;
    case 2:
    case 3: echo "two-or-three\n"; break;
    default: echo "other\n";                     // other
}

echo match (true) {                              // match 是表达式，严格比较
    $n > 10 => "big\n",
    $n > 5 => "medium\n",                        // medium
    default => "small\n",
};

echo match (2) {
    1, 2 => "one-or-two\n",                      // 多值分支
    default => "other\n",                        // one-or-two
};

$v = null;
echo $v ?? "default", "\n";                       // default（?? 只判 null）
echo $v ?: "falsy", "\n";                         // falsy（?: 判所有假值）
echo 0 == "abc", "\n";                            // 空（PHP 8 起 0 == "abc" 为 false）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

n = 7
puts n.even? ? "even" : "odd"            # odd
puts "big" if n > 5                       # big（语句修饰符）
puts "small" unless n > 5                 # 不输出（unless 是 if 的反面）

case n                                    # case/when 用 === 比较
when 1 then puts "one"
when 2, 3 then puts "two-or-three"
when 4..10 then puts "medium"             # medium（区间用 === 匹配）
when Integer then puts "int"
else puts "other"
end

case { name: "Ruby", year: 1995 }         # case/in 模式匹配
in { name: String => name, year: Integer => year } if year < 2000
  puts "#{name} is old"                   # Ruby is old
in [Integer => a, Integer => b]
  puts "pair #{a},#{b}"
else
  puts "unknown"
end

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

let xs = [10, 20, 30]
var sum = 0
for x in xs { sum += x }                        // for-in
print(sum)                                       // 60
for (i, x) in xs.enumerated() { print(i, x, terminator: " ") }
print()                                          // 0 10 1 20 2 30
for i in stride(from: 0, through: 10, by: 5) { print(i, terminator: " ") }
print()                                          // 0 5 10
for i in (1...3).reversed() { print(i, terminator: " ") }
print()                                          // 3 2 1
var n = 0
while n < 3 { n += 1 }
print(n)                                         // 3
repeat { n += 1 } while n < 5                    // repeat-while 至少一次
print(n)                                         // 5

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

package main

import "fmt"

func main() {
	total := 0
	for i := 1; i <= 5; i++ {           // 三段式
		total += i
	}
	fmt.Println(total)                   // 15
	for total < 20 {                     // 只有条件 == while
		total += 5
	}
	fmt.Println(total)                   // 20
	sum, c := 0, 0
	for {                                // 无限循环
		c++
		if c == 3 {
			break
		}
		sum += c
	}
	fmt.Println(sum)                     // 3
	for i, v := range []int{10, 20} {     // range 给索引与值
		fmt.Println(i, v)                 // 0 10 / 1 20
	}
	for range 4 {                         // Go 1.22 起可以 range 整数
		fmt.Print("*")                    // ****
	}
	fmt.Println()
	fs := []func() int{}
	for _, v := range []int{1, 2, 3} {    // 1.22 起每次迭代新建 v
		fs = append(fs, func() int { return v })
	}
	fmt.Println(fs[0](), fs[1](), fs[2]()) // 1 2 3
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

print([x * x for x in range(1, 6)])        # [1, 4, 9, 16, 25]
print([x for x in range(10) if x % 2])     # [1, 3, 5, 7, 9]
print({x: x * x for x in range(3)})        # {0: 0, 1: 1, 2: 4}
print(list(enumerate("abc")))              # [(0, 'a'), (1, 'b'), (2, 'c')]
print(list(zip([1, 2], [3, 4])))           # [(1, 3), (2, 4)]
for i, v in enumerate("ab"):
    print(i, v)                            # 0 a / 1 b
g = (x * x for x in range(3))              # 生成器表达式是惰性的
print(next(g), next(g), next(g))           # 0 1 4
print(sum(i for i in range(1, 101)))       # 5050

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

fun main() {
    for (i in 1..5) print("$i ")                  // 1 2 3 4 5
    println()
    for (i in 5 downTo 1 step 2) print("$i ")      // 5 3 1
    println()
    for (i in 1 until 5) print("$i ")               // 1 2 3 4（不含 5）
    println()
    for (i in 1..<5) print("$i ")                   // 1 2 3 4（..< 等价写法）
    println()
    for ((i, c) in "abc".withIndex()) print("$i$c ")   // 0a 1b 2c
    println()
    val xs = listOf("a", "b")
    for (x in xs) print(x)                          // ab
    println()
    xs.forEachIndexed { i, x -> print("$i$x ") }     // 0a 1b
    println()
    var n = 0
    while (n < 3) n++                               // while
    do { n++ } while (n < 5)                        // do-while 至少一次
    println(n)                                      // 5
    repeat(3) { print("hi ") }                       // hi hi hi
    println()
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

import java.util.List;
import java.util.stream.IntStream;

public class Loops {
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 1; i <= 5; i++) sum += i;        // 经典 for
        System.out.println(sum);                       // 15
        List<String> xs = List.of("a", "b");
        for (String x : xs) System.out.print(x);       // ab（增强 for）
        System.out.println();
        xs.forEach(x -> System.out.print(x + " "));     // a b（Iterable.forEach）
        System.out.println();
        int n = 0;
        while (n < 3) n++;                              // while
        System.out.println(n);                          // 3
        do { n++; } while (n < 5);                      // do-while 至少一次
        System.out.println(n);                          // 5
        for (;;) { n++; if (n == 8) break; }             // 无限循环
        System.out.println(n);                          // 8
        IntStream.range(0, 3).forEach(i -> System.out.print(i));   // 012
        System.out.println();
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

#include <cstdio>
#include <vector>
int main() {
    std::vector<int> v{1, 2, 3};
    int sum = 0;
    for (int x : v) sum += x;                        // 范围 for（C++11）
    std::printf("%d\n", sum);                        // 6
    for (auto& x : v) x *= 2;                        // 引用可修改元素
    std::printf("%d %d %d\n", v[0], v[1], v[2]);     // 2 4 6
    for (int i = 0; auto x : v) { (void)i; (void)x; } // C++20：范围 for 带初始化语句
    for (int i = 0; i < 3; i++) std::printf("%d ", i);
    std::printf("\n");                                // 0 1 2
    int n = 0;
    while (n < 3) n++;
    do { n++; } while (n < 5);                        // do-while 至少一次
    std::printf("%d\n", n);                           // 5
    for (;;) { if (n++ > 6) break; }                   // 无限循环
    std::printf("%d\n", n);                           // 8
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

#include <stdio.h>
int main(void) {
    int total = 0;
    for (int i = 1; i <= 5; i++) total += i;      /* C 风格 for */
    printf("%d\n", total);                         /* 15 */
    int xs[] = {10, 20, 30};
    for (size_t i = 0; i < sizeof xs / sizeof xs[0]; i++)
        printf("%d ", xs[i]);
    printf("\n");                                  /* 10 20 30 */
    int *p = xs;                                   /* 指针版遍历 */
    for (int n = 3; n > 0; n--, p++) printf("%d ", *p);
    printf("\n");                                  /* 10 20 30 */
    int k = 0;
    while (k < 3) k++;                             /* while */
    printf("%d\n", k);                             /* 3 */
    do { k++; } while (k < 5);                     /* do-while 至少一次 */
    printf("%d\n", k);                             /* 5 */
    for (;;) { if (k++ > 6) break; }                /* 无限循环 */
    printf("%d\n", k);                             /* 8 */
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

total = 0
for i in 1:5
    total += i
end
println(total)                        # 15

A = [10, 20, 30]
for i in eachindex(A)                 # 通用索引遍历
    print(A[i], " ")                  # 10 20 30
end
println()
for (i, v) in enumerate(A)            # 值与序号
    print("$i:$v ")                   # 1:10 2:20 3:30
end
println()
for (a, b) in zip([1, 2], [3, 4])     # 并行遍历
    print(a + b, " ")                 # 4 6
end
println()

println([x^2 for x in 1:5])            # [1, 4, 9, 16, 25]（推导式）
println(sum(x^2 for x in 1:100))       # 338350（生成器，不建数组）
g = (x^2 for x in 1:3)                 # 生成器是惰性的
println(collect(g))                    # [1, 4, 9]

n = 0
while n < 3
    global n += 1                      # 顶层作用域里需要 global
end
println(n)                             # 3