今天来学if和循环还有函数,这个和其他语言的差不多

if条件语句

这个老熟人了,这里不过多描述了

DART已复制
int score = 85;

if (score >= 90) {
  print("优秀");
} else if (score >= 60) {
  print("及格");
} else {
  print("不及格");
}

三元运算符

这个和其他语言的一样,本质上是if的简写版本,就是条件为true就是左边的,反之则是右边的

语法格式:

条件(布尔值) ? 表达式1 : 表达式2

DART已复制
void main() {
  int age = 18;

  String result = age >= 18 ? "成年人" : "未成年人";

  print(result);
}

switch case语句

DART已复制
void main() {
  String fruit = "apple";

  switch (fruit) {
    case "apple":
      print("苹果");
      break;
    case "banana":
      print("香蕉");
      break;
    default:
      print("未知水果");
  }
}

这个和C#和Java还有C++,C里的很像,但是大同小异,比如有的有break,有的没有,不过我们的dart语言里的default的最后一个没有break

对了,和java还有C#一样,这个也是分现代写法和旧写法的

DART已复制
void main() {
  String fruit = "apple";

  String result = switch (fruit) {
    "apple" => "苹果",
    "banana" => "香蕉",
    _ => "未知水果"
  };

  print(result);
}

这个是新的写法,省略了case的和default关键字

循环

循环就不用多说了,和C#还有java里的没有区别

while循环

DART已复制
void main() {
  int i = 0;

  while (i < 5) {
    print(i);
    i++;
  }
}

do while循环

DART已复制
void main() {
  int i = 10;

  do {
    print(i);
    i++;
  } while (i < 5);
}

for 循环

DART已复制
void main() {
  for (int i = 0; i < 5; i++) {
    print(i);
  }
}

for in循环

DART已复制
void main() {
  List<String> fruits = ["apple", "banana", "orange"];

  for (var fruit in fruits) {
    print(fruit);
  }
}

break和continue关键字

break（直接退出循环）,continue（跳过本次）

DART已复制
void main() {
  List<String> fruits = ["apple", "banana", "orange"];

  for (var i = 0; i < fruits.length; i++) {
    if (fruits[i] == "banana") {
      continue;
    }
    print(fruits[i]);
  }
}
DART已复制
void main() {
  List<String> fruits = ["apple", "banana", "orange"];

  for (var i = 0; i < fruits.length; i++) {
    if (fruits[i] == "banana") {
      break;
    }
    print(fruits[i]);
  }
}

函数

函数这个都熟悉,dart的函数和java这些差不多,只是某些地方有区别

参数通常分为有参和无参,这里我就从有参和无参来分类吧

无参

普通无参函数

DART已复制
void hello() {
  print("Hello");
}

返回值无参函数

DART已复制
int getNumber() {
  return 10;
}

箭头写法(Lambda表达式)

但是只允许一条表达式,即只有return这一句

DART已复制
int getNumber() => 10;

调用规则

规则：

  • 函数名 + ()

有参

普通有参函数

这个也称为必选位置参数

特点

  • 必须传
  • 按顺序传（位置固定）
  • 最基础、性能最好（无额外处理）
  • 返回值类型可省略，Dart会自动推断类型为dynamic
DART已复制
int add(int a, int b) {
  return a + b;
}

//也可以写成箭头函数(Lambda表达式)
int add(int a, int b) => a + b;

void main() {
  print(add(2, 3));
}
Function 类型参数

可以把函数作为参数

语法

DART已复制
void foo(Function fn) {
  fn();
}

✅ 更规范写法（推荐）

DART已复制
void foo(void Function() fn) {
  fn();
}

✅ 带参数

DART已复制
void foo(int Function(int, int) calc) {
  print(calc(2, 3));
}

✅ 特点

  • 强类型函数签名 ⭐
  • Dart 比 JS 严谨

可选参数（可以不传）

位置可选参数 []

语法（用 []）

  • 规则：可选位置参数必须位于必传参数后面 , 采用中括号包裹
  • 语法：函数名(String a , [String?b,…..]),传递时按照顺序传递
DART已复制
void foo(int a, [int? b, int? c]) {
  print('$a, $b, $c');
}

调用

DART已复制
foo(1);          // b=null, c=null
foo(1, 2);       // b=2, c=null
foo(1, 2, 3);    // b=2, c=3

✅ 默认值写法

DART已复制
void foo(int a, [int b = 10]) {
  print('$a, $b');
}

✅ 特点

  • 可以不传
  • 必须按顺序传
  • 不能跳过中间参数 ❗
  • 通常需要 ?（可空）

