Ruby/Iteratory: Różnice pomiędzy wersjami

Podczas pisania kodu potrzebujemy pętli w wielu różnych sytuacjach. W C, kodujemy je używając <tt>for</tt> lub <tt>while</tt>. Na przykład:

 

char *str;

for (str = "abcdefg"; *str != '\0'; str++) {

/* tutaj przetwarzamy znak */

}

 

Składnia pętli <tt>for (...)</tt> z języka C dostarcza pewnej abstrakcji, która pomaga w utworzeniu pętli, ale sprawdzenie czy <tt>*str</tt> nie wskazuje na znak pusty znak wymaga od programisty znajomości szczegółów o wewnętrznej strukturze łańcucha znakowego. Między innymi dlatego, C jest odbierany jako język niskiego poziomu. Języki wyższego poziomu odznaczają się bardziej elastycznym wsparciem iteracji. Rozważ następujący skrypt ''sh'' powłoki systemowej:

 

#!/bin/sh

 

# ... tutaj byłby kod do wykonania dla każdego pliku

done

 

Wszystkie pliki źródłowe i nagłówkowe języka C w bieżącym katalogu są przetwarzane i powłoka systemowa bierze na siebie detale dotyczące wskazywania i podstawiania po kolei wszystkich nazw plików, jedna po drugiej. To chyba działa na wyższym poziomie niż C, nie sądzisz?

Typ <tt>String</tt> Rubiego posiada kilka użytecznych iteratorów:

 

ruby> "abc".each_byte { |c| printf "<%c>", c }

#=> <a><b><c>

 

<tt>each_byte</tt> to iterator wskazujący każdy znak w łańcuchu. Każdy znak jest podstawiany do zmiennej lokalnej <tt>c</tt>. To samo można przełożyć na coś bardziej przypominającego kod C...

 

s = "abc"

i = 0

end

#=> <a><b><c>

 

... jednakże iterator <tt>each_byte</tt> jest koncepcyjnie prostszy, i wydaje się, że działałby nadal nawet gdyby klasa <tt>String</tt> uległa w przyszłości radykalnym modyfikacjom. Dużą zaletą iteratorów jest to, że zachowują one swoje poprawne działanie na przekór takim radykalnym zmianom. Jest to charakterystyczna cecha dobrego kodu w ogólności.

Innym iteratorem klasy <tt>String</tt> jest <tt>each_line</tt>.

 

"a\nb\nc\n".each_line { |l| print l }

#=> a

# b

# c

 

Zadania które wymagałyby dużego wysiłku w C (wyszukiwanie ograniczników linii, generowanie podłańcuchów, itd.) z użyciem iteratorów można wykonać bardzo łatwo.

Instrukcja <tt>for</tt> pojawiająca się w [[Ruby/Struktury sterujące|rozdziale o instrukcjach sterujących]] dokonywała iteracji przez użycie iteratora <tt>each</tt>. Iterator <tt>each</tt> klasy <tt>String</tt> działa w ten sam sposób jak <tt>each_line</tt>, więc przepiszmy powyższy przykład z <tt>for</tt>:

 

for l in "a\nb\nc\n"

print l

# b

# c

 

Możemy używać struktury sterującej <tt>retry</tt> w połączeniu z iterowaną pętlą. Spowoduje ona rozpoczęcie iterowania pętli od początku.

 

c = 0

for i in 0..4

#=> 012

# 01234

 

Zamienienie <tt>retry</tt> na <tt>redo</tt> w powyższym przykładzie spowoduje, że tylko bieżąca iteracja będzie wykonana ponownie, z następującym wynikiem:

<tt>yield</tt> jak już wiemy, jest wyrażeniem, które przenosi sterowanie do bloku kodu który został przekazany do iteratora. Używając instrukcji <tt>yield</tt> i <tt>retry</tt> można zdefiniować iterator który będzie działał mniej więcej jak standardowa pętla <tt>while</tt>.

 

def WHILE(warunek)

return if not warunek

i=0

WHILE(i < 3) { print i; i+=1 } #=> 012

 

Jak więc widzimy, iteratory w Rubim są metodami obsługującymi przekazane do nich domknięcia. Owszem, istnieją pewne ograniczenia, ale możesz pisać własne oryginalne iteratory. Szczególnie, gdy definiujemy nowy typ danych, wygodnie jest zdefiniować odpowiednie iteratory które będą na nim operować. W tym kontekście powyższe przykłady nie są szczególnie użyteczne. Poznajmy zatem bardziej praktyczne iteratory.

Przekazuje do bloku każdy element kolekcji. Zwraca <tt>true</tt>, jeśli blok nigdy nie zwróci <tt>false</tt> (lub <tt>nil</tt>).

 

[1, 2, 5].all? { |element| element <= 5 } #=> true

[1, 2, 5].all? { |element| element <= 4 } #=> false

element < 5

end #=> false

 

Wyjście:

Zwraca <tt>true</tt>, jeśli przekazany do bloku element kiedykolwiek zwróci <tt>true</tt>.

 

[1, 2, 5].any? { |element| element > 5 } # => false

[1, 2, 5].any? { |element| element == 2} # => true

 

