Flutter系列：Flutter常见问答（可用于面试）

Flutter系列 Flutter常见问答

---

作者：李俊才 （jcLee95）：https://blog.csdn.net/qq_28550263
邮箱 ：291148484@163.com
本文地址：https://blog.csdn.net/qq_28550263/article/details/135604801

---

【简介】：本文总结了数十道 Flutter/Dart 中常见的问题，所有的问题提供了答案提示。

---

基础知识篇

什么是 Flutter？

Flutter 是由 Google 开发的开源 UI 框架，用于构建能够在移动、Web 和桌面上进行本地编译的应用程序，使用单一代码库。

什么是 Dart？

Dart 是用于构建 Flutter 应用程序的编程语言。它是一种强类型、面向对象的语言，支持 JIT（即时编译）和 AOT（提前编译）两种编译方式。

使用 Flutter 进行移动应用开发的优势有哪些？

Flutter 提供了许多优势，包括用于快速开发周期的热重载、丰富的可自定义 UI 小部件集、高性能以及能够从单一代码库构建多平台应用的能力。

解释 Flutter 中 热重载 和 热重启 的区别

简答：

• 热重载允许开发人员立即看到对代码的更改，而不会丢失应用的状态。它通过立即反映代码更改来加速开发过程。
• 热重启则重新构建整个应用，包括其状态。在对应用程序的依赖项或初始化代码进行更改时很有用。

在Flutter中，热重载（Hot Reload）和热重启（Hot Restart）是两个重要的开发工具，它们都有助于加速Flutter应用程序的开发过程。它们允许开发者在进行代码更改时，快速查看更新后的效果，而无需完全重新启动应用。

1. 热重载（Hot Reload）:

   • 特点： 热重载是一种开发工具，它允许开发者在不丢失应用状态的情况下，实时查看对代码的更改。
   • 工作原理： 当你进行代码更改并触发热重载时，Flutter框架会将新的代码注入到运行中的应用中，替换掉已有的代码。这样可以立即反映代码的更改，而应用程序的状态（例如打开的页面、当前数据等）将保持不变。
   • 适用场景： 热重载适用于 UI 和业务逻辑的调整，以及一些轻微的代码更改。它是一种快速迭代的工具，可以在开发过程中实时查看效果。

2. 热重启（Hot Restart）:

   • 特点： 热重启是另一种开发工具，它重新启动整个应用，包括其状态。与热重载不同，热重启会丢失应用的当前状态。
   • 工作原理： 当你触发热重启时，Flutter会重新构建整个应用，并重新执行初始化代码。这对于对应用程序的依赖项或初始化代码进行更改时非常有用。然而，由于重新启动应用，你将失去应用的当前状态。
   • 适用场景： 热重启通常用于更深层次的代码更改，例如修改了应用的依赖项或进行了一些需要应用完全重启才能生效的配置更改。

什么是 Flutter 中的小部件树？

小部件树是 Flutter 应用程序的小部件的分层结构，定义了应用程序的用户界面。它表示应用的可视组件，如按钮、文本字段和容器。

解释 Flutter 中“一切皆为小部件”的概念

在 Flutter 中，一切都是小部件，包括应用程序本身。小部件是 Flutter 应用程序的构建块，它们可以组合和嵌套以创建复杂的用户界面。甚至应用程序的布局和样式都是通过组合和配置小部件实现的。

Flutter 中有哪些不同类型的小部件？

从是否保存状态的角度进行划分，Flutter 提供了两种类型的小部件：无状态小部件和有状态小部件。

• 无状态小部件是不可变的，没有任何内部状态。它们仅基于提供给它们的输入来渲染 UI。
• 有状态小部件具有可以随时间变化的可变状态。它们可以被更新和重建多次，以反映其内部状态的变化。

main() 函数在 Flutter 中有什么作用？

main() 函数是 Flutter 应用程序的入口点。它负责执行应用程序并初始化 Flutter 框架。

解释 Flutter 中“小部件状态”的概念

小部件状态指的是有状态小部件维护的内部状态。它表示特定于该小部件的数据和配置，可以根据用户交互或其他因素随时间而变化。

Flutter 中的 setState() 方法

setState() 方法用于通知 Flutter 小部件的状态已更改并需要重新构建。它触发小部件的 build() 方法，使其能够在 UI 中反映更新后的状态。

---

Dart 语言篇

