Flutter ਐਪਸ ਲਗਾਤਾਰ asynchronous operations (network requests, file access, database queries) ਨੂੰ ਸੰਭਾਲਦੇ ਹਨ। Dart ਦੇ Futures (single async results) ਅਤੇ Streams (sequences of async events), async/await ਦੇ ਨਾਲ ਅਤੇ FutureBuilder/StreamBuilder ਵਰਗੀਆਂ widgets ਦੀ ਵਰਤੋਂ ਕਰਕੇ, async 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 = ਇੱਕ single value ਜੋ ਬਾਅਦ ਵਿੱਚ ਉਪਲਬਧ ਹੋਵੇ (network response, file read)। async/await async ਕੋਡ ਨੂੰ sequentially ਪੜ੍ਹਨਯੋਗ ਬਣਾਉਂਦਾ ਹੈ।
// 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 ਐਪਸ ਲਗਾਤਾਰ asynchronous operations ਨਾਲ ਸੰਭਾਲਦੀ ਹਨ, ਇਸ ਲਈ ਉਨ੍ਹਾਂ ਨੂੰ ਸਹੀ ਤਰੀਕੇ ਨਾਲ ਹੈਂਡਲ ਕਰਨਾ real ਐਪਸ ਬਣਾਉਣ ਲਈ ਬੁਨਿਆਦੀ ਹੈ।
ਲਗਭਗ ਹਰ ਐਪ async ਕਾਰਜ ਕਰਦੀ ਹੈ — network requests, file access, database queries, real-time data — ਅਤੇ Dart ਦੇ async primitives ਇਸ ਨੂੰ ਹੈਂਡਲ ਕਰਨ ਦਾ ਤਰੀਕਾ ਹਨ।
Futures (single async result ਨੂੰ represent ਕਰਦਾ ਹੈ ਜੋ ਬਾਅਦ ਵਿੱਚ ਉਪਲਬਧ ਹੋਵੇ, ਜਿਵੇਂ network response) ਅਤੇ async/await (async ਕੋਡ ਨੂੰ sequentially ਅਤੇ cleanly ਪੜ੍ਹਨਯੋਗ ਬਣਾਉਂਦਾ ਹੈ) ਨੂੰ ਸਮਝਣਾ async operations ਕਰਨ ਲਈ ਜ਼ਰੂਰੀ ਹੈ।
FutureBuilder ਨੂੰ ਸਮਝਣਾ UI ਲਈ ਖਾਸ ਤੌਰ 'ਤੇ ਮਹੱਤਵਪੂਰਨ ਹੈ: ਇਹ UI ਨੂੰ Future ਦੀ state ਦੇ ਅਧਾਰ 'ਤੇ ਬਿਲਡ ਕਰਦਾ ਹੈ, loading, error, ਅਤੇ data states ਨੂੰ ਸਹੀ ਤਰੀਕੇ ਨਾਲ ਹੈਂਡਲ ਕਰਦਾ ਹੈ — ਜੋ exactly ਉਹ ਹੈ ਜੋ real ਐਪਸ ਨੂੰ ਚਾਹੀਦਾ ਹੈ (loading ਸਮੇ spinner ਦਿਖਾਉਣਾ, failure ਤੇ error message, ਅਤੇ success ਤੇ data), async UI ਲਈ ਇੱਕ common ਅਤੇ ਜ਼ਰੂਰੀ pattern।
Streams (sequences of async events over time, ਜਿਵੇਂ live data, websockets, ਜਾਂ sensor readings) ਅਤੇ StreamBuilder (ਜਿਵੇਂ ਨਵੀਆਂ events ਆਉਂਦੀਆਂ ਹਨ UI ਨੂੰ rebuild ਕਰਨਾ) ਨੂੰ ਸਮਝਣਾ reactive, real-time UIs ਅਤੇ streams 'ਤੇ ਬਣੇ state management approaches ਲਈ ਜ਼ਰੂਰੀ ਹੈ।
Async ਨੂੰ ਸਹੀ ਤਰੀਕੇ ਨਾਲ ਹੈਂਡਲ ਕਰਨਾ — ਜਿਸ ਵਿੱਚ loading/error/data states ਸ਼ਾਮਲ ਹਨ ਜੋ FutureBuilder ਅਤੇ StreamBuilder ਮੈਨੇਜ ਕਰਦੇ ਹਨ — ਐਪਸ ਬਣਾਉਣ ਲਈ ਬੁਨਿਆਦੀ ਹੈ ਜੋ data ਨੂੰ fetch ਅਤੇ display ਸਹੀ ਤਰੀਕੇ ਨਾਲ ਕਰਦੀ ਹੈ (ਜ਼ਿਆਦਾ ਤਰ ਐਪਸ ਦਾ core)।
Since Flutter ਐਪਸ ਲਗਾਤਾਰ asynchronous operations (network, files, real-time data) ਕਰਦੀ ਹਨ ਅਤੇ ਉਨ੍ਹਾਂ ਦੇ results ਨੂੰ display ਕਰਨ ਲਈ async states ਨੂੰ ਸਹੀ ਤਰੀਕੇ ਨਾਲ ਹੈਂਡਲ ਕਰਨਾ ਪੈਂਦਾ ਹੈ, ਅਤੇ since Futures, Streams, async/await, ਅਤੇ Builder widgets ਇਸ ਲਈ ਜ਼ਰੂਰੀ tools ਹਨ, async, Futures, ਅਤੇ Streams ਨੂੰ Flutter ਵਿੱਚ ਸਮਝਣਾ ਜ਼ਰੂਰੀ, ਅਕਸਰ ਵਰਤਿਆ ਜਾਣ ਵਾਲਾ knowledge ਹੈ — ਐਪਸ ਬਣਾਉਣ ਲਈ ਬੁਨਿਆਦੀ ਹੈ ਜੋ data ਅਤੇ async operations ਨੂੰ ਸਹੀ ਤਰੀਕੇ ਨਾਲ ਹੈਂਡਲ ਕਰਦਾ ਹੈ, ਇੱਕ core skill ਜੋ virtually ਹਰ real Flutter application ਵਿੱਚ ਲਾਜ਼ਮੀ ਹੈ ਜੋ data ਨੂੰ fetch ਜਾਂ process ਕਰਦੀ ਹੈ।