StatefulWidget State object પાસે lifecycle છે — methods ની શ્રેણી જે widget બનાવવામાં આવે, અપડેટ કરવામાં આવે અને નાશ પામે ત્યારે બોલાય છે (initState, build, didUpdateWidget, dispose, વગેરે). તેને સમજવું resources અને side effects ને યોગ્ય રીતે સંચાલિત કરવા માટે મહત્વપૂર્ણ છે.
class _MyWidgetState extends State<MyWidget> {
@override
void initState() {
super.initState();
// called ONCE when the State is created → initialize, start subscriptions,
// fetch initial data, set up controllers/listeners
}
@override
Widget build(BuildContext context) {
// called whenever the UI needs to render (often) → return the widget tree
return Container();
}
@override
void didUpdateWidget(MyWidget oldWidget) {
super.didUpdateWidget(oldWidget);
// called when the parent rebuilds with new config → react to changed inputs
}
@override
void dispose() {
// called when the State is permanently removed → CLEAN UP:
// cancel subscriptions, dispose controllers, close streams (prevent leaks!)
super.dispose();
}
}
createState → initState (once) → build (many times) → [didUpdateWidget on config change]
→ ... → dispose (once, at the end)
Other: didChangeDependencies (when InheritedWidget dependencies change)
⚠️ dispose() is CRITICAL for cleanup — failing to clean up causes MEMORY LEAKS / bugs:
→ cancel Stream subscriptions, Timers; dispose AnimationControllers, TextEditingControllers,
ScrollControllers; close StreamControllers
→ resources started in initState should be cleaned up in dispose
→ A common source of leaks: forgetting to dispose controllers/subscriptions.
StatefulWidget lifecycle સમજવું Flutter માં resources અને side effects ને યોગ્ય રીતે સંચાલિત કરવા માટે મહત્વપૂર્ણ છે, તેથી તે મૂલ્યવાન વ્યવહારુ જ્ઞાન છે.
State object lifecycle methods ચોક્કસ બિંદુઓ પર બોલાય છે, અને તેમને યોગ્ય રીતે ઉપયોગ કરવો આવશ્યક છે: initState (State બનાવવામાં આવે ત્યારે માત્ર એક વાર બોલાય — તે જગ્યા જ્યાં initialize કરવું, પ્રારંભિક ડેટા fetch કરવો, subscriptions શરૂ કરવી અને controllers/listeners સેટ કરવા), build (જ્યાં પણ UI renders, widget tree return કરે), didUpdateWidget (જ્યારે parent નવા configuration સાથે rebuilds, બદલાયેલ inputs પર પ્રતિક્રિયા આપવા માટે), અને dispose (જ્યારે State કાયમી રીતે દૂર થાય).
સામાન્ય પ્રવાહ (createState → initState → build વારંવાર → dispose) સમજવું સ્પષ્ટ કરે છે કે દરેક કંઈ ચલાવે છે.
સૌથી મહત્વની બાબત એ છે કે dispose cleanup માટે આવશ્યક છે એ સમજવું: resources કોઈ cleanup ન કરવા (Stream subscriptions અને Timers રદ્દ કરવા, AnimationControllers, TextEditingControllers અને ScrollControllers dispose કરવા, StreamControllers બંધ કરવા) memory leaks અને bugs કારણે થાય છે — અને controllers અને subscriptions dispose કરવાનું ભૂલવું Flutter apps માં leaks નો સામાન્ય, વાસ્તવિક સ્ત્રોત છે.
initState માં resources સેટ અપ કરવા અને dispose માં તેમને clean કરવાનો પેટર્ન સાચા, leak-free widgets લખવા માટે મૌલિક છે.
Lifecycle સમજવું યોગ્ય initialization (initState માં), changes પર પ્રતિક્રિયા (didUpdateWidget માં), અને ખાસ કરીને cleanup (dispose માં) સક્ષમ કરે છે.
چૂંકી resources અને side effects ને યોગ્ય રીતે સંચાલિત કરવું સાચા, leak-free Flutter apps માટે આવશ્યક છે, અને StatefulWidget lifecycle (ખાસ કરીને setup માટે initState અને cleanup માટે dispose) આ માટે મંત્રવિધિ છે, StatefulWidget lifecycle સમજવું — મુખ્ય methods, તેમની timing, અને ખાસ કરીને leaks રોકવામાં dispose ની મહત્વપૂર્ણ ભૂમિકા — મહત્વપૂર્ણ, વ્યવહારુ-સુસંગત Flutter જ્ઞાન છે સાચા stateful widgets લખવા માટે, resource leaks ટાળવા માટે મુખ્ય કૌશલ્ય જે Flutter માં સામાન્ય વાસ્તવિક-વિશ્વ મુદ્દો છે.