Dart While Loop

Mastering Dart while loop | A Comprehensive Guide

Introduction:
In Dart, a while loop is a control flow statement that executes a block of code repeatedly as long as a specified condition evaluates to true.

The syntax for a while loop in Dart is:

dart

while (condition) {
// Code to execute while the condition is true
}

Here, condition is a boolean expression that determines whether the loop should continue executing. The loop will continue executing the code block as long as the condition evaluates to true. Once the condition becomes false, the loop terminates, and the program continues with the code following the loop.

Here’s a simple example of a while loop in Dart:

dart

void main() {
int count = 0;

while (count < 5) {
print('Count: $count');
count++;
}
}

• In this example, the loop will execute as long as the value of count is less than 5.
• Inside the loop, the value of count is printed, and then it is incremented by 1 (count++).
• The loop will terminate when count reaches 5.

Output:

Count: 0
Count: 1
Count: 2
Count: 3
Count: 4

It’s important to ensure that the condition in a while loop eventually becomes false; otherwise, the loop will run indefinitely, causing a program to hang or crash.

Here are some additional points about while loops in Dart:

Loop Initialization: Unlike some programming languages like C or C++, Dart does not allow loop initialization directly within the while loop syntax. Instead, you typically initialize loop variables before the while loop.

dart

void main() {
int count = 0; // Initialization
while (count < 5) {
print('Count: $count');
count++;
}
}

Explanation

Condition Evaluation: The condition in a while loop is evaluated before each iteration of the loop. If the condition evaluates to false initially, the loop body will not execute at all.

Loop Body: The block of code inside the while loop is executed repeatedly as long as the condition evaluates to true. This block can contain any valid Dart statements, including nested loops, conditional statements, function calls, etc.

Exiting the Loop: To exit a while loop prematurely, you can use the break statement. This statement immediately terminates the loop, and the program continues executing the code after the loop.

dart

void main() {
int count = 0;
while (true) {
print('Count: $count');
count++;
if (count >= 5) {
break; // Exit the loop when count reaches 5
}
}
}

Loop Control: You can also use the continue statement to skip the rest of the current iteration and move to the next iteration of the loop.

dart

void main() {
int count = 0;
while (count < 5) {
count++;
if (count == 3) {
continue; // Skip printing when count is 3
}
print('Count: $count');
}
}

Infinite Loops: Be cautious when writing while loops to avoid creating infinite loops unintentionally. An infinite loop occurs when the condition always evaluates to true, causing the loop to continue indefinitely.

Ensure that the condition eventually becomes false to exit the loop.

dart

void main() {
while (true) {
print('This is an infinite loop!');
}
}

These are some fundamental aspects of while loops in Dart that you can use to control the flow of your programs effectively.

Here are a few advanced concepts and tips related to using while loops in Dart:

Loop Guards:

• While loops are commonly used when the number of iterations is not known in advance.
• However, it’s crucial to have a termination condition to prevent infinite loops.
• You can use loop guards, such as counters or flags, to ensure that the loop terminates eventually.

dart

void main() {
int count = 0;
bool condition = true;
while (condition && count < 5) {
print('Count: $count');
count++;
if (count == 3) {
condition = false; // Set condition to false to terminate the loop
}
}
}

Do-While Loop:

Dart also supports a variant of the while loop called the do-while loop. In a do-while loop, the loop body is executed at least once before the condition is evaluated.

The syntax is as follows:

dart

void main() {
int count = 0;
do {
print('Count: $count');
count++;
} while (count < 5);
}

Looping with Collections:

While loops can be used to iterate over collections manually, but Dart provides concise ways to iterate over lists, sets, maps, and other collections using for loops or higher-order functions like forEach.

dart

void main() {
List<int> numbers = [1, 2, 3, 4, 5];
int index = 0;
while (index < numbers.length) {
print('Number: ${numbers[index]}');
index++;
}
}

Performance Considerations: While loops are efficient for basic looping tasks, but for iterating over collections, using higher-order functions like forEach, map, or fold can lead to concise and potentially optimized code.

Nested While Loops:

You can nest while loops inside each other to perform complex iterations. However, be mindful of the readability and complexity of your code when nesting loops.

Looping with Stream Subscriptions:

