データ

foo = [
	{ :hoge => 5, :jitensya => "a" },
	{ :hoge => 3, :jitensya => "b" },
	{ :hoge => 6, :jitensya => "c" },
	{ :hoge => 0, :jitensya => "d" },
	{ :hoge => 9, :jitensya => "e" },
	{ :hoge => 1, :jitensya => "f" },
]

my @foo = (
	{ hoge => 5, jitensya => "a" },
	{ hoge => 3, jitensya => "b" },
	{ hoge => 6, jitensya => "c" },
	{ hoge => 0, jitensya => "d" },
	{ hoge => 9, jitensya => "e" },
	{ hoge => 1, jitensya => "f" },
);

all?

foo.all? {|i| i[:hoge] < 10 } #=> true
foo.all? {|i| i[:hoge] < 5 } #=> false

atode kanngae ru

any?

foo.any? {|i| i[:hoge] < 10 } #=> true
foo.any? {|i| i[:hoge] < 5 } #=> true

atode kanngae ru

collect, map

result = foo.map {|i| i[:hoge] }

@result = map { $_->{hoge} } @foo;

find, detect

result = foo.find {|i| i < 5 }

$result = wakannnai

find_all, select

result = foo.select {|i| i[:hoge] < 5}

@result = grep { $_->{hoge} < 5} @foo;

inject

result = foo.inject("") {|r,i| r << i[:jitensya] } #=> "abcdef"

$result = wakannnai

member?, include?
atode

max

result = foo.max {|a,b| a[:hoge] <=> b[:hoge] }

$result = (sort { $a->{hoge} <=> $b->{hoge} }
           @foo)[-1];

min

result = foo.min {|a,b| a[:hoge] <=> b[:hoge] }

$result = (sort { $a->{hoge} <=> $b->{hoge} }
           @foo)[0];

max_by

result = foo.max_by {|i| i[:hoge] }

$result = (sort { $a->[1] <=> $b->[1] }
           map  { [$_, $_->{hoge} ] }
           @foo)[-1];

min_by

result = foo.min_by {|i| i[:hoge] }

$result = (sort { $a->[1] <=> $b->[1] }
           map  { [$_, $_->{hoge} ] }
           @foo)[0];

partition

reject

sort

%w(5 1 2 7 8).sort #=> ["1", "2", "5", "7", "8"]

@result = sort qw(5 1 2 7 8);

sort_by

result = foo.sort_by {|i| i[:hoge] }

@result = map  { $_->[0] }
             sort { $a->[1] <=> $b->[1] }
             map  { [$_, $_->{hoge} ] }
             @foo;

zip
atode