PricingLoginStart free
Elixir ja Phoenix: skaalautuva backend-kehitys · Oppitunti

Enumerable-kokoelmien käsittely

Tutustukaa listojen, karttojen ja muiden enumerable-kokoelmien tehokkaaseen käsittelyyn Elixirin `Enum`-moduulilla.

Oppitunti 2/411 vaihetta

Enumerable-kokoelmien käsittely on ilmainen Elixir ja Phoenix: skaalautuva backend-kehitys-oppitunti CoddyKitissä. Tämä on oppitunti 2/4. Voit lukea koko oppitunnin alta ilmaiseksi ja harjoitella sen jälkeen käytännössä selaimessa sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla. Oppitunti kuuluu Elixir ja Phoenix: skaalautuva backend-kehitys-oppimispolkuun, ja edistymisesi synkronoituu verkon ja CoddyKit-sovelluksen välillä. Elixir ja Phoenix: skaalautuva backend-kehitys-kurssilla on yhteensä 4 oppituntia.

Mitä ovat lueteltavat kokoelmat?

Elixirissä lueteltava on tietorakenne, jonka alkiot voidaan käydä läpi yksi kerrallaan. Niitä voi ajatella useiden arvojen säiliöinä.

Elixirin tehokas Enum-moduuli tarjoaa monia funktioita näiden kokoelmien tehokkaaseen käsittelyyn.

  • Listat: minkä tahansa tietotyypin järjestettyjä kokoelmia.
  • Mapit: avain–arvo-säilöjä.
  • Välit: lukujen sarjoja.

Lueteltavien kokoelmien ymmärtäminen on funktionaalisen Elixir-ohjelmoinnin perusta.

Elixir-listojen käsittely

Listat ovat ehkä yleisin lueteltava kokoelma. Ne ovat järjestettyjä ja voivat sisältää eri tietotyyppejä.

Katsotaan yksinkertaista listaa:

defmodule ListExample do
  def run do
    my_list = [1, "hello", :atom, 4.5]
    IO.puts "My list: #{inspect my_list}"
  end
end

ListExample.run()

Map-rakenteet Enum-kokoelmina

Map-rakenteet tallentavat dataa avain–arvo-pareina. Vaikka niiden ensisijainen käyttötarkoitus on hakeminen, ne ovat myös lueteltavia, joten niiden avain–arvo-parit voidaan käydä läpi.

Map-rakennetta läpikäytäessä jokainen alkio on tupla {key, value}.

defmodule MapExample do
  def run do
    my_map = %{name: "Alice", age: 30}
    IO.puts "My map: #{inspect my_map}"
  end
end

MapExample.run()

`Enum`-moduulin esittely

Enum-moduuli on Elixirin vakiokirjasto, jolla käsitellään kaikenlaisia enumerable-rakenteita. Se tarjoaa yhdenmukaisen rajapinnan yleisiin toimintoihin.

Silmukoiden kirjoittamisen sijaan käytätte Enum-funktioita kokoelmien muuntamiseen, suodattamiseen ja yhdistämiseen muuttumattomalla ja funktionaalisella tavalla.

  • Tietoja ei muuteta paikallaan.
  • Funktiot palauttavat uusia kokoelmia.
  • Koodi pysyy selkeänä ja tiiviinä.

Toimintojen suorittaminen `Enum.each`-funktiolla

Enum.each/2-funktiota käytetään, kun haluatte suorittaa sivuvaikutuksen enumerable-rakenteen jokaiselle alkiolle, esimerkiksi tulostaa konsoliin. Se palauttaa aina arvon :ok.

Se muistuttaa muiden kielten for-each-silmukkaa, mutta sitä käytetään ainoastaan sivuvaikutusten tuottamiseen.

defmodule EachExample do
  def run do
    numbers = [1, 2, 3]
    IO.puts "Using Enum.each:"
    Enum.each(numbers, fn num -> IO.puts "Number: #{num}" end)
  end
end

EachExample.run()

Tietojen muuntaminen `Enum.map`-funktiolla

Enum.map/2 käyttää annettua funktiota enumerable-rakenteen jokaiseen alkioon ja kerää tulokset uudeksi listaksi. Se sopii erinomaisesti tietojen muuntamiseen.

Alkuperäinen enumerable-rakenne säilyy muuttumattomana funktionaalisen ohjelmoinnin periaatteiden mukaisesti.

defmodule MapTransformExample do
  def run do
    numbers = [1, 2, 3]
    doubled_numbers = Enum.map(numbers, fn num -> num * 2 end)
    IO.puts "Original: #{inspect numbers}"
    IO.puts "Doubled: #{inspect doubled_numbers}"
  end
end

MapTransformExample.run()

Alkioiden valitseminen `Enum.filter`-funktiolla

Enum.filter/2 luo uuden listan, joka sisältää vain alkiot, joille annettu funktio palauttaa "totuusarvoisen" arvon (kaiken muun paitsi false- tai nil-arvon).

Käyttäkää sitä, kun haluatte valita kokoelmasta tietyn osajoukon alkioita.

defmodule FilterExample do
  def run do
    numbers = [1, 2, 3, 4, 5, 6]
    even_numbers = Enum.filter(numbers, fn num -> rem(num, 2) == 0 end)
    IO.puts "All numbers: #{inspect numbers}"
    IO.puts "Even numbers: #{inspect even_numbers}"
  end
