flutter中 Future 详细介绍

我来为您详细介绍Flutter中Future的具体用法、使用场景，以及与JavaScript Promise的异同。

Future 基本概念

Future是Dart中表示异步操作结果的对象，类似于JavaScript中的Promise。它代表一个可能在未来某个时间点完成或失败的计算。

Future 基本用法

1. 创建Future

// 1. 使用Future构造函数
Future<String> fetchUserData() {
  return Future(() {
    // 模拟异步操作
    return "用户数据";
  });
}

// 2. 使用Future.delayed（您代码中的用法）
Future.delayed(Duration(seconds: 2), () {
  return "延迟2秒后返回的数据";
});

// 3. 使用Future.value（立即完成的Future）
Future<String> immediateFuture = Future.value("立即完成的值");

2. Future的链式操作

Future<int> fetchNumber() {
  return Future.delayed(Duration(seconds: 1), () => 42);
}

void processFuture() {
  fetchNumber()
    .then((number) {
      print('获取到的数字: $number');
      return number * 2;
    })
    .then((doubled) {
      print('加倍后的数字: $doubled');
      return doubled + 10;
    })
    .then((result) {
      print('最终结果: $result');
    })
    .catchError((error) {
      print('发生错误: $error');
    })
    .whenComplete(() {
      print('操作完成，无论成功或失败都会执行');
    });
}

与JavaScript Promise的异同

相同点：

• 都表示异步操作的结果
• 都支持链式调用（then/catch）
• 都有错误处理机制
• 都可以处理异步操作的成功和失败

不同点：

特性	Dart Future	JavaScript Promise
创建方式	Future(() => value)	new Promise((resolve, reject) => {})
错误处理	catchError()	catch()
最终执行	whenComplete()	finally()
异步等待	await future	await promise
多个操作	Future.wait()	Promise.all()

实际使用案例

案例1：HTTP请求

import 'package:http/http.dart' as http;

Future<void> fetchUserProfile() async {
  try {
    final response = await http.get(Uri.parse('https://api.example.com/user'));
    
    if (response.statusCode == 200) {
      print('用户数据: ${response.body}');
    } else {
      throw Exception('请求失败: ${response.statusCode}');
    }
  } catch (e) {
    print('网络请求错误: $e');
  }
}

// 使用then的等价写法
void fetchUserProfileWithThen() {
  http.get(Uri.parse('https://api.example.com/user'))
    .then((response) {
      if (response.statusCode == 200) {
        print('用户数据: ${response.body}');
      } else {
        throw Exception('请求失败: ${response.statusCode}');
      }
    })
    .catchError((error) {
      print('网络请求错误: $error');
    });
}

案例2：文件操作

import 'dart:io';

Future<void> readFileContent() async {
  final file = File('path/to/file.txt');
  
  try {
    final contents = await file.readAsString();
    print('文件内容: $contents');
  } catch (e) {
    print('读取文件错误: $e');
  }
}

案例3：多个Future并行处理

Future<void> fetchMultipleData() async {
  final future1 = http.get(Uri.parse('https://api.example.com/users'));
  final future2 = http.get(Uri.parse('https://api.example.com/posts'));
  final future3 = http.get(Uri.parse('https://api.example.com/comments'));
  
  try {
    final results = await Future.wait([future1, future2, future3]);
    
    print('用户数据: ${results[0].body}');
    print('帖子数据: ${results[1].body}');
    print('评论数据: ${results[2].body}');
  } catch (e) {
    print('部分请求失败: $e');
  }
}

案例4：超时控制

Future<void> fetchWithTimeout() async {
  final future = http.get(Uri.parse('https://api.example.com/slow'));
  
  try {
    final response = await future.timeout(Duration(seconds: 5));
    print('请求成功: ${response.body}');
  } on TimeoutException {
    print('请求超时');
  } catch (e) {
    print('其他错误: $e');
  }
}

案例5：在Flutter Widget中使用FutureBuilder

class UserProfileWidget extends StatelessWidget {
  final Future<User> userFuture;
  
  UserProfileWidget({required this.userFuture});
  
  @override
  Widget build(BuildContext context) {
    return FutureBuilder<User>(
      future: userFuture,
      builder: (context, snapshot) {
        if (snapshot.connectionState == ConnectionState.waiting) {
          return CircularProgressIndicator();
        } else if (snapshot.hasError) {
          return Text('错误: ${snapshot.error}');
        } else if (snapshot.hasData) {
          return Text('用户名: ${snapshot.data!.name}');
        } else {
          return Text('暂无数据');
        }
      },
    );
  }
}

您代码中Future用法的解释

基于您提供的代码片段：

Future.delayed(Duration(seconds: 2), () {
  print('Response status: ${response.statusCode}');
  print('Response body: ${response.body}');
  return 100;
})
.then((value) {
  print('value: $value');
})
.whenComplete(() {
  print('whenComplete');
});

这个代码的含义是：

1. 延迟2秒执行异步操作
2. 打印响应状态和内容，返回数字100
3. 通过then处理返回的值
4. 无论成功或失败，最后都会执行whenComplete

Future与Stream的区别

• Future：表示单个异步操作的结果（一次性）
• Stream：表示一系列异步事件的序列（多次）

// Future - 一次性
Future<int> getSingleValue() async {
  return 42;
}

// Stream - 多次
Stream<int> getMultipleValues() async* {
  for (int i = 0; i < 5; i++) {
    yield i;
    await Future.delayed(Duration(seconds: 1));
  }
}

Future是Flutter异步编程的核心概念，熟练掌握它的使用对于开发高质量的Flutter应用至关重要。