this 关键字是什么，创建构造函数时它的作用是什么？

简答：Dart 中的 this 关键字引用类的当前实例。在构造函数中，this 可以用于使用传递的参数初始化实例变量。
在 Dart 中，this 关键字引用的是当前类的实例，即当前对象。它可以用于访问当前对象的实例变量、方法和构造函数。在构造函数中，this 关键字通常用于区分实例变量和构造函数参数，以便正确初始化对象。

以下是关于 this 关键字在构造函数中的使用的详细讲解：

1. 引用实例变量和方法：

在类中，可以使用 this 来引用类的实例变量和方法。这对于在方法内部访问实例变量时特别有用，尤其是当方法的参数和实例变量具有相同的名称时。

class MyClass {
  int value;

  MyClass(this.value);

  void printValue() {
    print(this.value); // 使用 this 引用实例变量
  }
}

void main() {
  MyClass myObject = MyClass(42);
  myObject.printValue(); // 输出: 42
}

2. 在构造函数中初始化实例变量：

在构造函数中，如果参数和实例变量具有相同的名称，可以使用 this 关键字来明确指定初始化实例变量。这样可以避免命名冲突，并清晰地表示哪个是实例变量，哪个是参数。

class Point {
  double x, y;

  Point(this.x, this.y); // 使用 this 初始化实例变量
}

void main() {
  Point point = Point(2.0, 3.0);
  print('Point coordinates: (${point.x}, ${point.y})');
  // 输出: Point coordinates: (2.0, 3.0)
}

3. 链式调用构造函数：

在构造函数中，this 关键字还可以用于在同一个类的其他构造函数中调用当前类的构造函数。这种方式被称为链式调用构造函数。

class Rectangle {
  double width, height;

  Rectangle(this.width, this.height);

  Rectangle.square(double side) : this(side, side); // 链式调用构造函数
}

void main() {
  Rectangle square = Rectangle.square(4.0);
  print('Square area: ${square.width * square.height}');
  // 输出: Square area: 16.0
}

在上述例子中，Rectangle.square 构造函数通过 this(side, side) 调用了另一个构造函数，避免了重复的初始化代码。

总之，this 关键字在 Dart 中用于引用当前对象，它在构造函数中用于清晰地访问实例变量和方法，以及方便地进行构造函数之间的调用。

位置可选参数和命名可选参数有什么区别？

简答：位置可选参数在方括号 [] 内定义，可以按定义顺序传递给函数。命名可选参数在花括号 {} 内定义，可以通过指定名称的方式以任意顺序传递给函数。

在Dart语言中，位置可选参数和命名可选参数是两种不同的参数传递方式，它们有一些区别：

1. 位置可选参数：

• 定义语法： 位置可选参数通过在函数参数列表中用方括号 [] 包裹参数来定义。

  void printInfo(String name, [int age, String country]) {
    // 函数体
  }
  

• 调用方式： 位置可选参数需要按照参数的定义顺序进行传递，可以选择性地省略某些参数。

  printInfo("John");            // 仅传递必须的参数
  printInfo("Alice", 25);        // 传递两个参数
  printInfo("Jack", 28, "CHINA");   // 传递所有参数
  

2. 命名可选参数：

• 定义语法： 命名可选参数通过在函数参数列表中用花括号 {} 包裹参数，并用冒号 : 指定参数名来定义。

  void printInfo({String name, int age, String country}) {
    // 函数体
  }
  

• 调用方式： 命名可选参数可以通过指定参数名的方式以任意顺序传递，每个参数都有一个对应的名称。

  printInfo(name: "John");                  // 仅传递必须的参数
  printInfo(name: "Alice", age: 25);        // 以任意顺序传递参数
  printInfo(age: 28, country: "CHINA", name: "Jack");   // 以任意顺序传递参数
  

3. 区别总结：

• 位置可选参数：

  • 定义时使用方括号 []。
  • 调用时按照参数的定义顺序传递。

• 命名可选参数：

  • 定义时使用花括号 {}。
  • 调用时可以通过指定参数名以任意顺序传递。

使用哪种方式取决于你的需求和代码的清晰度。命名可选参数在某些情况下可以提高代码的可读性，特别是当函数有多个可选参数时。

扩展（extension）是什么，如何创建一个？

简答：Dart 中的扩展允许开发者向现有类添加新功能。通过使用 extension 关键字后跟名称以及 on 关键字和要扩展的类的名称来定义扩展。

