Hur man använder Ruby Each-metoden (med exempel)

Ruby är känt för sin eleganta syntax och sina utvecklarvänliga funktioner, vilket gör det till ett populärt val bland programmerare tack vare sin enkelhet och kraft. En av de mest grundläggande och vanligaste metoderna i Ruby är var och en, en hörnsten i Räknbar modul som gör det möjligt att iterera över samlingar som arrayer, hash-tabeller och intervall. Oavsett om du är nybörjare i Ruby eller vill fördjupa dina kunskaper är det viktigt att behärska var och en Denna metod är avgörande för att skriva effektiv och läsbar kod.

I den här utförliga guiden ska vi titta närmare på Ruby var och en metoden, med fokus på dess syntax, användningsfall, bästa praxis och vanliga fallgropar. Vi kommer att ge praktiska exempel för att visa hur var och en hur det fungerar och hur det kan tillämpas i olika situationer. När du är klar kommer du att ha en grundlig förståelse för var och en och vara redo att på ett effektivt sätt integrera det i dina Ruby-projekt.

Vad är metoden `each` i Ruby?

De var och en metoden är en inbyggd Ruby-metod som finns tillgänglig för objekt som inkluderar Räknbar modul, till exempel arrayer, hash-tabeller, intervall och mängder. Den används för att iterera över varje element i en samling och köra ett kodblock för varje element. Till skillnad från metoder som karta eller välj, som returnerar nya samlingar, var och en är utformad för att hantera biverkningar – den utför en åtgärd för varje element och returnerar den ursprungliga samlingen.

Viktiga egenskaper hos var och en

• Icke-destruktiv: var och en ändrar inte den ursprungliga samlingen, såvida det inte uttryckligen har programmerats att göra det inom blocket.
• Med fokus på biverkningar: Den används vanligtvis för åtgärder som utskrift, uppdatering av externt tillstånd eller utförande av åtgärder utan att resultaten samlas in.
• Returnerar den ursprungliga samlingen: Efter iterationen, var och en returnerar den samling som metoden anropades på, inte ett nytt objekt.

Syntax

Den grundläggande syntaxen för var och en är:

ruby
collection.each { |element| action }

eller genom att använda do...end blocksyntax för flerradiga block:

ruby
collection.each do |element|
    #-åtgärd
end

Här:

• samling är det objekt som du går igenom (t.ex. en array, en hash eller ett intervall).
• |element| återger varje objekt i samlingen som var och en upprepar.
• åtgärd är den kod som körs för varje element.
• Metoden returnerar originalet samling.

Du kan också använda var och en utan ett block genom att skicka en metod eller en proc, men användning med block är vanligast.

Varför använda metoden `each` i Ruby?

De var och en metoden är ett grundläggande verktyg i Ruby för att iterera över samlingar. Den erbjuder flera fördelar:

• Enkelhet: Ger ett överskådligt och lättläst sätt att gå igenom element i en slinga utan att behöva hantera index manuellt.
• Flexibilitet: Fungerar med alla objekt som går att räkna upp, från arrayer till hash-tabeller och anpassade samlingar.
• Funktionell stil: Främjar ett funktionellt programmeringssätt genom att lägga tonvikten på iteration utan att kräva uttryckliga slingor.

Låt oss titta på några praktiska exempel för att se var och en i praktiken.

Grundläggande exempel på metoden `each` i Ruby

Exempel 1: Iterera över en array

Anta att du vill skriva ut varje element i en array:

ruby
fruits = ["äpple", "banan", "apelsin"]
fruits.each { |fruit| puts fruit }
# Utdata:
# äpple
# banan
# apelsin

I detta exempel:

• var och en genomgår frukter array.
• Blocket skriver ut varje element med hjälp av sätter.
• Metoden returnerar den ursprungliga arrayen: ["äpple", "banan", "apelsin"].

Exempel 2: Utföra beräkningar

Du kan använda var och en för att utföra åtgärder som att uppdatera en löpande summa:

ruby
numbers = [1, 2, 3, 4]
sum = 0
numbers.each { |n| sum += n }
puts sum # Utdata: 5

Här, var och en genomgår siffror, och lägga till varje element till summa. Observera att var och en Den returnerar inte själva summan, utan den ursprungliga arrayen.

Exempel 3: Ändring av externt tillstånd

var och en är perfekt för att uppdatera externa objekt, till exempel för att fylla i en hash:

ruby
words = ["cat", "dog", "bird"]
word_lengths = {}
words.each { |word| word_lengths[word] = word.length }
puts word_lengths # Output: {"cat"=>3, "dog"=>3, "bird"=>4}

