Kapag sinisiyasat natin ang mundo ng modernong pagbuo ng aplikasyon, napagtanto natin na ang estado ay simpleng anumang halaga na may kakayahang magbago sa paglipas ng panahon. Ito man ay isang simpleng variable, isang database ng Room, o isang touch-sensitive animation, Tinutukoy ng estado kung ano ang nakikita ng gumagamit sa bawat sandali. Ang pagiging dalubhasa kung paano iniimbak at ina-update ang impormasyong ito ang pagkakaiba sa pagitan ng isang app na tumatakbo nang maayos at isa na puno ng hindi maipaliwanag na mga error.
Sa mga deklaratibong kapaligiran tulad ng Pagsulat ng Jetpack Sa React, ang mindset ay lubos na nagbabago: hindi na natin mano-manong binabago ang mga elemento ng screen, kundi Inilalarawan namin ang interface ayon sa kasalukuyang estado nitoKung magbabago ang estado, awtomatikong muling iginuguhit ang interface, isang prosesong kilala bilang recomposition. Para gumana ito nang maayos, kailangan natin ng malinaw na mga pattern upang maiwasan ang mga hindi pagkakapare-pareho ng data.
Mga Pangunahing Kaalaman ng Estado sa Jetpack Compose
Para maunawaan ang Compose, kailangan mong tanggapin na ang tanging paraan para ma-update ang screen ay ang tawagin muli ang function gamit ang mga na-update na argumentoKung susubukan nating gumamit ng text field nang hindi pinamamahalaan ang estado nito, mapapansin natin na wala itong sinusulat; nangyayari ito dahil ang component ay hindi nagbabago sa sarili nito, sa halip ay sumasalamin sa value na natatanggap nito.
Para malutas ito, mayroon tayong API tandaanNagbibigay-daan ito sa iyo na i-save ang isang bagay sa memorya habang ginagawa ang unang komposisyon at kunin ito sa mga susunod na rekomposisyon. Kung gusto nating makaligtas ang datos na iyon sa pag-ikot ng screen o pagbabago ng configuration, ang mainam na solusyon ay ang paggamit ng rememberSaveable, na nag-iimbak ng impormasyon sa isang system Bundle.
Kapag pinag-uusapan natin ang mga baryabol na dapat magdulot ng mga biswal na pagbabago, babaling tayo sa nababagong EstadoNgLumilikha ito ng isang naoobserbahang estado na, kapag binago, ay nagsasabi sa Compose na magsagawa ng recomposition sa lahat ng mga function na nagbabasa ng partikular na value na iyon.
Mga Advanced na Pattern para sa isang Matatag na Estado
Hindi sapat ang simpleng pag-iimbak ng mga variable; para maging scalable ang isang app, kailangan nating ilapat ang Nag-iisang Pinagmumulan ng Katotohanan (SSOT)Ipinahihiwatig nito na ang lahat ng estado ng screen ay nagmumula sa iisang awtoritatibong pinagmulan, kadalasan sa pamamagitan ng mga selyadong klase o interface na tumutukoy sa lahat ng posibleng senaryo ng UI, kaya tinitiyak na pinipilit tayo ng compiler na hawakan ang bawat estado.
Ang isa pang pangunahing haligi ay ang kawalan ng pagbabago ng estadoSa halip na baguhin ang isang umiiral na bagay, lumilikha tayo ng isang bagong kopya na may mga ninanais na pagbabago (gamit ang pamamaraang `kopya` ng mga klase ng datos). Naiiwasan nito ang kinatatakutang mga kondisyon ng karera sa mga sabay-sabay na kapaligiran at ginagawa itong masusubaybayan ang mga transisyon ng estado at madaling i-debug.
Para isara ang loop, ipinatupad namin mga update batay sa kaganapanSa halip na direktang baguhin ng UI ang estado, nagpapadala ito ng isang kaganapan (tulad ng isang pag-click o na-type na teksto) pataas, at ang may-ari ng estado ang magpapasya kung paano ito ipoproseso. Ang modelong ito ang batayan ng daloy ng datos na unidireksyonal (UDF)kung saan ang estado ay bumababa sa mga bahagi at ang mga kaganapan ay umaakyat sa lohika.
Mga Lalagyan ng Estado: ViewModel vs Flat Classes
Depende sa kasalimuotan, maaari nating piliin kung saan ilalagay ang lohika. Android ViewModel Ito ang pangunahing opsyon para sa business logic. Ang pangunahing bentahe nito ay nakaligtas sa muling paglikha ng Aktibidad at maayos itong isinasama sa Navigation at Hilt, na nagpapahintulot sa data na manatili habang nagna-navigate ang user sa app.
Sa kabilang banda, mayroon Mga lalagyan ng estado ng lohika ng UIKaraniwan itong mga simple at walang format na klase. Humahawak sila ng mga panandaliang gawain, tulad ng kung dapat bang ipakita ang isang buton batay sa posisyon ng pag-scroll o pamamahala ng mga pahintulot. Hindi tulad ng ViewModel, ang mga ito Pareho ang siklo ng kanilang buhay gaya ng interface at karaniwang ginagawa gamit ang mga pasadyang function ng pag-alala.
Mahalagang huwag direktang ipasa ang ViewModel sa mga child component, dahil ikokonekta nito ang view sa logic at gagawing mas mahirap ang pagsubok. Ang tamang paraan ay pumasa lamang sa kinakailangang estado at magtalaga ng mga kaganapan gamit ang mga lambda, sa gayon ay pinapanatili ang modularity at kadalian ng paglikha ng mga preview.
Mga Istratehiya sa Pagsusuri at Kalidad
Kapag ang estado ay hindi mababago at pinangungunahan ng mga kaganapan, ang pagsubok sa aplikasyon ay nagiging isang tunay na kasiya-siyang gawain. Mapapatunayan natin na ang Gagawa ang ViewModel ng inaasahang update bilang tugon sa isang partikular na kaganapan nang hindi kinakailangang ilunsad ang graphical interface, na gumagawa ng mga direktang pahayag tungkol sa nagresultang estado.
Tungkol sa pagsubok sa UI, ang dapat na pokus ay ang pagpapatunay na Ang mga bahagi ay tumpak na sumasalamin sa estado at ang mga interaksyon ng gumagamit ay nagpapalitaw ng mga tamang kaganapan. Sa pamamagitan ng paghihiwalay ng lohika mula sa presentasyon, maaari nating subukan ang bawat piraso nang hiwalay, tinitiyak na ang mga estado ng error o paglo-load ay ipinapakita nang naaangkop.
Pamamahala ng Estado sa React Ecosystem
Bagama't pinag-uusapan natin ang Android, ang mga konsepto ay halos kapareho ng nangyayari sa React. Dito rin, nariyan ang lokal na estado sa pamamagitan ng useState hook, na nagbibigay-daan sa bawat component na pamahalaan ang sarili nitong internal data. Kapag kailangan natin ng maraming component para magbahagi ng impormasyon, ginagamit natin ang mga kagamitan para sa pagpasa ng datos mula ama patungo sa anak.
Para maiwasan ang problema ng pagpasa ng mga props sa napakaraming level (prop drilling), iniaalok ng React ang konteksto gamit ang useContextpaglikha ng isang sentralisadong imbakan ng datos. Sa mga malalaking aplikasyon, madalas itong ginagamit Redux, na nagpapatupad ng Store, Actions at Reducers upang pamahalaan ang estado sa isang nahuhulaan at pandaigdigan na paraan.
Tulad ng sa Compose, sa React, ang DOM ay hindi mano-manong minamanipula, kundi Ilarawan ang interface para sa iba't ibang visual na estadoAng daloy ng datos ay nananatiling mahalaga: ang estado ay ina-update sa pamamagitan ng mga partikular na function, na nagiging sanhi ng muling pag-render ng mga bahagi gamit ang bagong impormasyon.
Ang pagkakaroon ng arkitektura kung saan ang estado ay mahuhulaan at ang lohika ay nakahiwalay sa view ay nagbibigay-daan para sa mas maayos na pag-unlad. Gumagamit man ng ViewModels sa Android, Redux sa web, o simpleng pag-angat ng estado sa isang parent component, ang susi ay nasa... mapanatili ang pagkakapare-pareho ng datos at igalang ang unidirectional na daloy upang ang aplikasyon ay mapanatili sa pangmatagalan.