Dart中Streams是什么？async与Streams的区别及适用场景

Hey there! Let's tackle your questions about Dart's Streams and async/await clearly—these are super common points of confusion when diving into Dart's async programming.

1. What are Streams in Dart? #

First off, as the official docs state:

Streams represent a sequence of data.

Put simply, Streams are Dart’s way of handling asynchronous sequences of data. Unlike a single async operation that gives you one result, a Stream can emit multiple values, events, or errors over time. Think of it like a pipe that keeps sending chunks of data until it’s done—perfect for scenarios where data arrives in pieces, not all at once.

Common use cases for Streams include:

• Repeating user interactions (button taps, text input changes)
• Chunked network transfers (downloading large files, WebSocket messages)
• Periodic data updates (like fetching live weather every minute)
• Real-time feeds (sensor readings, chat app messages)

Here’s a quick example of a basic Stream that emits a number every second, stopping after 3 emissions:

// Create a Stream that sends a number every 1 second, limited to 3 items
final numberStream = Stream.periodic(const Duration(seconds: 1), (count) => count).take(3);

// Listen to the Stream to handle each emitted value
numberStream.listen((data) {
  print('Got value: $data');
});

Run this, and you’ll see Got value: 0, Got value: 1, Got value: 2 printed one second apart—this is the "sequence of data" the docs refer to in action.

2. Difference between async/await and Streams, and when to use Streams instead #

Let’s break this into core differences and practical use cases for choosing Streams over async/await.

Core Differences #

• Return Type & Purpose:
  • Async functions marked with async return a Future<T>, which represents a single asynchronous result. You use await to pause execution until that one result is ready.
  • Streams are Stream<T>, which represent a continuous flow of asynchronous values, events, or errors.
• Data Flow:
  • Async/await is one-time: you ask for something, wait for it, and get one result.
  • Streams are ongoing: they can keep sending data as long as needed, and you handle events as they arrive.

When to Use Streams Instead of Async/Await #

Reach for Streams whenever you’re dealing with multiple asynchronous events rather than a single one. Specific scenarios include:

• Tracking repeated user input: For example, listening to every keystroke in a text field or every tap on a button—async/await can’t handle these repeated, ongoing events.
• Processing large data in chunks: When reading a huge file or downloading a large asset, you don’t want to wait for the entire thing to load. Streams let you process each chunk as it arrives.
• Real-time updates: If you’re getting live data (stock prices, sensor readings, chat messages) that updates regularly, Streams handle the continuous flow naturally.
• Multi-step async pipelines: When you have a series of async operations that emit results along the way (like transforming data in stages), Streams simplify the workflow.

Example Comparison

Here’s how async/await works for a single async task (reading a small file all at once):

Future<String> readSmallTextFile() async {
  final file = File('small_notes.txt');
  // Wait for the entire file to be read, then return the single string result
  return await file.readAsString();
}

And here’s how Streams handle a large file by reading it in chunks:

Stream<List<int>> readLargeFileInChunks() {
  final file = File('big_dataset.csv');
  // Return a Stream that emits chunks of bytes as they're read
  return file.openRead();
}

// Process each chunk as it arrives
readLargeFileInChunks().listen((chunk) {
  print('Processed ${chunk.length} bytes of the file');
});

内容的提问来源于stack exchange，提问作者Lakhwinder Singh