Flutter აპლიკაციები მუდმივად ეხმიანებიან ასინქრონულ ოპერაციებს (ქსელის მოთხოვნები, ფაილების წვდომა, ბაზის მოთხოვნები). Dart-ის Futures (ერთი ასინქრონული შედეგი) და Streams (ასინქრონული ივენტების თანმიმდევრობა), async/await-თან და ვიჯეტებთან ისევ როგორც FutureBuilder/StreamBuilder, აუცილებელია ასინქრონული UI-სთვის.
// a Future represents a single async result that completes later
Future<String> fetchUser() async {
final response = await http.get(url); // await pauses until the Future completes
return response.body; // returns the result
}
// using it
final data = await fetchUser(); // await the result
// or: fetchUser().then((data) => ...); // callback style
Future = ერთი მნიშვნელობა, რომელიც ხელმისაწვდომი იქნება მოგვიანებით (ქსელის პასუხი, ფაილის წაკითხვა). async/await აზრობრივად თანმიმდევრულს ხდის ასინქრონულ კოდს.
// FutureBuilder rebuilds the UI based on the Future's state (loading/data/error)
FutureBuilder<String>(
future: fetchUser(),
builder: (context, snapshot) {
if (snapshot.connectionState == ConnectionState.waiting) {
return CircularProgressIndicator(); // loading
} else if (snapshot.hasError) {
return Text('Error: ${snapshot.error}'); // error
} else {
return Text(snapshot.data!); // got the data
}
},
)
// a Stream = a SEQUENCE of async events over time (e.g. live data, websocket, sensor)
Stream<int> counter() async* {
for (int i = 0; i < 10; i++) {
await Future.delayed(Duration(seconds: 1));
yield i; // emit each value
}
}
// StreamBuilder rebuilds the UI as new events arrive
StreamBuilder<int>(stream: counter(), builder: (context, snapshot) => Text('${snapshot.data}'))
Async, Futures და Streams-ის გაგება აუცილებელია, რადგან Flutter აპლიკაციები მუდმივად ეხმიანებიან ასინქრონულ ოპერაციებს, ამიტომ მათი სწორად დამუშავება ფუნდამენტურია რეალური აპლიკაციების აგებისთვის.
საკმაოდ ყველა აპლიკაცია ასრულებს ასინქრონულ სამუშაოს — ქსელის მოთხოვნები, ფაილების წვდომა, ბაზის მოთხოვნები, რეალური დროის მონაცემები — და Dart-ის ასინქრონული პრიმიტივები ის გზაა, რომლითაც ამას ხელი შეუწყობთ.
Futures-ის გაგება (რომელიც წარმოადგენს ერთი ასინქრონული შედეგს, რომელიც ხელმისაწვდომი იქნება მოგვიანებით, როგორც ქსელის პასუხი) async/await-თან (რაც ასინქრონულ კოდს აზრობრივად თანმიმდევრულს და სუფთად აზრობრივს ხდის) აუცილებელია ასინქრონული ოპერაციების შესასრულებლად.
FutureBuilder-ის გაგება განსაკუთრებით მნიშვნელოვანია UI-სთვის: ის აყალიბებს UI Future-ის მდგომარეობის საფუძველზე, სწორად დამმუშავებელი დატვირთვის, შეცდომის და მონაცემების მდგომარეობებით — რომელიც სწორედ ის არის, რაც რეალურმა აპლიკაციებმა საჭიროა (დატვირთვის დროს სპინერის ჩვენება, წარუმატებლობის შემთხვევაში შეცდომის შეტყობინება და მონაცემები წარმატების შემთხვევაში), ასინქრონული UI-ის ხშირი და აუცილებელი შაბლონი.
Streams-ის გაგება (ასინქრონული ივენტების თანმიმდევრობა დროთი, როგორიცაა ცოცხალი მონაცემები, ვებსოკეტები ან სენსორის მნიშვნელობები) და StreamBuilder (UI-ის თავიდან აგება ახალი ივენტების მოწოდებისას) აუცილებელია რეაქტიული, რეალური დროის UI-სთვის და მდგომარეობის მართვის მიდგომებისთვის, რომლებიც შენობა დგა Stream-ზე.
ასინქრონის სწორად დამუშავება — მათ შორის დატვირთვის/შეცდომის/მონაცემების მდგომარეობები, რომლებსაც FutureBuilder და StreamBuilder მართავენ — ფუნდამენტურია აპლიკაციების აგებისთვის, რომლებიც სწორად იხვევენ და აჩვენებენ მონაცემებს (უმეტეს აპლიკაციების ბირთვი).
ვინაიდან Flutter აპლიკაციები მუდმივად ასრულებენ ასინქრონულ ოპერაციებს (ქსელი, ფაილები, რეალური დროის მონაცემები) და მათი შედეგების ჩვენება საჭიროებს ასინქრონული მდგომარეობების სწორად დამუშავებას, და ვინაიდან Futures, Streams, async/await და Builder ვიჯეტები აუცილებელი ხელსაწყოები ამისთვის, ასინქრონის, Futures-ის და Streams-ის გაგება Flutter-ში აუცილებელი, ხშირად გამოყენებული ცოდნა — ფუნდამენტური აპლიკაციების აგებისთვის, რომლებიც სწორად მუშავენ მონაცემებს და ასინქრონული ოპერაციებს, ძირითადი უნარი, რომელიც საჭიროა ფაქტიურად ყველა რეალურ Flutter აპლიკაციაში, რომელიც იხვევს ან ამუშავებს მონაცემებს.