# Deeper into Dart

Dart is a rich language with many features. As we delve deeper, we'll cover some key concepts that will help you write more efficient and maintainable Flutter apps.

## 1. Async/Await and Futures 🕒

Dart has built-in support for asynchronous programming, which is crucial for IO-bound work like loading files or making network requests.

```dart
Future<String> fetchUserData() {
  // Simulate a network request
  return Future.delayed(Duration(seconds: 2), () => 'User Data');
}

void getUserData() async {
  String userData = await fetchUserData();
  print(userData);  // Prints: User Data
}
```

## 2. Streams 🌊

Streams provide a way to respond to a series of data over time, like user input or a file being read.

```dart
Stream<int> countStream(int max) async* {
  for (int i = 1; i <= max; i++) {
    yield i;  // Pauses execution, returns the value, then continues from here when resumed
    await Future.delayed(Duration(seconds: 1));
  }
}

void listenToStream() {
  countStream(5).listen((int value) {
    print(value);  // Prints 1, 2, 3, 4, 5 (each on a new line, once per second)
  });
}
```

## 3. Collections (List, Set, Map) 🗂️

Dart has powerful collection types like Lists, Sets, and Maps.

```dart
// List
List<String> fruits = ['apple', 'banana', 'cherry'];
fruits.add('date');

// Set
Set<String> colors = {'red', 'green', 'blue'};
colors.add('yellow');

// Map
Map<String, int> ages = {
  'Alice': 30,
  'Bob': 25,
};
ages['Charlie'] = 35;
```

## 4. Error Handling 🛑

Handle errors gracefully using try-catch blocks.

```dart
void mightFail() {
  throw ('This function throws an error!');
}

void handleError() {
  try {
    mightFail();
  } catch (e) {
    print('Error: $e');
  }
}
```

## 5. Custom Classes and OOP 🧩

Leverage Object-Oriented Programming (OOP) principles to create custom classes.

```dart
class Person {
  String name;
  int age;

  Person(this.name, this.age);

  void greet() {
    print('Hello, my name is $name and I am $age years old.');
  }
}

void createPerson() {
  Person person = Person('Alice', 30);
  person.greet();  // Prints: Hello, my name is Alice and I am 30 years old.
}
```

## Assignments 📝

Reinforce your learning with these exercises:

* [ ] Create a function that returns a Future and use it with async/await.
* [ ] Create a Stream and listen to it in another function.
* [ ] Implement a custom class with a constructor, method, and properties. Instantiate it and call a method on it.
* [ ] Use a try-catch block to handle an error in a function

{% hint style="info" %}
These topics are fundamental for working effectively with Flutter. By understanding these Dart concepts, you'll be well-equipped to tackle more complex tasks in your Flutter projects.&#x20;
{% endhint %}

Up next, delve deeper into & State Management to learn how to create dynamic and responsive user interfaces!


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://flutteruniversity.gitbook.io/docs/learn-flutter/intermediate/deeper-into-dart.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.