在Dart中，扩展（extension）它允许你向现有的类添加新的方法，而无需修改这些类的源代码。这使得你可以在不继承或修改原始类的情况下，向其添加新的功能。

以下是创建Dart扩展的基本语法：

extension ExtensionName on ExtendedType {
  // 新的方法和属性在这里定义
}

• ExtensionName: 扩展的名称，用于标识扩展。
• on ExtendedType: 使用on关键字指定要扩展的类型，即希望添加新功能的类。
• 新的方法和属性: 在扩展中定义新的方法和属性，这些方法和属性将成为原始类的一部分。

下面是一个简单的示例，演示如何使用扩展为Dart的内置List类添加新的方法：

// 定义扩展
extension ListExtension on List<int> {
  int sum() {
    int result = 0;
    for (int value in this) {
      result += value;
    }
    return result;
  }
}

void main() {
  // 使用扩展中的新方法
  List<int> numbers = [1, 2, 3, 4, 5];
  int total = numbers.sum();

  print('Sum of numbers: $total'); // 输出: Sum of numbers: 15
}

在这个例子中，我们创建了一个名为ListExtension的扩展，它在List<int>上定义了一个新的sum方法。然后，我们可以在List实例上直接调用sum方法，就好像它是List类的原生方法一样。

需要注意的是，扩展只能添加新的方法和属性，而不能修改原始类的现有方法或属性。此外，扩展只在扩展的作用域内可见，因此在其他文件中无法访问扩展中定义的方法和属性。

我们能在动态类型上调用扩展的方法吗？

简答：不能，在 Dart 中，扩展方法是静态解析的，不能在动态类型上调用。

在Dart中，扩展方法是静态解析的，这意味着它们在编译时已经确定了，而不是在运行时。由于静态解析，扩展方法不能在动态类型上调用，因为在运行时，动态类型的具体类型是不确定的。

让我们通过一个例子来说明：

extension MyExtension on String {
  void printUpperCase() {
    print(this.toUpperCase());
  }
}

void main() {
  String myString = "hello";

  // 不能在动态类型上调用扩展的方法
  // 下面这行代码将会导致编译时错误
  // myString.printUpperCase();
}

在上面的例子中，我们为String类创建了一个扩展，添加了一个printUpperCase方法。但是，如果尝试在动态类型myString上调用这个方法，会导致编译时错误。

如果你想要在动态类型上调用类似的方法，你可以使用接口、抽象类或者直接在类中定义这些方法。例如：

abstract class MyPrintable {
  void printUpperCase();
}

extension MyExtension on String implements MyPrintable {
  void printUpperCase() {
    print(this.toUpperCase());
  }
}

void main() {
  MyPrintable myString = "hello";

  // 可以在动态类型上调用接口中定义的方法
  myString.printUpperCase();
}

在这个例子中，我们创建了一个MyPrintable接口，并为String类实现了这个接口。现在，我们可以在动态类型myString上调用接口中定义的printUpperCase方法。

如何定义泛型扩展？

在 Dart 中，可以通过在扩展声明中添加类型参数来定义泛型扩展。然后，可以在扩展的方法中使用这个类型参数。

如何创建一个工厂（factory）？

简答：在 Dart 中，通过添加 factory 关键字来创建工厂构造函数。这些构造函数可以返回子类型甚至 null。

在Dart中，使用factory关键字可以创建工厂构造函数。工厂构造函数与普通构造函数不同，它不必每次都返回一个新的实例，而可以返回一个现有的实例或者甚至是null。这使得工厂构造函数在某些情况下非常有用，例如对象缓存、单例模式等。

下面是使用factory关键字创建工厂构造函数的基本语法：

class MyClass {
  // 常规构造函数
  MyClass(this.property1, this.property2);

  // 工厂构造函数
  factory MyClass.fromSomething(dynamic something) {
    // 在这里进行一些逻辑，返回一个新实例或者现有实例
    // 也可以返回null
    return MyClass(something.property1, something.property2);
  }

  // 属性或方法
  // ...
}

在上面的例子中，MyClass.fromSomething是一个工厂构造函数，它接受一个参数 something，并返回一个MyClass实例。在工厂构造函数内部，你可以根据传入的参数来决定返回什么样的实例，这使得你可以在构造对象的过程中执行一些逻辑。