I det här fallet.., var och en genomgår ord, och blocket lägger till nyckel-värdepar till ordlängder.

Använda Ruby Each med olika samlingar

Exempel 4: Iterera över en hash

När den används tillsammans med en hash, var och en ger nyckel-värdepar:

ruby
priser = { äpple: 1, banan: 2, apelsin: 3 }
priser.each do |frukt, pris|
    puts "#{frukt} kostar $#{pris}"
end
# Utdata:
# äpple kostar $1
# banan kostar $2
# apelsin kostar $3

Här, var och en paketerar upp varje hash-post till frukt och pris, som används i blocket.

Exempel 5: Iterera över ett intervall

Du kan använda var och en med en rad för att utföra åtgärder på en talföljd:

ruby
(1..5).each { |n| puts n * 2 }
# Utdata:
# 2
# 4
# 6
# 8
# 10

Sortimentet (1..5) genererar siffrorna 1 till 5, och var och en dubblar och skriver ut var och en.

Exempel 6: Iterera över en mängd

Om du använder Rubys Uppsättning klass (tillgänglig via require 'set'), var och en fungerar på liknande sätt:

ruby
require 'set'
set = Set.new([1, 2, 3])
set.each { |n| puts n + 1 }
# Utdata:
# 2
# 3
# 4

Avancerade användningsfall

Exempel 7: Att kedja samman ”each” med andra metoder

Medan var och en returnerar den ursprungliga samlingen, vilket gör att du kan kedja ihop den med andra metoder för förbehandling. Du kan till exempel filtrera en array med välj och använd sedan var och en:

ruby
numbers = [1, 2, 3, 4, 5, 6]
numbers.select { |n| n.even? }.each { |n| puts n * 2 }
# Utdata:
# 4
# 8
# 12

Här, välj filtrerar bort jämna tal, och var och en skriver ut deras dubbla värden.

Exempel 8: Inbäddad iteration

Du kan kapsla in var och en anrop för att bearbeta kapslade samlingar:

ruby
nested = [[1, 2], [3, 4], [5, 6]]
nested.each do |subarray|
    subarray.each { |n| puts n * 2 }
end
# Utdata:
# 2
# 4
# 6
# 8
# 10
# 12

Varje delmatris bearbetas av den yttre var och en, och dess beståndsdelar bearbetas av den inre var och en.

Exempel 9: Att använda ”each” med objekt

Om du har en samling av anpassade objekt, var och en man kan anropa metoder på dem:

ruby
class Person
    attr_reader :name
    def initialize(name)
 @name = name
    end
end

people = [Person.new("Alice"), Person.new("Bob")]
people.each { |person| puts person.name }
# Utdata:
# Alice
# Bob

Här, var och en genomgår en array av Person objekt, och få åtkomst till deras namn egenskaper.

Var och en jämfört med övriga metoder för uppräkning

Att välja var och en Jämför det gärna med andra metoder för enumerable i Ruby:

• karta: Omvandlar element och returnerar en ny array. Använd karta när du behöver en omformad samling, inte biverkningar.
• välj: Filtrerar element utifrån ett villkor och returnerar en ny array. Använd välj för filtrering.
• minska eller injicera: Sammanfogar element till ett enda värde. Använd minska för aggregeringar som summor eller produkter.
• var och en: Perfekt för biverkningar som utskrift, uppdatering av externt tillstånd eller utförande av åtgärder utan att samla in resultat.

Till exempel:

ruby
numbers = [1, 2, 3]
# Användning av each (biverkning, returnerar den ursprungliga arrayen)
numbers.each { |n| puts n * 2 } # Skriver ut 2, 4, 6, returnerar [1, 2, 3]

# Användning av `map` (transformation, returnerar en ny array)
doubled = numbers.map { |n| n * 2 } # Returnerar [2, 4, 6]

Bästa praxis för användning av Ruby Each

• Användning vid biverkningar: Reserv var och en för åtgärder som utskrift, loggning eller uppdatering av externt tillstånd, inte för att omvandla data.
• Håll blocken enkla: Se till att blockets logik är tydlig och fokuserad. Komplex logik bör flyttas ut till separata metoder.
• Undvik onödiga returer: Eftersom var och en returnerar den ursprungliga samlingen; lita inte på dess returvärde vid omvandlingar – använd istället `map`.
• Var försiktig med mutationer: Om blocket ändrar objekt som går att ändra, se till att detta är avsiktligt för att undvika oväntade bieffekter.
• Parametrar för hävstångsblock: Använd beskrivande namn på blockparametrar (t.ex., |frukt| istället för |x|) för att förbättra läsbarheten.
• Kombinera med andra metoder: Användning var och en som en del av en kedja när förbehandling krävs, men se till att kedjan förblir läsbar.