end

FilterExample.run()

Kokoelmien pelkistäminen `Enum.reduce`-funktiolla

Enum.reduce/3 (tai Enum.reduce/2) on yksi tehokkaimmista Enum-funktioista. Se "pelkistää" enumerablen yhdeksi arvoksi käyttämällä funktiota toistuvasti.

Annette alkuperäisen akkumulaattorin arvon sekä funktion, joka vastaanottaa nykyisen alkion ja akkumulaattorin ja palauttaa uuden akkumulaattorin.

defmodule ReduceExample do
  def run do
    numbers = [1, 2, 3, 4]
    sum = Enum.reduce(numbers, 0, fn num, acc -> num + acc end)
    IO.puts "Numbers: #{inspect numbers}"
    IO.puts "Sum: #{sum}"
  end
end

ReduceExample.run()

Muita tuntemisen arvoisia `Enum`-funktioita

Enum-moduuli on laaja! Tässä on muutama hyödyllinen funktio:

  • Enum.all?(enum, fun): Tarkistaa, täyttävätkö kaikki alkiot ehdon.
  • Enum.any?(enum, fun): Tarkistaa, täyttääkö jokin alkio ehdon.
  • Enum.take(enum, n): Palauttaa ensimmäiset n alkiota.
  • Enum.drop(enum, n): Palauttaa kaikki alkiot ensimmäisten n alkion jälkeen.
  • Enum.sort(enum): Järjestää alkiot.

Tutustukaa Elixirin viralliseen dokumentaatioon, josta löydätte täydellisen luettelon!

Testatkaa `Enum`-osaamistanne

Tarkastellaan seuraavaa Elixir-koodikatkelmaa:

defmodule QuestionCode do
  def run do
    data = [1, 2, 3, 4, 5]
    result_a = Enum.map(data, fn x -> x * 10 end)
    result_b = Enum.filter(data, fn x -> rem(x, 2) == 0 end)
    result_c = Enum.reduce(data, 0, fn x, acc -> x + acc end)
    IO.puts "A: #{inspect result_a}"
    IO.puts "B: #{inspect result_b}"
    IO.puts "C: #{inspect result_c}"
  end
end

QuestionCode.run()
Vastaa interaktiivisessa oppitunnissa

Kertaus: Enumerablen voima

Hienoa työtä! Olette oppineet Elixirin enumerable-kokoelmien käsittelyn perusteet.

  • Enumerables ovat tietorakenteita, joiden läpi voidaan iteroida (listat, mapit ja alueet).
  • Enum-moduuli tarjoaa tehokkaita funktioita yhdenmukaisiin ja muuttumattomiin operaatioihin.
  • Keskeisiä funktioita ovat each (sivuvaikutukset), map (muuntaminen), filter (valitseminen) ja reduce (yhdistäminen).

Nämä funktiot ovat Elixirin funktionaalisen ohjelmoinnin kulmakiviä, ja niiden avulla tietoja voidaan käsitellä selkeästi ja tehokkaasti.

Aloita maksutta

Opi Elixir 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
12
Oppitunnit
48
Aloita opiskelu maksuttaNäytä koko kurssi

Usein kysytyt kysymykset

Onko oppitunti ”Enumerable-kokoelmien käsittely” ilmainen?

Kyllä – oppitunnin ”Enumerable-kokoelmien käsittely” koko tekstin voi lukea täällä verkossa ilmaiseksi. Jos haluat harjoitella interaktiivisesti sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla sekä avata koko Elixir ja Phoenix: skaalautuva backend-kehitys-kurssin, päivitä CoddyKit PROhon. Elixir ja Phoenix: skaalautuva backend-kehitys-kurssilla on yhteensä 4 oppituntia.

Mitä opin oppitunnilla ”Enumerable-kokoelmien käsittely”?

Tutustukaa listojen, karttojen ja muiden enumerable-kokoelmien tehokkaaseen käsittelyyn Elixirin `Enum`-moduulilla. Harjoittelet Elixir ja Phoenix: skaalautuva backend-kehitys-aihetta koodilla, jonka suoritat suoraan selaimessa. Ympäri vuorokauden käytettävissä oleva tekoälytuutori vastaa kysymyksiisi oppitunnin aikana.

Tarvitsenko kokemusta aloittaakseni Elixir ja Phoenix: skaalautuva backend-kehitys-opiskelun?

Aiempi kokemus ei ole tarpeen. CoddyKitin Elixir ja Phoenix: skaalautuva backend-kehitys-oppimispolku sopii vasta-alkajista edistyneisiin, joten voit aloittaa tästä tai alusta ja edetä omaan tahtiisi. Tämä on oppitunti 2/4.

Kuinka kauan ”Enumerable-kokoelmien käsittely”-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ä Elixir ja Phoenix: skaalautuva backend-kehitys-oppitunnilla?

Kyllä. Jokainen Elixir ja Phoenix: skaalautuva backend-kehitys-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

  1. Funktiot, moduulit ja putkiketjutus
  2. Enumerable-kokoelmien käsittely
  3. Rekursio ja korkeamman asteen funktiot
  4. Laiska evaluointi Stream-moduulilla
← Takaisin: Elixir ja Phoenix: skaalautuva backend-kehitys