使用工厂构造函数时需要注意以下几点：

1. 返回类型： 工厂构造函数的返回类型是其所属类的类型。

2. 无法访问 this： 在工厂构造函数中，不能直接使用this关键字引用正在构建的对象。

3. 可以返回现有实例： 工厂构造函数可以返回已经存在的实例，这对于实现单例模式或对象缓存等场景非常有用。

一个更接近实际的例如：

class Logger {
  final String name;
  static final Map<String, Logger> _cache = {};

  // 常规构造函数
  Logger._internal(this.name);

  // 工厂构造函数
  factory Logger(String name) {
    if (_cache.containsKey(name)) {
      return _cache[name]!;
    } else {
      final logger = Logger._internal(name);
      _cache[name] = logger;
      return logger;
    }
  }

  void log(String message) {
    print('$name: $message');
  }
}

void main() {
  var logger1 = Logger('Logger 1');
  var logger2 = Logger('Logger 2');
  var logger3 = Logger('Logger 1'); // Reuse existing instance

  print(identical(logger1, logger2)); // false
  print(identical(logger1, logger3)); // true
}

在上面的代码中，Logger类使用工厂构造函数创建日志记录器。如果已经存在具有相同名称的日志记录器，则直接返回现有实例，否则创建一个新的实例。这样可以确保相同名称的日志记录器始终是相同的实例，从而实现了对象缓存的效果。

什么是空感知运算符，如何使用它？

Dart 有两个空感知运算符：?? 和 ??=。?? 运算符如果第一个操作数非空，则返回第一个操作数；否则，返回第二个操作数。??= 运算符仅在变量当前为 null 时才将值赋给变量。

如何在 Dart 中有条件地访问属性或方法？

Dart允许使用 ?. 运算符进行条件属性或方法访问。如果 ?. 前面的对象为 null，则整个表达式将计算为 null。

如何创建自定义的 getter 和 setter，以及这样做的优势是什么？

在 Dart 中，可以使用 get 和 set 关键字创建自定义的 getter 和 setter。它们允许在获取或设置属性时添加额外的逻辑，例如验证或转换。

什么是 Dart 中的 ‘Future’？

Dart 中的 Future 表示在将来某个时间点可用的潜在值（或错误）。它用于异步编程。

‘async’ 和 ‘await’ 关键字的作用是什么？

Dart 中的 async 和 await 关键字用于简化异步编程。它们允许您以更线性的方式编写异步代码，类似于同步代码。

在使用 Dart 时有哪些良好的风格实践？

在 Dart 中的良好风格实践包括使用 camelCase 命名变量和函数，使用 UpperCamelCase 命名类型，并使用 lower_case_with_underscores 命名包。Dart 还建议使用 2 个空格进行缩进。

如何解析 JSON？

Dart 提供了 dart:convert 库中的 jsonDecode 和 jsonEncode 函数，用于解析和生成 JSON。

什么是扩展运算符？

Dart 中的扩展运算符（…）提供了一种简洁的方式将多个元素插入到集合中。Dart 还有一个空感知扩展运算符（…?），仅在集合非空时插入元素。

---

Flutter 小部件（组件）篇

Flutter 小部件是什么？

Flutter 小部件是 Flutter 应用程序中用户界面的构建块。它们定义了应用程序 UI 元素的结构和外观，如按钮、文本字段、图像和容器。

解释有状态小部件和无状态小部件之间的区别

• 无状态小部件是不可变的，没有任何内部状态。它们仅基于提供给它们的输入来渲染 UI。
• 有状态小部件具有可变状态，可以随时间变化。它们可以被多次更新和重建，反映其内部状态的变化。

Flutter 小部件中的 BuildContext 参数有什么作用？

BuildContext 参数表示小部件的当前上下文。它提供对小部件树的访问，并用于执行诸如访问继承的小部件、导航小部件层次结构和构建新小部件等任务。

解释 Flutter 中键（keys）的概念

在 Flutter 中，键（keys）用于唯一标识和区分小部件。它们帮助 Flutter 在小部件树中添加、删除或重新排列小部件时进行识别。

---

Flutter 高级主题

Flutter 渲染是如何工作的，即小部件树是什么？

Flutter 使用三树架构进行渲染：小部件树、元素树和渲染树。小部件树表示 UI，元素树连接小部件树和渲染树，而渲染树处理布局和绘制。

