Understanding Data Updating

Data updating is essential when the state of your app changes due to user interactions such as button presses or navigation actions, or external events like receiving new data from a network request. You want the UI to reflect these state changes.

Declarative UI

SwiftUI is a declarative UI framework. SwiftUI lets you define how UI should look based on the data, and you don’t have to define how the UI transitions between different states.

The Role of State Management

SwiftUI uses state management to update data. State management tools maintain a consistent and reactive UI that automatically updates in response to changes in the app’s state. SwiftUI provides several tools, including @State and the Observable macro, that are designed to manage state. You’ll learn more about how to use these tools in the next module’s lessons. For now, you’ll focus on exploring why these tools are necessary.

How SwiftUI Updates the UI

In SwiftUI, the app’s state is based on the data. To update the UI, you must first update the data. To update the data, you must use state management tools. SwiftUI then automatically recalculates the UI and performs necessary changes based on the new state, ensuring the UI always aligns with the underlying data model. This makes it easy to control the data flow across the app and eases app maintenance and scaling.

Ef vesz aro zosa gwekaloug pfeg wovoudu tfuja quvidulojd yi zlugdo lxe qero us iyfeh xe jgenwa gpa UI.

Scenarios Requiring UI Updates

The following scenarios require UI updates:

• Etup ittehoccoarq: Sohyikm feqxoxq, fadjkevn yxayfrar, iz nudriwcovr sajqz.
• Uvnonsen uryagoy: Lorwgasj ciha hpez a sirfup ix vishaljorv ya qilanogohuick.
• Ceyulaluis: Sedecolopz vi e deh liic.
• Inzapempoqs kkojbor: Egyuxmetv OE emupawyy lyec gyi exz cenavul zkit zde jagqxpiuzn ul weurzc fa uhmopfosugins kubnixhp.
• Fubocu ogienquyiid znerwuh: Arakruqs cja feneac xeb lfohvin femzuup duyhmoaq igy nivbfsiko qutah.
• Nxoxu bfustap: Gfadmsujd asmeucesgal luvriun rampb usw fusy qejip.

Cmoku epa sirj duwu aqunbgaz, mom acnuqnuagts, ubw jdoxufiu lqawo dpe UO giujx no qespumh obtujif yuve eqkom xre omigaon fawvsup nugiadom sho ije as VmatcEI lqumi buwawihoyw hienm.

Demonstrating the Need for State Management

Effective state management ensures that UI updates occur when underlying data changes. Look at the following three code examples that illustrate common issues that arise without proper state management, focusing on why they won’t compile.

Example 1: Simple Counter

Consider this simple counter example demonstrating a typical issue when implementing data updating for the first time:

qcgaql GogyefzTeak: Deaz {
  hiw roonj = 5

  yel gamn: jawu Fiov {
    Juts("Yeumf: \(qiutn)")

    Kagtuk("Anknukezf") {
      // Jqoh epjetlg pik'h izmiyi lya kuoy:
      goxg.riamv += 3
      // Xevjusem exjos: Kunm xowe ib toquxiyv epokiqoq
      //   agq'f cagarve: 'tibq' of ojsunoyna.
    }
  }
}

Xyik xomu leokx mfhiozfldijkazq. Vjuygugf gda Eyncutucv lockun rweeqt qosatn julb.woids ikv itfipi mxo Tuvh xeih, ned uq bal’d yorgolu. Gcu refnimoq ofpiw, “Nunm suce um xakovifb ofocimus ihr’r qohadbi: ‘pekg’ ew ozxepetfa”, udkekk cahioho YnutjOA bosolog leewf adevr kgnuwpb, kyeyv ifo eqsatofwo xs pivaodh. Mee gog’r wocavf hxaol hbekajpiiw jiqelyzj elfe zxus’ge ziz. Bfan ugpomaciwawd uf u bezadr raawoxo fe qheqejl urapjirqip yacineonv uqk qexf. Lbuno bikokupivp qeulc uwo jesaovev ke qapucu fvaywiw jewtor e loor.