Vanliga fallgropar

Fallgrop 1: Att ändra den ursprungliga samlingen

Medan var och en Även om den i sig är icke-destruktiv kan blocket ändra muterbara objekt:

ruby
strings = ["hello", "world"]
strings.each { |s| s.upcase! }
puts strings # Utdata: ["HELLO", "WORLD"]

Här, upcase! ändrar de ursprungliga strängarna. För att undvika detta bör du använda icke-destruktiva metoder som upcase:

ruby
strings = ["hello", "world"]
strings.each { |s| puts s.upcase }
puts strings # Utdata: ["hello", "world"]

Fallgrop 2: Att förvänta sig en förändrad samling

Eftersom var och en returnerar den ursprungliga samlingen; att använda den för omvandlingar kan leda till fel:

ruby
numbers = [1, 2, 3]
result = numbers.each { |n| n * 2 }
puts result # Utdata: [1, 2, 3] (inte [2, 4, 6])

Användning karta istället för transformationer:

ruby
result = numbers.map { |n| n * 2 } # Utdata: [2, 4, 6]

Fallgrop 3: Att överanvända `each` för komplex logik

Undvik att klämma in komplex logik i var och en block. Till exempel:

ruby
numbers = [1, 2, 3]
results = []
numbers.each do |n|
    if n.even?
      results << n * 2
    else
      results << n + 1
    end
end

Det här hanteras bättre med map:

ruby
results = numbers.map { |n| n.even? ? n * 2 : n + 1 }

Praktiska tillämpningar

De var och en Metoden används ofta i praktiska Ruby-applikationer, bland annat:

• Konsolutdata: Skriver ut data till konsolen för felsökning eller användarinteraktion.
• Databehandling: Uppdatering av externa system, till exempel att spara poster i en databas.
• Webbutveckling: Iterera över modelldata i Ruby on Rails för att rendera vyer.
• Filhantering: Läsa in och bearbeta rader i en fil.

I en Rails-applikation kan man till exempel använda var och en för att visa en lista över användare:

ruby
@users = User.all
@users.each do |user|
    puts "
#{user.name}
"
end

Detta genererar HTML-listposter för varje användare.

Användning av ”each” tillsammans med uppräknare

När var och en om den anropas utan ett block, returnerar den en Räknare, vilket möjliggör lat iteration eller kedjekoppling med andra metoder:

ruby
numbers = [1, 2, 3]
enum = numbers.each
enum.each { |n| puts n * 2 }
# Utdata:
# 2
# 4
# 6

Detta är användbart vid avancerade iterationsmönster eller när man vill överföra enumeratorn till en annan metod.

Överväganden om prestanda

När det gäller stora samlingar, var och en är effektivt eftersom det inte skapar en ny samling (till skillnad från karta). Om du däremot utför resurskrävande beräkningar i blocket bör du överväga att optimera logiken eller använda tekniker för parallellbearbetning (t.ex. med Rubys parallell (gem) för mycket stora datamängder.

Felsökning med Ruby Each

var och en är ovärderligt vid felsökning. Du kan infoga sätter eller p satser i blocket för att undersöka element:

ruby
data = ["apple", 42, :symbol]
data.each { |item| p item.class }
# Utdata:
# Sträng
# Heltal
# Symbol

Detta underlättar verifieringen av typerna eller värdena i en samling.

Slutsats

Ruby var och en Metoden är ett grundläggande och mångsidigt verktyg för att iterera över samlingar, vilket gör den idealisk för uppgifter som att skriva ut värden, uppdatera tillstånd eller bearbeta data på ett effektivt sätt. Med en tydlig förståelse för dess syntax, användningsfall och bästa praxis kan utvecklare skriva ren och underhållsbar Ruby-kod som skalar väl för praktiska tillämpningar. Från enkla array-iterationer till komplexa nästlade slingor, var och en erbjuder ett tillförlitligt och enkelt sätt att arbeta med objekt som går att räkna upp.

På Carmatec, lägger vi stor vikt vid att utveckla robusta och skalbara lösningar genom att följa bästa praxis inom Utveckling med Ruby och Rails. Genom att öva med praktiska exempel och tillämpa beprövade tekniker kommer du att vara väl förberedd för att använda var och en på ett effektivt sätt i dina projekt. Oavsett om du utvecklar funktionsrika webbapplikationer, hanterar komplexa dataflöden eller effektiviserar felsökningen, var och en kommer att förbli en viktig del av dina Ruby-verktyg.