如何创建自定义小部件？

在 Flutter 中，通过组合较小、较简单的小部件或扩展基本小部件类来创建自定义小部件。

如何在 Flutter 中使用扩展方法（extension method）？

在 Dart 中，扩展方法允许您向现有类添加新功能。例如，您可以向 String 类添加一个方法，将字符串解析为整数。

4. 什么是 AOT 和 JIT 以及 Flutter 如何使用它们？

JIT（即时编译） 允许更快的开发周期和热重载。AOT（提前编译） 导致更快的启动时间和更好的生产部署性能。

Flutter 选择使用 Dart 的原因是什么？Dart 的主要特点是什么？

Flutter 使用 Dart，因为它易于学习，具有强大的类型系统，支持 JIT 和 AOT 编译，并具有出色的工具支持。Dart 还具有强大的标准库和良好的异步编程支持。

如何在 Flutter 中使用自定义绘制？

在 Flutter 中，可以通过扩展 CustomPainter 类并实现 paint() 和 shouldRepaint() 方法来进行自定义绘制。

如何为应用程序设置主题？

在 Flutter 中，可以使用 ThemeData 类进行主题设置。您可以将 ThemeData 对象提供给 MaterialApp 小部件，以将主题应用于整个应用程序。

无状态小部件和有状态小部件有什么区别？

无状态小部件是不可变的，它们的状态仅创建一次。有状态小部件具有可变状态，可以随时间变化，并可以多次更新和重建。

有状态小部件的生命周期是什么？

有状态小部件的生命周期包括方法如 createState()、initState()、didChangeDependencies()、build()、didUpdateWidget()、deactivate() 和 dispose()。

什么是 pubspec.yml 文件？

Flutter 项目中的 pubspec.yml 文件用于管理项目的依赖关系和元数据。

调试模式和发布模式之间有什么区别？

在 Flutter 中，调试模式用于调试应用程序，而发布模式保留了一些调试功能，并用于分析应用程序的性能。

什么时候使用 ‘double.infinity’？

当您希望小部件的大小尽可能大，以适应其父级时，可以使用值 ‘double.infinity’。

如何创建在 iOS 和 Android 上外观不同的小部件？

您可以通过使用 Platform.isIOS 或 Theme.of(context).platform 检查当前平台，以在 Flutter 中创建特定于平台的小部件。

如何在 Flutter 中进行 HTTP 请求？

在 Flutter 中，可以使用 http 包进行 HTTP 请求。http.get() 方法可用于发起 GET 请求。

如何使用十六进制颜色？

在 Flutter 中，可以通过使用十六进制颜色代码创建 Color 对象，例如 Color(0xFF000000)。

如何创建带有初始值的 TextField？

在 Flutter 中，可以通过使用 TextEditingController 并设置初始值来创建带有初始值的 TextField。

有没有以编程方式关闭键盘的方法？

在 Flutter 中，可以通过使用 FocusScope.of(context).unfocus() 以编程方式关闭键盘。

向列（Column）中添加 ‘ListView’ 的方式有哪些？

在 Flutter 中，可以通过显式设置 ListView 的高度、在 ListView 上使用 shrinkWrap 属性，或者用 Expanded 封装 ListView 来将 ListView 添加到 Column 中。

文本带有黄色双下划线的原因是什么？

在 Flutter 中，文本带有黄色双下划线通常表示缺少主题实例作为父级。

我们能够使用 SVG 文件作为图像吗？

是的，在 Flutter 中可以使用 flutter_svg 插件将 SVG 文件用作图像。

如何从网络加载图像？

在 Flutter 中，可以使用 Image.network() 构造函数从网络加载图像。

如何以编程方式滚动 ‘ScrollView’ 小部件？

在 Flutter 中，通过创建 ScrollController 并将其分配给 ScrollView，然后调用控制器上的 animateTo 方法来实现编程方式的滚动。

如何重写返回按钮的操作？

在 Flutter 中，可以使用 WillPopScope 小部件来重写返回按钮的操作。

‘ListView’ 小部件上的 ‘reverse’ 属性有什么作用？

在 Flutter 中，‘ListView’ 小部件上的 ‘reverse’ 属性用于以相反的顺序显示列表中的项目。

如何根据屏幕大小设置小部件的大小？

简单：在 Flutter 中，可以使用 MediaQuery.of(context).size 根据屏幕大小设置小部件的大小。

