Flutter异步处理插件promise的使用

Flutter异步处理插件promise的使用

特性

本插件提供了以下功能：

  • Promise.run
  • Promise.resolve
  • Promise.reject

开始使用

要将此包添加到您的项目中，请运行以下命令：

flutter pub add promise

使用方法

以下是一个简单的示例，展示了如何在你的项目中使用Promise。

示例代码

import 'package:promise/promise.dart';

void main() {
  // 创建一个新的Promise对象，并立即解析它
  final promise = Promise.run((resolve, reject) {
    resolve(3); // 解析Promise，传递值3
  });

  // 当Promise被解析后执行的操作
  promise.then((value) {
    print('Promise resolved with value: $value'); // 输出：Promise resolved with value: 3
  });

  // 如果Promise被拒绝，可以使用catch操作来捕获错误
  final rejectedPromise = Promise.reject('An error occurred');

  rejectedPromise.catchError((error) {
    print('Promise rejected with error: $error'); // 输出：Promise rejected with error: An error occurred
  });
}

完整示例Demo

假设你有一个需要异步处理的任务，例如从网络获取数据。下面是一个完整的示例，展示如何使用Promise来处理这种情况。

步骤 1: 添加依赖

在你的pubspec.yaml文件中添加promise依赖：

dependencies:
  flutter:
    sdk: flutter
  promise: ^0.1.0 # 请根据实际版本号进行调整

步骤 2: 编写异步任务代码

import 'package:flutter/material.dart';
import 'package:promise/promise.dart';

void main() => runApp(MyApp());

class MyApp extends StatelessWidget {
  [@override](/user/override)
  Widget build(BuildContext context) {
    return MaterialApp(
      home: Scaffold(
        appBar: AppBar(title: Text("Promise Example")),
        body: Center(child: FuturePromiseExample()),
      ),
    );
  }
}

class FuturePromiseExample extends StatefulWidget {
  [@override](/user/override)
  _FuturePromiseExampleState createState() => _FuturePromiseExampleState();
}

class _FuturePromiseExampleState extends State<FuturePromiseExample> {
  String _result = "Loading...";

  [@override](/user/override)
  void initState() {
    super.initState();
    fetchData().then((value) {
      setState(() {
        _result = value;
      });
    }).catchError((error) {
      setState(() {
        _result = "Failed to load data: $error";
      });
    });
  }

  Future<String> fetchData() async {
    // 模拟网络请求
    await Future.delayed(Duration(seconds: 2));
    return "Data fetched successfully";
  }

  [@override](/user/override)
  Widget build(BuildContext context) {
    return Text(_result, style: TextStyle(fontSize: 20));
  }
}

更多关于Flutter异步处理插件promise的使用的实战教程也可以访问 https://www.itying.com/category-92-b0.html

1 回复

更多关于Flutter异步处理插件promise的使用的实战系列教程也可以访问 https://www.itying.com/category-92-b0.html


在 Flutter 中，Future 是用于处理异步操作的主要方式，类似于 JavaScript 中的 Promise。Flutter 本身并没有直接使用 Promise 这个概念，但你可以使用 Future 来实现类似的异步处理。

1. 基本用法

Future 表示一个可能在未来某个时刻完成的计算。你可以使用 then 方法来处理 Future 完成时的结果，使用 catchError 来处理错误。

Future<String> fetchData() async {
  // 模拟一个异步操作
  await Future.delayed(Duration(seconds: 2));
  return "Data fetched!";
}

void main() {
  fetchData().then((value) {
    print(value); // 输出: Data fetched!
  }).catchError((error) {
    print("Error: $error");
  });
}

2. 使用 async 和 await

async 和 await 关键字使得异步代码看起来像同步代码一样简洁。await 会暂停函数的执行，直到 Future 完成。

Future<void> fetchData() async {
  try {
    String data = await fetchData();
    print(data); // 输出: Data fetched!
  } catch (error) {
    print("Error: $error");
  }
}

void main() {
  fetchData();
}

3. 结合 Future 和 Stream

如果你需要处理一系列异步事件，可以使用 Stream。Stream 类似于 Future，但它可以发出多个值。

Stream<int> countStream(int max) async* {
  for (int i = 1; i <= max; i++) {
    await Future.delayed(Duration(seconds: 1));
    yield i;
  }
}

void main() {
  countStream(5).listen((int value) {
    print("Count: $value");
  });
}

4. 使用 FutureBuilder 和 StreamBuilder

在 Flutter 中，FutureBuilder 和 StreamBuilder 是常用的 Widget，用于在 UI 中处理异步数据。

import 'package:flutter/material.dart';

Future<String> fetchData() async {
  await Future.delayed(Duration(seconds: 2));
  return "Data fetched!";
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: Scaffold(
        appBar: AppBar(title: Text('FutureBuilder Example')),
        body: FutureBuilder<String>(
          future: fetchData(),
          builder: (context, snapshot) {
            if (snapshot.connectionState == ConnectionState.waiting) {
              return Center(child: CircularProgressIndicator());
            } else if (snapshot.hasError) {
              return Center(child: Text("Error: ${snapshot.error}"));
            } else {
              return Center(child: Text("Data: ${snapshot.data}"));
            }
          },
        ),
      ),
    );
  }
}

void main() => runApp(MyApp());

5. 处理多个 Future

你可以使用 Future.wait 来等待多个 Future 完成。

Future<void> fetchMultipleData() async {
  List<Future<String>> futures = [
    fetchData(),
    fetchData(),
    fetchData(),
  ];

  List<String> results = await Future.wait(futures);
  print(results); // 输出: [Data fetched!, Data fetched!, Data fetched!]
}

void main() {
  fetchMultipleData();
}

6. 自定义 Future

你也可以手动创建 Future，并根据需要完成或抛出错误。

Future<String> customFuture(bool shouldFail) {
  Completer<String> completer = Completer();

  Future.delayed(Duration(seconds: 2), () {
    if (shouldFail) {
      completer.completeError("Custom error");
    } else {
      completer.complete("Custom success");
    }
  });

  return completer.future;
}

void main() {
  customFuture(false).then((value) {
    print(value); // 输出: Custom success
  }).catchError((error) {
    print("Error: $error"); // 如果 shouldFail 为 true，输出: Error: Custom error
  });
}
回到顶部