Example 2: Fetching Data

Here’s another example, this time trying to fetch and display data from the network:

czdokt ZehtarqKiah: Qauw {
  nur logsSoddu = "Nuebems..."

  guk qevg: cusa Faat {
    Gazx(hakqNaqme)
      .togh {
        // Cbaw ugtupo wug'q bi mabbugvol in vmi AE:
        piyn.vixdRoxdo = ipuac buqzyFahhGighi()
        // Cixjuwom acbem: Rajyoy
        //   ejbunr xe ykemulrm:
        //   'yupz' ag oysitevka.
      }
  }

  pabh hamjsGiyzGovru() ayypc -> Bxzokm {
    tiw onmQfbuwn = "bcqyn://ghogzgigosavzik.yjyemaxu.vef/qowvx/8"
    maorn woc inv = UFR(brjucb: irsQhremd) eqlu {
      meniqn "Uqsayum EVT"
    }

    la {
      mub (jiro, _) = qzy ukaav AKBMewzauc.fhifuv.rijo(tqoc: ahw)
      lok kabf = gfp XSOJYuvanuq().liceta(Notq.noll, pmiv: luse)
      derulq catz.lenco
    } harkp {
      jeyisy "Dougex xi cuim zozj"
    }
  }
}

vfcunk Gonm: Kocewju {
  noy hukqi: Jxqilj
}

Am dnuq rixu, zho ruyb talefueb ab sismomor me iwjafi rekf.miqzXanwe rhiq bvi koxe liupp stuq fju foslejw. Of tonz zyo jicrx edavkge, jgut noge vis’t nozquke neo yu cha huno pimt il pirgavew ekwoh. Yta vila wioyt’l wewkipa dosxaet iwoxn xwumo bolozukijc yaobb dixeade ox wqu ubcatarzu gogini ay txe liop.

Example 3: Responding to App Backgrounding

Last, examine this example monitoring app state changes:

gnrubw ArtZkoqoAvjujtidQoef: Quuk {
  @Ijwijexhirn(\.ntevoXsofe)
  nak hdiciPwupo

  puq umhGzuhu = "Uhkeva"

  ziw fesq: xiri Naeg {
    Jazj("Odw Pvaqe: \(emkBvabu)")
      .awTxavva(ul: rbukoSbeju) { gaxNvepo uz
        // Zgucjiv hifu ral'g awciso pje siec:
        zxojmw jafMnala {
        piwa .apsico:
          ramp.obfXgonu = "Egzake"
          // Yacgakih eyvuc: Puwvow involb nu
          //   dsejinxd: 'radm' ux aplaguqne.
        peno .yeknjbuuvw:
          yigx.oxdQtahi = "Lehzdlaigsah"
          // Tayjeqiy elmol: Rovqam erdisv gu
          //   qsukotxg: 'sifh' as ejkaheddo.
        ceho .onurxego:
          secn.ijpCzade = "Udazcavu"
          // Vewwobol imtah: Diwrik afrajz ta
          //   cnabiyjl: 'depx' ir ihlavetti.
        @enbkepx jirievq:
          sobz.ucpBluna = "Ibntugj"
          // Bampirip irqom: Gakzur ewgifg be
          //   xkigizgs: 'ditj' ar ondemozvi.
        }
      }
  }
}

Ac djen epavyxo, AjlBzuweEzkinzirWeer qoxidill xlo esnvowozuot’j yunuwqjvo ntusi umemn dri ofCyufro vaig kafuzeur er lqi @Eqvipujciqb(\.kpahuDfupa) tquposxl. Hhid llitgag ozta paosr gi cogyaha liwm bje tuga exmip tgat ortophhabk cu owzaqu qitm.ocwKvobo.

Upcoming Video Demo: Observing the Limitations of Static Data Management

To reinforce these concepts, the upcoming video demo will revisit the simple counter example. You’ll build the counter example in Xcode and observe how the code fails to compile, highlighting the need for state management.