MediaQuery是一个非常有用的类，它提供了对当前屏幕信息的访问，包括屏幕的尺寸、方向等。通过使用MediaQuery的of方法，可以获取到当前BuildContext下的MediaQueryData对象，从而可以获取屏幕的宽度、高度等信息。

更新所有插件的命令是什么？

在 Flutter 项目中，更新所有插件的命令是 flutter pub upgrade。

Flutter 中的树抖动（Tree Shaking）是什么？

简答：在 Flutter 中，树抖动（Tree Shaking）是一个过程，它在构建过程中从应用中删除未使用的代码，从而使应用的大小更小。

在Flutter中，树抖动（Tree Shaking）是指在构建应用程序时通过静态分析和检测，去除未被使用的代码，以减小应用程序的体积。这个过程类似于其他编程语言中的代码消除或无用代码删除，但在Flutter中，特别强调了对整个部件树（Widget Tree）的优化。x

概念理解：

• 部件树（Widget Tree）： 在Flutter中，用户界面由许多小部件（Widgets）组成，这些小部件形成了一个树状结构，称为部件树。每个小部件都代表UI的一部分，包括按钮、文本、图像等。

• 树抖动（Tree Shaking）： 是一个源自JavaScript领域的术语，它在Flutter中指的是通过分析和删除部分未被使用的小部件，以减小应用程序的二进制大小。这是一个在编译时进行的优化过程。

工作原理：

• 静态分析： 在构建Flutter应用程序时，编译器会通过静态分析检查应用程序的代码，识别哪些部件在应用程序中被实际使用，而哪些部件是未使用的。

• 标记未使用的部件： 通过标记未使用的部件，编译器能够识别出不会在运行时被调用的部件。

• 剔除未使用的代码： 一旦标记完成，未使用的部件及其相关的代码就会被从最终的应用程序二进制中剔除，从而减小应用程序的大小。

优势：

• 减小应用程序大小： 移除未使用的代码和部件可以显著减小应用程序的体积。这对于移动应用程序至关重要，因为小型应用更容易下载、安装和加载。

• 提高性能： 较小的应用程序体积可以加快应用程序的启动时间，减少网络传输时间，并提高整体性能。

注意事项：

• 动态代码和反射： 树抖动通常更适用于静态代码，对于通过动态代码生成或使用反射的情况，可能存在一定的限制，因为这些代码在静态分析中难以确定其具体调用关系。

• 避免无用引入： 使用树抖动时，还需要注意避免引入未使用的依赖或库，以确保整个应用程序中没有未使用的代码。

通过树抖动优化，Flutter开发者可以确保构建的应用程序仅包含实际使用的代码，从而提高应用程序的效率和用户体验。

Flutter 实际上是原生的吗？

简答：是的，从技术上讲，Flutter 是原生的，因为它编译为原生的 ARM 和 x86 等库。然而，它提供了一个用于构建 UI 的高级框架，与传统的原生开发不同。

下面是谷歌Flutter官网首页的关于介绍：

可以看到，在Flutter官方网站上有一段标语：“Flutter is an open source framework by Google for building beautiful, natively compiled, multi-platform applications from a single codebase.”

“natively compiled”（原生编译），指的是Flutter应用程序的代码在目标平台上被直接编译为本地机器码，而不是通过解释器执行。这种编译方式使得Flutter应用程序在目标平台上能够以原生应用程序的方式运行，而不需要依赖于中间解释层或虚拟机。

具体来说，当你使用Flutter构建应用程序时，你的Flutter代码会被编译成本地机器码，而不是被转换成中间代码（如Java的字节码）或被解释执行。这种原生地编译的方式有几个关键优势：

1. 性能优越： 由于Flutter应用程序的代码被编译成本地机器码，因此它可以充分利用目标平台的硬件和系统优化，提供更高效的性能。

2. 更接近原生体验： 原生地编译的Flutter应用程序在外观和感觉上与本地应用程序几乎无法区分，提供了更接近原生应用的用户体验。

3. 跨平台一致性： 通过原生地编译，Flutter实现了从单一代码库构建多平台应用程序的目标。这意味着你可以使用相同的代码构建同时运行在iOS和Android等多个平台上的应用程序。

“natively compiled”强调了Flutter在构建跨平台移动应用时所采用的直接编译为本地机器码的方法，以提供高性能和一致的原生用户体验。