While loops can be useful for handling asynchronous events, such as with Dart streams. You can use a while loop to continuously listen for events from a stream until a certain condition is met.

Performance Considerations: complete example 

• Let’s create a complete example demonstrating the performance considerations when using while loops compared to higher-order functions for iterating over collections in Dart.
• Suppose we have a list of integers, and we want to calculate the sum of all the numbers in the list. We’ll implement two versions of the code:
• Using a while loop to iterate over the list and calculate the sum.
• Using the higher-order function forEach for iterating over the list and calculating the sum.
  We’ll then compare the performance of both approaches.

dart

import 'dart:math';

void main() {
// Generating a large list of random integers
final List<int> numbers = List.generate(1000000, (_) => Random().nextInt(100));

// Using a while loop to calculate the sum
int sum = calculateSumWithWhileLoop(numbers);
print('Sum calculated with while loop: $sum');

// Using forEach to calculate the sum
sum = calculateSumWithForEach(numbers);
print('Sum calculated with forEach: $sum');
}

// Function to calculate the sum using a while loop
int calculateSumWithWhileLoop(List<int> numbers) {
int sum = 0;
int index = 0;
while (index < numbers.length) {
sum += numbers[index];
index++;
}
return sum;
}

// Function to calculate the sum using forEach
int calculateSumWithForEach(List<int> numbers) {
int sum = 0;
numbers.forEach((number) {
sum += number;
});
return sum;
}

Explanation:

Generating Random Numbers: We generate a large list (numbers) containing one million random integers between 0 and 99 using List.generate and Random().nextInt(100).

calculateSumWithWhileLoop: This function calculates the sum of the elements in the list using a while loop. It initializes sum to 0 and iterates over the list using a while loop until the end of the list, adding each element to the sum.

calculateSumWithForEach: This function calculates the sum of the elements in the list using the higher-order function forEach. It initializes sum to 0 and iterates over each element in the list using forEach, adding each element to the sum.

Performance Comparison: We call both functions and measure their execution time. While Dart doesn’t provide built-in profiling tools in the standard library, you can use external tools or measure execution time manually using DateTime.now() before and after the function calls.

By running this example, you’ll observe that both approaches yield the same result, but using forEach is generally concise and idiomatic in Dart. Additionally, higher-order functions often provide better performance optimizations compared to manually written loops, especially when dealing with complex collections or operations.

