Lär dig Ruby Enumerable: each, map och select

Ruby's Ruby Enumerable Modulen är drivkraften bakom uttrycksfull iteration i funktionell stil. Integrerad i Array, Hash, Range, Set, samt anpassade samlingar, vilket möjliggör en smidig och effektiv databehandling. Förbättra dina Ruby-projekt med hjälp av experter Konsulttjänster inom Rails, genom att optimera varje `map`- och `select`-uttryck för att få en renare och mer prestandastark kod.

Ruby Enumerable: Grunden

Användning Ruby Enumerable, måste en klass definiera var och en:

ruby
class ShoppingList
  include Enumerable

  def initialize(*items)
    @items = items
  end

  def each(&block)
    @items.each(&block)
  end
end

Nu Inköpslista stöder alla Ruby-enumerable-objekt metoder.

Ruby Enumerable: var och en – Utför per post

Vad var och en Gör

Kör ett block för varje element. Returnerar den ursprungliga samlingen.

ruby
[1, 2, 3].each { |n| puts n * 2 }
# Utdata:
# 2
# 4
# 6
# Returvärde: [1, 2, 3]

När ska man använda Ruby Enumerable? var och en

• Logga eller skriva ut
• Utlösande bieffekter (e-post, API-anrop)
• Ackumulering av externt tillstånd

ruby
total = 0
[10, 20, 30].each { |n| total += n }
puts total # => 60

Fallgrop: Använd aldrig var och en förväntar sig en transformerad matris.

ruby
# Fel
[1, 2, 3].each { |n| n * 2 } # => [1, 2, 3]

Ruby Enumerable: karta (eller samla in) – Omvandla alla objekt

Vad karta Gör

Tillämpar ett block och returnerar en ny array av resultaten.

ruby
[1, 2, 3].map { |n| n * 2 } # => [2, 4, 6]

När ska man använda Ruby Enumerable? karta

• Konvertering av datatyper
• Extrahera fält
• Att bygga nya strukturer

Ruby Enumerable karta Exempel

Skriv namn med versaler

ruby
["alice", "bob"].map(&:upcase) # => ["ALICE", "BOB"]

Hämta användarnas e-postadresser

ruby
users = [{email: "[email protected]"}, {email: "[email protected]"}]
users.map { |u| u[:email] } # => ["[email protected]", "[email protected]"]

Med index

ruby
fruits = ["äpple", "banan"]
fruits.map.with_index { |f, i| "#{i + 1}. #{f}" }
# => ["1. äpple", "2. banan"]

Fallgrop: Använd inte karta endast vid biverkningar.

ruby
# returnerar [nil, nil, nil]
[1, 2, 3].map { |n| puts n }

Ruby Enumerable: Välj (eller find_all) – Filtrera matchande artiklar

Vad Välj Gör

Returnerar ett ny matris av element där block återkommer Sann.

ruby
[1, 2, 3, 4].select(&:even?) # => [2, 4]

När ska man använda Ruby Enumerable? Välj

• Filtrering av giltiga poster
• Hämta data
• Delmängder av samlingar

Ruby Enumerable Välj Exempel

Godkända poäng

ruby
poäng = [89, 45, 92, 61]
poäng.select { |s| s >= 70 } # => [89, 92]

Aktiva användare

ruby
users = [
  {name: "Alice", active: true},
  {name: "Bob",   active: false}
]
users.select { |u| u[:active] } # => [{name: "Alice", active: true}]

Mittemot: avvisa

ruby
[1, 2, 3, 4].reject(&:even?) # => [1, 3]

Ruby Enumerable: De viktigaste skillnaderna

Ruby Enumerable: Kedjekoppling för ökad prestanda

Kedjemetoder för uttrycksfulla pipeliner:

ruby
(1..10)
  .select(&:even?) # [2, 4, 6, 8, 10]
  .map { |n| n ** 2 }   # [4, 16, 36, 64, 100]
  .each { |sq| puts sq }

Exempel från verkligheten:

ruby
active_emails = users
  .select { |u| u[:active] && u[:age] >= 18 }
  .map { |u| u[:email] }

Ruby Enumerable: Tips för bättre prestanda

Ett pass > Två

ruby
# Långsammare: två iterationer
users.map(&:age).select { |a| a > 18 }

# Snabbare: en iteration
users.select { |u| u[:age] > 18 }.map(&:age)

Förkortning för ”symbol till procedur”

ruby
names.map(&:upcase)

Lazy Evaluation för stora/oändliga datamängder

ruby
(1..Float::INFINITY).lazy
  .select(&:even?)
  .map { |n| n * n }
  .first(5)
# => [4, 16, 36, 64, 100]

Ruby Enumerable: Bonusmönster

Säker tolkning med karta + kompakt

ruby
["1", "2", "abc"].map { |s| Integer(s) rescue nil }.compact
# => [1, 2]

Hitta första träff

ruby
admin = users.find { |u| u[:role] == "admin" }  # Bättre än select.first

Samla ihop med each_with_object

ruby
[1, 2, 3].each_with_object({}) { |n, h| h[n] = n * 2 }
# => {1=>2, 2=>4, 3=>6}

Ruby Enumerable: Slutlig checklista

• Användning var och en → biverkningar
• Användning karta → omvandla
• Användning Välj → filter
• Kedja för tydlighetens skull
• Ignorera aldrig returvärden
• Föredra hitta över select.first
• Användning lat för stora/oändliga strömmar

Slutsats:

Modulen `Enumerable` i Ruby är mer än bara en samling metoder – den representerar en filosofi om ren, läsbar och effektiv kod. Genom att bemästra vardera, karta, och Välj, får du möjlighet att:

• Uttryck din avsikt tydligt — inga förvirrande slingor längre.
• Undvik buggar — Returvärdena är viktiga, och dessa metoder säkerställer detta.
• Skriv effektiv kod — operationer i ett steg och lat utvärdering.
• Kedja flytande — skapa kraftfulla datapipelines med en enda rad.

På RailsCarmaett ledande Ruby on Rails utvecklingsföretag, tillämpar vi dessa principer varje dag för att bygga skalbara, underhållsvänliga och eleganta applikationer. Oavsett om det handlar om att filtrera användare, omvandla datamängder eller skicka aviseringar, utnyttjar våra utvecklare kraften i Rubys Enumerable för att skriva kod som är både uttrycksfull och effektiv.

Öva på dessa metoder varje dag, kombinera dem på ett klokt sätt, så kommer du snart att skriva Ruby precis som det är tänkt – elegant, uttrycksfullt och utan ansträngning.

Börja redan idag: öppna din terminal, starta irb och prova dig fram med karta, välj, och var och en på vilken array som helst. Kraften – och RailsCarma-metoden – ligger i dina händer.