Dart Future

last modified January 1, 2021

Dart Future tutorial shows how to work with futures in Dart language.

Future

A Future represents a potential value, or error, that will be available at some time in the future.

A Future can be complete with a value or with an error. Programmers can plug callbacks for each case. Futures and async and await keywords are used to perform asynchronous operations in Dart.

Common asynchronous operations include:

• fetching data over network
• reading data from a database
• reading data from a file
• performing a long-running task in a UI program

The async and await keywords provide a declarative way to define asynchronous functions and use their results. We mark an asynchronous function with the async keyword. The await keyword is used to get the completed result of an asynchronous expression. The await keyword only works within an asynchronous function.

Dart future simple example

The Future.value creates a future completed with value.

void main() async {
  var myfut1 = Future.value(14);
  print(myfut1);

  var myfut2 = await Future.value(14);
  print(myfut2);
}

In the example, we have two futures.

void main() async {

Since in the main function we work with futures, we mark it with the async keyword.

var myfut1 = Future.value(14);
print(myfut1);

This code is incorrect; we create a new future with Future.value and print the result, which is an uncompleted instance of the future. In order to get the value, we need to use the await keyword.

var myfut2 = await Future.value(14);
print(myfut2);

We create another future and wait for its result with the await keyword.

$ dart simple.dart 
Instance of 'Future<int>'
14  

Dart Future.delayed

The Future.delayed creates a future that runs its computation after a delay.

void main() async {
  Future.delayed(Duration(seconds: 2), () => 12).then((value) => print(value));

  final res = await Future.delayed(Duration(seconds: 2), () => 14);
  print(res);
}

The example creates two delayed futures.

Future.delayed(Duration(seconds: 2), () => 12).then((value) => print(value));

We create a future which is executed after two seconds; it returns value 12. With then, we register a callback when the future completes. It prints the returned value to the console.

final res = await Future.delayed(Duration(seconds: 2), () => 14);
print(res);

The same functionality is performed; this time using the await keyword.

$ dart delayed.dart 
12
14

Dart read file with readAsString

The readAsString function reads the entire file contents as a string asynchronously. It returns a Future<String> that completes with the string once the file contents has been read.

bear
fruit
cloud
sky
forest
falcon
wood
lake
rock

This is the words.txt file.

import 'dart:io';

void main() async {
  var file = File('words.txt');

  var contents = await file.readAsString();
  print(contents);
}

The example reads the words.txt file asynchronously.

Dart Future.wait

The Future.wait waits for multiple futures to complete and collects their results. It returns a future which completes once all the given futures have completed.

import 'dart:async';
import 'dart:math';

Future<int> getRandomValue() async {
  await Future.delayed(Duration(seconds: 1));
  var random = new Random();
  return random.nextInt(150);
}

int findMinVal(List<int> lst) {
  lst.forEach((e) => print(e));

  return lst.reduce(max);
}

void main() async {
  final maximum = await Future.wait([
    getRandomValue(),
    getRandomValue(),
    getRandomValue(),
    getRandomValue(),
    getRandomValue(),
    getRandomValue()
  ]).then((List<int> results) => findMinVal(results));

  print('Maximum is : $maximum');
}

In the example, we have an asynchronous getRandomValue method, which returns a random value. We launch the method six times and place them all inside Future.wait. Once all the futures are completed, we find the maximum of the generated random values.

$ dart future_wait.dart 
94
13
106
41
110
122
Maximum is : 122

Dart future get request

The http is a composable, Future-based library for making HTTP requests.

dependencies:
  http: ^0.12.2

We add the library to our dependencies.

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

Future<String> fetchData() async {
  final response = await http.get('http://webcode.me');

  if (response.statusCode == 200) {
    return response.body;
  } else {
    throw Exception('Failed to fetch data');
  }
}

void main() async {
  var data = await fetchData();
  print(data);
}

In the example, we send a GET request to the webcode.me and print the response body.

$ dart get_req.dart 
<!DOCTYPE html>
<html lang="en">
<head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <title>My html page</title>
</head>
<body>

     <p>
          Today is a beautiful day. We go swimming and fishing.
     </p>
     
     <p>
          Hello there. How are you?
     </p>
     
</body>
</html>

In this tutorial, we have worked with futures in Dart.

List all Dart tutorials.