❌ 错误示例

DART已复制
foo(1, , 3); // ❌ 不允许跳过

我们可以自己练习一下带返回值的写法

DART已复制
void main() {
  print(add(1, 2));
  print(comment("我"));
  print(comment("我", "喜欢"));
}

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

String comment(String a, [String? b, String? c = "明日方舟终末地"]) {
  return a + (b ?? "") + (c ?? "");
}

​ image-20260416113840742

命名参数 {}

语法（用 {}）

  • 特点：可选命名参数必须位于必传参数后面，采用大括号包裹
  • 语法：函数名(String a , {String?b , …}), 传递时按照参数名：值的方式进行传递，无需关注顺序
DART已复制
void foo({int? a, int? b}) {
  print('$a, $b');
}

✅ 调用

DART已复制
foo(a: 1, b: 2);
foo(b: 2);       // 可以只传一个

✅ 必填命名参数（required）

DART已复制
void foo({required int a, int? b}) {
  print('$a, $b');
}
foo(a: 1);       // ✅
foo();           // ❌ 报错

✅ 默认值

DART已复制
void foo({int a = 10, int b = 20}) {
  print('$a, $b');
}

✅ 特点

  • 按名字传，不看顺序
  • 可以只传一部分
  • 可读性极高 ⭐⭐⭐
  • Flutter 里用得最多

✅ 适用场景

👉 参数多 / 可选多 / UI配置

例如：

DART已复制
Container(
  width: 100,
  height: 200,
  color: Colors.red,
)

练习一下

DART已复制
void main() {
  playerData("JohnDoe");
  playerData("JaneSmith", age: 25);
  playerData("Alice", level: "intermediate");
}

void playerData(String username, {int? age = 18, String? level = "beginner"}) {
  print("Username: $username");
  print("Age: $age");
  print("Level: $level");
  print('-------------------------');
}
this 参数

在类里非常常见👇

✅ 语法

DART已复制
class Person {
  String name;
  int age;

  Person({required this.name, required this.age});
}

✅ 特点

  • 自动赋值
  • 常和命名参数一起用
  • Flutter 代码里遍地都是
混合参数

同样的,以上两种是可以混用的,但是有顺序要求(先位置,后命名)

正确顺序（必须记住）

DART已复制
必选位置参数
→ 可选位置参数 []
→ 命名参数 {}

✅ 示例

DART已复制
void foo(int a, [int? b], {int? c}) {
  print('$a, $b, $c');
}

❌ 错误写法

DART已复制
void foo({int? a}, int b) {} // ❌ 命名参数不能在前

匿名函数

匿名函数这个在C#和java里也很常见,而且和JavaScript差不多,都可以用Function来定义函数类型

没有名字的函数

DART已复制
() {
  print("hello");
}

这就是一个匿名函数。

但它本身没用，必须赋值或传递：

DART已复制
var f = () {
  print("hello");
};

f(); // 调用

在 Dart 里：函数也是对象，类型是 Function

DART已复制
Function f = () {
  print("hello");
};

但更推荐写成：

DART已复制
void Function() f = () {
  print("hello");
};

因为：

  • Function 太泛（不安全）
  • void Function() 有明确参数和返回值

带参数的匿名函数

DART已复制
var f = (int a, int b) {
  return a + b;
};

或者箭头写法：

DART已复制
var f = (int a, int b) => a + b;

这个东西实际用途比较广

回调函数
DART已复制
void run(void Function() fn) {
  fn();
}

run(() {
  print("执行了");
});
集合操作
  1. forEach
DART已复制
var list = [1, 2, 3];

list.forEach((item) {
  print(item);
});
  1. map（转换）
DART已复制
var list = [1, 2, 3];

var newList = list.map((item) {
  return item * 2;
}).toList();

箭头简化：

DART已复制
var newList = list.map((item) => item * 2).toList();
  1. where（过滤）
DART已复制
var list = [1, 2, 3, 4];

var result = list.where((item) {
  return item % 2 == 0;
});
返回函数（闭包）
DART已复制
Function makeAdder(int x) {
  return (int y) {
    return x + y;
  };
}

var add5 = makeAdder(5);
print(add5(3)); // 8
临时逻辑(立即执行函数)
DART已复制
(() {
  print("立即执行");
})();

总之就这些功能

  1. 回调函数（按钮、事件）
  2. 集合操作（map / where / forEach）
  3. 异步处理（Future / async）
  1. 返回函数（闭包）
  2. 策略模式（动态逻辑）

  1. 立即执行函数（IIFE）