1..2..3... The Future Race

Getting the Fastest Answer in Flutter

Ever been in a situation where your app needs data, and you've got a few different places to get it from? Maybe multiple servers, different caches, or even a mix of local and remote sources. The cool part is, you don't always need all the answers – sometimes, the first one that comes back is all you need to keep things moving.

What is Future.any?

This is where Future.any in Flutter comes in super handy! Think of it like a race: you start several tasks (or 'Futures') at the same time, but you're only waiting for the very first one to finish. As soon as one of them completes with a result, Future.any completes with that result, and you can carry on.

It's great for making your app feel snappy because you're not waiting around for every single task to finish if you only need one successful outcome. Plus, you can even put different kinds of Futures in there!

How to Use Future.any (A Quick Example)

Let's look at a simple example where we try to fetch data from two different sources. We just want the data from whichever source responds first.

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

void main() async {
  try {
    // We're racing to get a post from SERVER_1 or SERVER_2
    String postContent = await Future.any([
      getPost('https://api.server1.com/post/1'), // Imagine SERVER_1 URL
      getPost('https://api.server2.com/post/1'), // Imagine SERVER_2 URL
    ]);
    print('Received post content: $postContent');
  } catch (e) {
    print('Failed to get any post: $e');
  }
}

Future<String> getPost(String url) async {
  final response = await http.get(Uri.parse(url));
  if (response.statusCode == 200) {
    return response.body; // Success!
  } else {
    // If a server responds with an error, we throw an Exception
    throw Exception('Failed to load post from $url with status ${response.statusCode}');
  }
}

In this code, Future.any will return the content from the source that replies successfully first.

Important: Handling Errors with Future.any

Here's a crucial tip to remember: if the first Future to complete actually finishes with an error (like a network timeout or a bad response), then Future.any will also complete with that error. It won't wait for other Futures that might succeed later.

To make your Future.any more robust, especially if you expect some failures but still want the first successful result, you might need to handle errors within each individual Future. For example, you could wrap each Future with a try-catch block and return a Future.value(null) or a specific error object if it fails, allowing Future.any to potentially wait for another Future to succeed. The example above shows a basic try-catch around Future.any itself, which catches the first error that surfaces.

Boost Your App's Responsiveness

Using Future.any is a smart way to improve your app's performance and responsiveness. By only waiting for the quickest successful outcome, you can often display content faster to your users, leading to a much better experience.