Nested While Loops:complete exam[ple 

Let’s create a complete example demonstrating nested while loops in Dart. In this example, we’ll use nested while loops to generate a multiplication table from 1 to 10.

dart

void main() {
// Outer loop to iterate over the numbers from 1 to 10
int i = 1;
while (i <= 10) {
// Inner loop to generate the multiplication table for the current number
int j = 1;
while (j <= 10) {
// Multiply i by j and print the result
int result = i * j;
print('$i * $j = $result');
j++; // Increment j for the next iteration
}
print(''); // Empty line to separate each multiplication table
i++; // Increment i for the next multiplication table
}
}

Explanation:

Outer Loop (i): The outer loop iterates over the numbers from 1 to 10. It initializes i to 1 and continues looping until i is no longer less than or equal to 10.

Inner Loop (j): Inside the outer loop, there’s an inner loop that also iterates from 1 to 10. It initializes j to 1 and continues looping until j is no longer less than or equal to 10.

Multiplication Operation: Inside the inner loop, we perform the multiplication operation i * j to generate the product of the current i and j values. We then print the multiplication expression along with the result.

Incrementing Counters: After each iteration of the inner loop, we increment the j counter to move to the next number in the multiplication table. Similarly, after each complete iteration of the outer loop (i.e., after printing the multiplication table for a specific number), we increment the i counter to move to the next number for which we want to generate a multiplication table.

Output Formatting: We print an empty line after each complete multiplication table to separate them visually for better readability.

When you run this program, it will output the multiplication table for each number from 1 to 10. Each multiplication table will be printed with its corresponding multiplication expressions and results. This demonstrates how nested while loops can be used to generate structured output and perform repetitive tasks efficiently.

Looping with Stream Subscriptions: complete example 

In Dart, streams are a way to handle asynchronous events and data sequences. They can emit multiple values over time, and you can subscribe to them to listen for these values.

Here’s an example demonstrating looping with stream subscriptions:

dart

import 'dart:async';

void main() {
// Creating a stream controller to emit integers
final StreamController<int> controller = StreamController<int>();

// Adding an event listener to the stream
final StreamSubscription<int> subscription =
controller.stream.listen((int value) {
print('Received value: $value');
});

// Adding integers to the stream
for (int i = 1; i <= 5; i++) {
controller.add(i);
}

// Closing the stream after adding all values
controller.close();

// Canceling the subscription when done
subscription.cancel();
}

Explanation:

StreamController: We create a StreamController<int> named controller to manage the stream. Stream controllers provide methods for adding data to the stream and closing the stream when done.

StreamSubscription: We create a StreamSubscription<int> named subscription to listen for events emitted by the stream. The listen method is called on controller.stream to subscribe to the stream, and the provided callback function is invoked whenever a new event is emitted.

Adding Values to the Stream: We use a for loop to add integers from 1 to 5 to the stream using the add method of the stream controller. Each value added to the stream triggers the callback function provided to the listen method.

Closing the Stream: After adding all the values, we close the stream using the close method of the stream controller. This indicates that no events will be added to the stream.

Canceling the Subscription: Finally, we cancel the subscription using the cancel method of the stream subscription. This step is important to release resources and prevent memory leaks once we’re done listening to the stream.

When you run this program, it will output:

Received value: 1
Received value: 2
Received value: 3
Received value: 4
Received value: 5

This demonstrates how to use stream subscriptions to listen for events emitted by a stream and perform actions accordingly.

An application about this lesson wioth explanation

Let’s create a simple Dart console application that demonstrates the concept of stream subscriptions by simulating a weather station that emits temperature readings every second. We’ll subscribe to these temperature readings and display them in real-time.

Here’s the code with explanations:

dart

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

void main() {
// Create a stream controller for temperature readings
final StreamController<double> temperatureController = StreamController<double>();

// Subscribe to temperature readings
final StreamSubscription<double> subscription = temperatureController.stream.listen((double temperature) {
print('Current temperature: ${temperature.toStringAsFixed(2)}°C');
});

// Simulate temperature readings every second
simulateTemperatureReadings(temperatureController);

// Wait for 10 seconds, then cancel subscription
Future.delayed(Duration(seconds: 10), () {
print('Subscription canceled after 10 seconds.');
subscription.cancel();
temperatureController.close();
});
}

void simulateTemperatureReadings(StreamController<double> controller) {
// Generate random temperature readings between 0 and 40 degrees Celsius
final Random random = Random();
Timer.periodic(Duration(seconds: 1), (Timer timer) {
final double temperature = 20 + random.nextDouble() * 20; // Random temperature between 20 and 40
controller.add(temperature);
});
}

Explanation:

StreamController: We create a StreamController<double> named temperatureController to manage the stream of temperature readings. This controller provides methods for adding data to the stream (add) and closing the stream (close).

StreamSubscription: We subscribe to temperature readings using temperatureController.stream.listen. Whenever a new temperature reading is emitted by the stream, the provided callback function is invoked to display the current temperature.

Simulating Temperature Readings: The simulateTemperatureReadings function generates random temperature readings between 20 and 40 degrees Celsius every second using a Timer.periodic function. It adds these readings to the stream via the stream controller.

Canceling Subscription: After 10 seconds (Future.delayed(Duration(seconds: 10))), we cancel the subscription and close the stream to release resources. This step ensures that we stop listening to temperature readings after a certain period.

When you run this application, you’ll see the current temperature readings displayed in the console approximately every second. After 10 seconds, the subscription is canceled, and the program exits. This demonstrates how to use stream subscriptions to listen for and react to asynchronous events in Dart applications, such as temperature readings from a weather station.

Quiz about this lesson:15 questions with explanation

Here’s a quiz about streams and subscriptions in Dart. Each question is followed by an explanation of the correct answer.

1-What is a stream in Dart?

A. A sequence of asynchronous events.
B. A collection of synchronous data.
C. A way to perform network requests.
D. A data structure for storing key-value pairs.
Correct Answer: A. A stream in Dart represents a sequence of asynchronous events. It allows you to handle asynchronous data flow and react to events as they occur.

2-Which Dart library provides classes for working with streams and stream controllers?

A. dart:async
B. dart:io
C. dart:core
D. dart:math
Correct Answer: A. The dart:async library provides classes like Stream, StreamController, and StreamSubscription for working with streams and stream-based asynchronous programming.

3-What does a stream controller do in Dart?

A. Controls the temperature of a stream.
B. Manages the flow of events in a stream.
C. Performs network requests asynchronously.
D. Executes mathematical calculations on stream data.
Correct Answer: B. A stream controller in Dart manages the flow of events in a stream. It allows you to add events to the stream and control its subscription.

4-How do you subscribe to a stream in Dart?

A. Using the subscribe method.
B. Using the listen method.
C. Using the add method.
D. Using the onData method.
Correct Answer: B. You subscribe to a stream in Dart using the listen method. This method takes a callback function that is invoked whenever a new event is emitted by the stream.

5-What method is used to add events to a stream controller in Dart?

A. addEvent
B. emit
C. dispatch
D. add
Correct Answer: D. The add method is used to add events to a stream controller in Dart. It allows you to add new data or events to the stream.

6-Which function is used to cancel a stream subscription in Dart?

A. stop
B. end
C. cancel
D. close
Correct Answer: C. The cancel method is used to cancel a stream subscription in Dart. It releases the resources associated with the subscription.

7-How can you create a stream that emits periodic events in Dart?

A. Using a for loop.
B. Using the Timer class.
C. Using the Future class.
D. Using the async keyword.
Correct Answer: B. You can create a stream that emits periodic events in Dart using the Timer class. This class allows you to schedule periodic or one-time events.

8-What is the purpose of the close method in a stream controller?

A. To open the stream.
B. To close the stream and release associated resources.
C. To add events to the stream.
D. To subscribe to the stream.
Correct Answer: B. The close method in a stream controller is used to close the stream and release associated resources. Once a stream is closed, no events can be added to it.

9-Which of the following statements about stream subscriptions is true?

A. A subscription cannot be canceled once it’s created.
B. Multiple subscribers can listen to the same stream independently.
C. A subscription automatically cancels itself after a certain period.
D. A subscription requires explicit closing to release resources.
Correct Answer: D. A subscription in Dart requires explicit closing using the cancel method to release resources associated with it. This helps prevent memory leaks.

10-How do you handle errors in a stream subscription callback in Dart?

A. By catching exceptions with a try-catch block.
B. By using the onError method of the stream.
C. By logging errors to the console.
D. Errors cannot be handled in a stream subscription callback.
Correct Answer: B. You can handle errors in a stream subscription callback in Dart by providing an onError parameter to the listen method. This parameter specifies a callback function that is invoked when an error occurs in the stream.

11-What does the StreamSubscription class represent in Dart?

A. A stream controller.
B. A single event in a stream.
C. A subscription to a stream.
D. A buffer for storing stream data.
Correct Answer: C. The StreamSubscription class in Dart represents a subscription to a stream. It allows you to control and manage the subscription, including canceling it.

12-Which of the following is NOT a method of the Stream class in Dart?

A. listen
B. add
C. cancel
D. transform
Correct Answer: C. The cancel method is not a method of the Stream class. It is a method of the StreamSubscription class used to cancel a subscription.

13-When is the listen method called on a stream in Dart?

A. To add events to the stream.
B. To close the stream.
C. To subscribe to the stream and start receiving events.
D. To cancel the subscription to the stream.
Correct Answer: C. The listen method is called on a stream in Dart to subscribe to the stream and start receiving events. It takes a callback function as a parameter to handle the events emitted by the stream.

14-Which Dart library is used for working with asynchronous operations and futures?

A. dart:async
B. dart:io
C. dart:core
D. dart:async
Correct Answer: D. The dart:async library is used for working with asynchronous operations and futures in Dart. It provides classes and utilities for managing asynchronous code.

15-What is the primary purpose of streams and stream subscriptions in Dart?

A. To handle network requests.
B. To work with interface elements.
C. To manage asynchronous events and data flow.
D. To perform mathematical calculations.
Correct Answer: C. The primary purpose of streams and stream subscriptions in Dart is t

رابط الدرس باللغة العربية