Swift Academy · Oppitunti

Laiskan ja välittömän käsittelyn kompromissit

Tiedä, milloin laiskuus auttaa tai haittaa.

Oppitunti 3/413 vaihetta

Laiskan ja välittömän käsittelyn kompromissit on ilmainen Swift Academy-oppitunti CoddyKitissä. Tämä on oppitunti 3/4. Voit lukea tästä oppimispolusta kokonaan mitkä tahansa 3 oppituntia ilmaiseksi — sen jälkeen CoddyKit PRO avaa kaikki oppitunnit sekä käytännön harjoittelun sisäänrakennetulla koodieditorilla ja ympäri vuorokauden toimivalla tekoälytuutorilla. Oppitunti kuuluu Swift Academy-oppimispolkuun, ja edistymisesi synkronoituu verkon ja CoddyKit-sovelluksen välillä. Swift Academy-kurssilla on yhteensä 4 oppituntia.

Ilmaisia lounaita ei ole

Lazy ei ole aina nopeampi. Se vaihtaa ennakkoon tehtävän varauksen elementtikohtaiseen käyttökuormaan ja muuttaa sivuvaikutusten suoritusajankohtaa. Kun tunnette nämä kompromissit, osaatte valita oikein.

Lazy voittaa: osittainen kulutus

Tarvitaan vain osa valtavan muunnoksen tuloksesta — lazy ohittaa loput:

let data = Array(1...1_000_000)
let top = data.lazy.map { $0 * 2 }.prefix(3)
print(Array(top))  // [2, 4, 6]  -- 999,997 transforms skipped

Eager voittaa: tuloksen täysi uudelleenkäyttö

Jos iteroitte tuloksen useita kertoja, eager laskee sen kerran; lazy laskee sen uudelleen jokaisella kierroksella:

let doubled = [1, 2, 3].map { $0 * 2 }  // computed once
print(doubled.reduce(0, +))  // 12
print(doubled.max()!)        // 6  -- no recompute

Lazy laskee uudelleen

Sama lazy-näkymä tekee työn uudelleen jokaisella iteroinnilla:

var work = 0
let view = [1, 2, 3].lazy.map { (n: Int) -> Int in work += 1; return n }
_ = view.reduce(0, +)
_ = view.max()
print(work)  // 6  -- transformed twice

Elementtikohtainen kuormitus

Jokainen lazy-vaihe käärii sekvenssin uuteen tyyppiin ja kutsuu sulkeumia elementti kerrallaan. Pienillä taulukoilla tämä kuormitus voi olla suurempi kuin säästetty varaus.

Pieni taulukko: eager riittää

Kun muutama elementti käytetään kokonaan, suosikaa tavallista eager-arviointia — se on yksinkertaisempaa, ja varaus on merkityksetön:

let nums = [3, 1, 2]
let sorted = nums.map { $0 + 1 }.sorted()
print(sorted)  // [2, 3, 4]

Sivuvaikutusten ajoitus poikkeaa

Lazy-arvioinnissa sulkeuman runko suoritetaan myöhemmin kuin sen määrittelevä rivi. Välttäkää sivuvaikutuksiin nojaamista lazy-muunnoksissa:

var log: [Int] = []
let v = [1, 2].lazy.map { (n: Int) -> Int in log.append(n); return n }
print(log)        // []  -- nothing ran yet
_ = Array(v)
print(log)        // [1, 2]

Toiminnot, jotka pakottavat eager-arvioinnin

Joidenkin toimintojen on joka tapauksessa luettava koko sekvenssi, joten lazy ei tuo niissä hyötyä:

let nums = Array(1...10)
print(nums.lazy.map { $0 * 2 }.sorted())  // sorted must see all -> [2,4,...,20]
print(nums.lazy.map { $0 }.count)         // count walks everything

Lazy ja contains

Oikopolkuarviointia käyttävät toiminnot, kuten contains(where:), hyötyvät lazysta suurilla syötteillä:

let big = Array(1...1_000_000)
let found = big.lazy.map { $0 * 2 }.contains { $0 == 8 }
print(found)  // true  -- stops at element 4

Päätöksenteon tarkistuslista

Käyttäkää lazy-arviointia, kun: lähde on suuri JA säilytätte siitä vain osan (prefix / first / contains) JA iteroitte kerran. Käyttäkää eager-arviointia, kun: taulukko on pieni, käytätte tulosta uudelleen tai luettavuus on tärkeämpää kuin mikro-optimointi.

