|
instansmetoder
|
|
collect
|
enumObj.collect {| obj | block }
-> anArray
|
|
Returnerer et nytt Array-objekt som inneholder resultatene av å kjøre block
en gang for hvert element i enumObj.
(1..4).collect {|i| i*i }
|
» |
[1, 4, 9, 16]
|
(1..4).collect { "cat" }
|
» |
["cat", "cat", "cat", "cat"]
|
|
|
detect
|
enumObj.detect {| obj | block }
-> anObject eller nil
|
|
Sender hvert element i fra enumObj til block.
Returnerer det første elementet hvor block ikke gir false.
Returnerer nil dersom intet objekt passer.
(1..10).detect {|i| i % 5 == 0 and i % 7 == 0 }
|
» |
nil
|
(1..100).detect {|i| i % 5 == 0 and i % 7 == 0 }
|
» |
35
|
|
|
each_with_index
|
enumObj.each_with_index
{| obj, i | block }
-> nil
|
|
Kaller block med to argumenter, elementet og dets indeks,
for hvert element i enumObj.
hash = Hash.new
|
%w(cat dog wombat).each_with_index {|item, index|
|
hash[item] = index
|
}
|
hash
|
» |
{"dog"=>1, "cat"=>0, "wombat"=>2}
|
|
|
entries
|
enumObj.entries -> anArray
|
|
Synonym for
Enumerable#to_a
.
|
|
find
|
enumObj.find {| obj | block }
-> anObject eller nil
|
|
Synonym for
Enumerable#detect
.
|
|
find_all
|
enumObj.find_all {| obj | block }
-> anArray
|
|
Returnerer et Array-objekt som inneholder alle elementene fra enumObj
hvor block ikke gir false (se også
Enumerable#reject
).
(1..10).find_all {|i| i % 3 == 0 }
|
» |
[3, 6, 9]
|
|
|
grep
|
enumObj.grep( pattern ) -> anArray
enumObj.grep( pattern ) {| obj | block }
-> anArray
|
|
Returnerer et Array-objekt som inneholder hvert element i fra enumObj
hvor Pattern === element slår til. Dersom en valgfri block
er angitt, vil hvert element som passer bli sendt videre til blokken og
resultatet fra blokken vil lagres i det resulterende Array-objektet.
(1..100).grep 38..44
|
» |
[38, 39, 40, 41, 42, 43, 44]
|
c = IO.constants
|
c.grep(/SEEK/)
|
» |
["SEEK_END", "SEEK_CUR", "SEEK_SET"]
|
res = c.grep(/SEEK/) {|v| IO.const_get(v) }
|
res
|
» |
[2, 1, 0]
|
|
|
include?
|
enumObj.include?( anObject )
-> true eller false
|
|
Returns true if any member of enumObj equals
anObject. Equality is tested using ==.
IO.constants.include? "SEEK_SET"
|
» |
true
|
IO.constants.include? "SEEK_NO_FURTHER"
|
» |
false
|
|
|
map
|
enumObj.map {| obj | block }
-> anArray
|
|
Synonym for
Enumerable#collect
.
|
|
max
|
enumObj.max -> anObject
enumObj.max {| a,b | block }
-> anObject
|
|
Returnerer det objektet i enumObj som har høyest verdi.
Den første varianten antar at alle objektene implementerer
Comparable; den andre bruker blokken til å regne ut
a <=> b.
a = %w(albatross dog horse)
|
a.max
|
» |
"horse"
|
a.max {|a,b| a.length <=> b.length }
|
» |
"albatross"
|
|
|
member?
|
enumObj.member?( anObject ) -> true eller false
|
|
Synonym for
Enumerable#include?
.
|
|
min
|
enumObj.min -> anObject
enumObj.min {| a,b | block }
-> anObject
|
|
Returnerer det objektet i enumObj som har lavest verdi.
Den første varianten antar at alle objektene implementerer
Comparable; den andre bruker blokken til å regne ut
a <=> b.
a = %w(albatross dog horse)
|
a.min
|
» |
"albatross"
|
a.min {|a,b| a.length <=> b.length }
|
» |
"dog"
|
|
|
reject
|
enumObj.reject {| obj | block }
-> anArray
|
|
Returnerer et Array-objekt med alle elementene i fra enumObj hvor
block gir false (se også
Enumerable#find_all
).
(1..10).reject {|i| i % 3 == 0 }
|
» |
[1, 2, 4, 5, 7, 8, 10]
|
|
|
select
|
enumObj.select {| obj | block }
-> anArray
|
|
Synonym for
Enumerable#find_all
.
|
|
sort
|
enumObj.sort -> anArray
enumObj.sort {| a, b | block }
-> anArray
|
|
Returnerer et Array-objekt som inneholder objektene i fra enumObj sortert, enten utifra objektenes egne <=> metoder, eller ved å benytte resultatet fra
den angitte blokken. Blokken bør returnere -1, 0 eller +1 beroende på
sammenligningen mellom a og b.
%w(rhea kea flea).sort
|
» |
["flea", "kea", "rhea"]
|
(1..10).sort {|a,b| b <=> a}
|
» |
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
|
Den følgende kodebiten sorterer noen filer ut fra tidspunktet de sist ble modifisert.
files = Dir["*"]
|
sorted = files.sort {|a,b| File.new(a).mtime <=> File.new(b).mtime}
|
sorted
|
» |
["mon", "tues", "wed", "thurs"]
|
Denne sorteringen er ineffektiv: den genererer to nye File-objekter
for hver sammenligning. En litt bedre teknikk er å bruke
Kernel#test
-metoden til å generere modifikasjonstidspunktene direkte.
files = Dir["*"]
|
sorted = files.sort { |a,b|
|
test(?M, a) <=> test(?M, b)
|
}
|
sorted
|
» |
["mon", "tues", "wed", "thurs"]
|
Dette genererer fremdeles mange unødvendige Time-objekter.
En enda mer effektiv teknikk går ut på å cache nøklene vi sorterer på
(modifikasjonstidspunktene i dette tilfellet) før vi sorterer.
Perlbrukere kaller ofte denne angripsmåten for en
Schartzisk transformering ("Schwartzian Transform"),
etter Randal Schwartz. Vi lager en midlertidig Array hvor hvert element er en mindre Array
som både holder vår sorteringsnøkkel og filnavnet. Vi sorterer denne for så å trekke ut filnavnene fra resultatet.
sorted = Dir["*"].collect { |f|
|
[test(?M, f), f]
|
}.sort.collect { |f| f[1] }
|
sorted
|
» |
["mon", "tues", "wed", "thurs"]
|
|
|
to_a
|
enumObj.to_a -> anArray
|
|
Returnerer en Array med alle elementene i enumObj.
(1..7).to_a
|
» |
[1, 2, 3, 4, 5, 6, 7]
|
{ 'a'=>1, 'b'=>2, 'c'=>3 }.to_a
|
» |
[["a", 1], ["b", 2], ["c", 3]]
|
|