==== <tt>collect(map)</tt> ====

Przekazuje do bloku każdy element kolekcji, następnie tworzy nową - z elementów zwracanych przez blok.

 

%w{kot tulipan parowka}.collect { |element| element.upcase }

# => ["KOT", "TULIPAN", "PAROWKA"]

[1, 2, 3].collect { |element| element + 1}

#=> [2, 3, 4]

 

==== <tt>collect!(map!)</tt> ====

Działa jak <tt>collect</tt>, z tą jednak różnicą, że operacji kolekcja dokonuje na sobie, w każdej iteracji zmieniając swoją zawartość.

 

a = [1, 2, 3] #=> [1, 2, 3]

a.collect! { |element| element + 1 } #=> [2, 3, 4]

a #=> [2, 3, 4]

 

==== <tt>delete_if</tt> ====

Usuwa z kolekcji elementy, dla których blok zwraca <tt>true</tt>

 

[1, 2, 3, 4, 5, 6].delete_if { |i| i%2 == 0 } # => [1, 3, 5]

 

==== <tt>detect(find)</tt> ====

Zwraca pierwszy element, dla którego blok zwróci <tt>true</tt>

 

(36..100).detect { |i| i%7 == 0 } # => 42

 

==== <tt>downto</tt> ====

Wykonuje blok, podając w kolejności malejącej liczby od siebie samej do podanej jako parametr.

 

9.downto(0) { |i| print i } #=> 9876543210

 

==== <tt>each</tt> ====

Przekazuje do bloku każdy z elementów kolekcji

 

['pies', 'kot', 'ryba'].each { |word| print word + " " }

(0..9).each { |i| print i }

#=> pies kot ryba 0123456789

 

==== <tt>each_index</tt> ====

Działa jak each, ale przekazuje sam indeks każdego elementu.

 

[3, 6, -5].each_index { |i| print i.to_s + " " }

#=> 0 1 2

 

==== <tt>each_with_index</tt> ====

Przekazuje jednocześnie element i jego indeks do bloku.

 

["jeden", 2, "trzy"].each_with_index do |element, index|

puts "Indeksowi #{index} przyporzadkowalem #{element}"

# Indeksowi 1 przyporzadkowalem 2

# Indeksowi 2 przyporzadkowalem trzy

 

==== <tt>find_all</tt> ====

Zwraca wszystkie elementy kolekcji, dla których blok zwróci <tt>true</tt>.

 

(0..30).find_all { |i| i%9 == 0 } #=> [0, 9, 18, 27]

 

==== <tt>grep</tt> ====

Zwraca elementy spełniające dopasowanie podane jako parametr. Jeśli podano blok, przekazuje do niego tylko te elementy i zwraca tablicę zbudowaną z wartości zwracanych przez blok.

 

# Zwraca wyrazy zawierajace litere 'r'

%w{ruby python perl php}.grep(/r/) do |w|

 

#=> RUBY PERL

 

==== <tt>inject</tt> ====

Przekazuje do bloku każdy element kolekcji. Posiada dodatkowo pamięć, która początkowo jest równa pierwszemu elementowi (lub wartości podanej jako parametr). Po zakończeniu każdej iteracji pamięć jest aktualizowana do wartości zwracanej przez blok.

 

# Zwraca największą liczbę z tablicy

a = [-5, 2, 10, 17, -50]

mem *= element

end #=> 120

 

==== <tt>partition</tt> ====

Zwraca dwie tablice: jedną z elementami, dla których blok zwraca <tt>true</tt> i drugą - z resztą.

 

(1..6).partition { |i| i%2 == 0 } #=> [[2, 4, 6], [1, 3, 5]]

 

==== <tt>reject</tt> ====

Odrzuca z kolekcji wszystkie elementy, dla których blok zwróci <tt>true</tt>.

 

(1..10).reject { |i| i >= 3 and i <= 7 } #=> [1, 2, 8, 9, 10]

 

==== <tt>reject!</tt> ====

Wyrzuca z siebie elementy, dla których blok zwraca <tt>true</tt>.

 

a = (1..10).to_a # => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

a.reject! { |i| i >= 3 and i <= 7 } # => [1, 2, 8, 9, 10]

a # => [1, 2, 8, 9, 10]

 

==== <tt>reverse_each</tt> ====

Działa jak <tt>each</tt> tyle, że podaje elementy w odwrotnej kolejności.

 

(0..9).to_a.reverse_each { |i| print i }

#=> 9876543210

 

==== <tt>step</tt> ====

Przekazuje do bloku wartości od, do - z określonym krokiem.

 

# (1)

0.step(100, 10) { |i| puts i}

# (2)

(0..100).step(10) { |i| puts i }

 

W obu przypadkach wyjście będzie wyglądało tak:

Wykonuje dany blok określoną ilość razy.

 

5.times { puts "Hej!" }

5.times { |i| print "#{i} "}

# Hej!

# 0 1 2 3 4

 

==== <tt>upto</tt> ====

Iteruje blok, przekazując liczby od, do.

 

1.upto(3) { |i| print i }

#=> 123

<noinclude>

{{Nawigacja|Ruby|