let huge = Array(1...100_000)
let first = huge.lazy.filter { $0 % 9973 == 0 }.first
print(first!)  // 9973

Mitatkaa, älkää arvatko

Suorituskykyä koskeva intuitio on usein väärässä. Kun asialla on merkitystä, verratkaa molempia versioita realistisilla tiedoilla ennen lazy-arviointiin sitoutumista.

let nums = Array(1...50)
let eager = nums.filter { $0 > 25 }.count
let lazyC = nums.lazy.filter { $0 > 25 }.count
print(eager == lazyC)  // true -- same answer, profile for speed

Pikakysymys

Milloin eager on parempi valinta kuin lazy?

Vastaa interaktiivisessa oppitunnissa

Kertaus

Opitte näiden vaihtoehtojen kompromissit:

Lazy voittaa suurilla lähteillä, kun kulutus on osittaista ja tapahtuu kerran
Eager voittaa pienillä taulukoilla ja uudelleenkäytettävillä tuloksilla (lazy laskee tuloksen uudelleen)
Lazy-muunnosten sivuvaikutukset suoritetaan myöhemmin — älkää perustako toimintaa niihin
Mitatkaa ennen optimointia

Seuraavaksi: mukautettujen lazy-sekvenssien rakentaminen.

Aloita maksutta

Opi Swift tekoälytuutorin avulla — ilmaiseksi

Kirjoita ja suorita oikeaa koodia selaimessa, saa välitöntä apua tekoälytuutorilta ympäri vuorokauden ja jatka siitä, mihin jäit, verkossa tai sovelluksessa.

Kurssit: 122
Oppitunnit: 409

Aloita opiskelu maksutta Näytä koko kurssi

Usein kysytyt kysymykset

Onko oppitunti ”Laiskan ja välittömän käsittelyn kompromissit” ilmainen?

Kyllä — voit lukea täällä verkossa kokonaan ilmaiseksi mitkä tahansa Swift Academy-oppimispolun 3 oppituntia, myös oppitunnin “Laiskan ja välittömän käsittelyn kompromissit”. Sen jälkeen CoddyKit PRO avaa kaikki oppitunnit sekä interaktiiviset harjoitukset sisäänrakennetulla koodieditorilla ja ympäri vuorokauden toimivalla tekoälytuutorilla. Swift Academy-kurssilla on yhteensä 4 oppituntia.

Mitä opin oppitunnilla ”Laiskan ja välittömän käsittelyn kompromissit”?

Tiedä, milloin laiskuus auttaa tai haittaa. Harjoittelet Swift Academy-aihetta koodilla, jonka suoritat suoraan selaimessa. Ympäri vuorokauden käytettävissä oleva tekoälytuutori vastaa kysymyksiisi oppitunnin aikana.

Tarvitsenko kokemusta aloittaakseni Swift Academy-opiskelun?

Aiempi kokemus ei ole tarpeen. CoddyKitin Swift Academy-oppimispolku sopii vasta-alkajista edistyneisiin, joten voit aloittaa tästä tai alusta ja edetä omaan tahtiisi. Tämä on oppitunti 3/4.

Kuinka kauan ”Laiskan ja välittömän käsittelyn kompromissit”-oppitunnin suorittaminen kestää?

Useimmat CoddyKitin oppitunnit kestävät noin 5–10 minuuttia. Jokainen oppitunti on lyhyt ja interaktiivinen, joten edistyt tasaisesti ja voit jatkaa siitä, mihin jäit – sekä verkossa että sovelluksessa.

Voinko kirjoittaa ja suorittaa koodia tällä Swift Academy-oppitunnilla?

Kyllä. Jokainen Swift Academy-oppitunti sisältää sisäänrakennetun koodieditorin, joten voit kirjoittaa ja suorittaa oikeaa koodia suoraan selaimessa ja saada välitöntä palautetta tekoälyltä – paikallista asennusta ei tarvita.

Kaikki tämän kurssin oppitunnit

lazy-ominaisuus
Laiska map ja filter
Laiskan ja välittömän käsittelyn kompromissit
Mukautettujen laiskojen sekvenssien rakentaminen

← Takaisin: Swift Academy