ruby 数据过滤相关操作
Module Enumerable In: enum.c
lib/set.rb
lib/soap/property.rb
ext/enumerator/enumerator.c
The Enumerable mixin provides collection classes with several traversal and searching methods, and with the ability to sort . The class must provide a method each , which yields successive members of the collection. If Enumerable#max , min , or sort is used, the objects in the collection must also implement a meaningful <=> operator, as these methods rely on an ordering between members of the collection.
Methods
all? any? collect detect each_cons each_slice each_with_index entries enum_cons enum_slice enum_with_index find find_all grep include? inject inject map max member? min partition reject select sort sort_by to_a to_set zip
Classes and Modules Class Enumerable::Enumerator
Public Instance methods
enum.all? [{|obj| block } ] => true or false
Passes each element of the collection to the given block. The method returns true if the block never returns false or nil . If the block is not given, Ruby adds an implicit block of {|obj| obj} (that is all? will return true only if none of the collection members are false or nil .)
%w{ ant bear cat}.all? {|word| word.length >= 3} #=> true
%w{ ant bear cat}.all? {|word| word.length >= 4} #=> false
[ nil, true, 99 ].all? #=> false
enum.any? [{|obj| block } ] => true or false
Passes each element of the collection to the given block. The method returns true if the block ever returns a value other than false or nil . If the block is not given, Ruby adds an implicit block of {|obj| obj} (that is any? will return true if at least one of the collection members is not false or nil .
%w{ ant bear cat}.any? {|word| word.length >= 3} #=> true
%w{ ant bear cat}.any? {|word| word.length >= 4} #=> true
[ nil, true, 99 ].any? #=> true
enum.collect {| obj | block } => array
enum.map {| obj | block } => array
Returns a new array with the results of running block once for every element in enum .
(1..4).collect {|i| i*i } #=> [1, 4, 9, 16]
(1..4).collect { "cat" } #=> ["cat", "cat", "cat", "cat"]
enum.detect(ifnone = nil) {| obj | block } => obj or nil
enum.find(ifnone = nil) {| obj | block } => obj or nil
Passes each entry in enum to block . Returns the first for which block is not false . If no object matches, calls ifnone and returns its result when it is specified, or returns nil
(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_cons(n) {...}
Iterates the given block for each array of consecutive <n> elements.
e.g.:
(1..10).each_cons(3) {|a| p a}
# outputs below
[1, 2, 3]
[2, 3, 4]
[3, 4, 5]
[4, 5, 6]
[5, 6, 7]
[6, 7, 8]
[7, 8, 9]
[8, 9, 10]
e.each_slice(n) {...}
Iterates the given block for each slice of <n> elements.
e.g.:
(1..10).each_slice(3) {|a| p a}
# outputs below
[1, 2, 3]
[4, 5, 6]
[7, 8, 9]
[10]
enum.each_with_index {|obj, i| block } → enum
Calls block with two arguments, the item and its index, for each item in enum .
hash = Hash.new
%w(cat dog wombat).each_with_index {|item, index|
hash[item] = index
}
hash #=> {"cat"=>0, "wombat"=>2, "dog"=>1}
enum.to_a => array
enum.entries => array
Returns an array containing the items in enum .
(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]]
e.enum_cons(n)
Returns Enumerable::Enumerator.new (self, : each_cons , n).
e.enum_slice(n)
Returns Enumerable::Enumerator.new (self, : each_slice , n).
enum_with_index
Returns Enumerable::Enumerator.new (self, : each_with_index ).
enum.detect(ifnone = nil) {| obj | block } => obj or nil
enum.find(ifnone = nil) {| obj | block } => obj or nil
Passes each entry in enum to block . Returns the first for which block is not false . If no object matches, calls ifnone and returns its result when it is specified, or returns nil
(1..10).detect {|i| i % 5 == 0 and i % 7 == 0 } #=> nil
(1..100).detect {|i| i % 5 == 0 and i % 7 == 0 } #=> 35
enum.find_all {| obj | block } => array
enum.select {| obj | block } => array
Returns an array containing all elements of enum for which block is not false (see also Enumerable#reject ).
(1..10).find_all {|i| i % 3 == 0 } #=> [3, 6, 9]
enum.grep(pattern) => array
enum.grep(pattern) {| obj | block } => array
Returns an array of every element in enum for which Pattern === element . If the optional block is supplied, each matching element is passed to it, and the block‘s result is stored in the output array.
(1..100).grep 38..44 #=> [38, 39, 40, 41, 42, 43, 44]
c = IO.constants
c.grep(/SEEK/) #=> ["SEEK_END", "SEEK_SET", "SEEK_CUR"]
res = c.grep(/SEEK/) {|v| IO.const_get(v) }
res #=> [2, 0, 1]
enum.include?(obj) => true or false
enum.member?(obj) => true or false
Returns true if any member of enum equals obj . Equality is tested using == .
IO.constants.include? "SEEK_SET" #=> true IO.constants.include? "SEEK_NO_FURTHER" #=> false
inject (init) {|result, item| ...}
enum.inject(initial) {| memo, obj | block } => obj
enum.inject {| memo, obj | block } => obj
Combines the elements of enum by applying the block to an accumulator value ( memo ) and each element in turn. At each step, memo is set to the value returned by the block. The first form lets you supply an initial value for memo . The second form uses the first element of the collection as a the initial value (and skips that element while iterating).
# Sum some numbers
(5..10).inject {|sum, n| sum + n } #=> 45
# Multiply some numbers
(5..10).inject(1) {|product, n| product * n } #=> 151200
# find the longest word
longest = %w{ cat sheep bear }.inject do |memo,word|
memo.length > word.length ? memo : word
end
longest #=> "sheep"
# find the length of the longest word
longest = %w{ cat sheep bear }.inject(0) do |memo,word|
memo >= word.length ? memo : word.length
end
longest #=> 5
enum.collect {| obj | block } => array
enum.map {| obj | block } => array
Returns a new array with the results of running block once for every element in enum .
(1..4).collect {|i| i*i } #=> [1, 4, 9, 16]
(1..4).collect { "cat" } #=> ["cat", "cat", "cat", "cat"]
enum.max => obj
enum.max {|a,b| block } => obj
Returns the object in enum with the maximum value. The first form assumes all objects implement Comparable ; the second uses the block to return a <=> b .
a = %w(albatross dog horse)
a.max #=> "horse"
a.max {|a,b| a.length <=> b.length } #=> "albatross"
enum.include?(obj) => true or false
enum.member?(obj) => true or false
Returns true if any member of enum equals obj . Equality is tested using == .
IO.constants.include? "SEEK_SET" #=> true IO.constants.include? "SEEK_NO_FURTHER" #=> false
enum.min => obj
enum.min {| a,b | block } => obj
Returns the object in enum with the minimum value. The first form assumes all objects implement Comparable ; the second uses the block to return a <=> b .
a = %w(albatross dog horse)
a.min #=> "albatross"
a.min {|a,b| a.length <=> b.length } #=> "dog"
enum.partition {| obj | block } => [ true_array, false_array ]
Returns two arrays, the first containing the elements of enum for which the block evaluates to true, the second containing the rest.
(1..6).partition {|i| (i&1).zero?} #=> [[2, 4, 6], [1, 3, 5]]
enum.reject {| obj | block } => array
Returns an array for all elements of enum for which block is false (see also Enumerable#find_all ).
(1..10).reject {|i| i % 3 == 0 } #=> [1, 2, 4, 5, 7, 8, 10]
enum.find_all {| obj | block } => array
enum.select {| obj | block } => array
Returns an array containing all elements of enum for which block is not false (see also Enumerable#reject ).
(1..10).find_all {|i| i % 3 == 0 } #=> [3, 6, 9]
enum.sort => array
enum.sort {| a, b | block } => array
Returns an array containing the items in enum sorted, either according to their own <=> method, or by using the results of the supplied block. The block should return -1, 0, or +1 depending on the comparison between a and b . As of Ruby 1.8, the method Enumerable#sort_by implements a built-in Schwartzian Transform, useful when key computation or comparison is expensive..
%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]
enum.sort_by {| obj | block } => array
Sorts enum using a set of keys generated by mapping the values in enum through the given block.
%w{ apple pear fig }.sort_by {|word| word.length}
#=> ["fig", "pear", "apple"]
The current implementation of sort_by generates an array of tuples containing the original collection element and the mapped value. This makes sort_by fairly expensive when the keysets are simple
require 'benchmark'
include Benchmark
a = (1..100000).map {rand(100000)}
bm(10) do |b|
b.report("Sort") { a.sort }
b.report("Sort by") { a.sort_by {|a| a} }
end
produces:
user system total real Sort 0.180000 0.000000 0.180000 ( 0.175469) Sort by 1.980000 0.040000 2.020000 ( 2.013586)
However, consider the case where comparing the keys is a non-trivial operation. The following code sorts some files on modification time using the basic sort method.
files = Dir["*"]
sorted = files.sort {|a,b| File.new(a).mtime <=> File.new(b).mtime}
sorted #=> ["mon", "tues", "wed", "thurs"]
This sort is inefficient: it generates two new File objects during every comparison. A slightly better technique is to use the Kernel#test method to generate the modification times directly.
files = Dir["*"]
sorted = files.sort { |a,b|
test(?M, a) <=> test(?M, b)
}
sorted #=> ["mon", "tues", "wed", "thurs"]
This still generates many unnecessary Time objects. A more efficient technique is to cache the sort keys (modification times in this case) before the sort . Perl users often call this approach a Schwartzian Transform, after Randal Schwartz. We construct a temporary array, where each element is an array containing our sort key along with the filename. We sort this array, and then extract the filename from the result.
sorted = Dir["*"].collect { |f|
[test(?M, f), f]
}.sort.collect { |f| f[1] }
sorted #=> ["mon", "tues", "wed", "thurs"]
This is exactly what sort_by does internally.
sorted = Dir["*"].sort_by {|f| test(?M, f)}
sorted #=> ["mon", "tues", "wed", "thurs"]
enum.to_a => array
enum.entries => array
Returns an array containing the items in enum .
(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]]
to_set (klass = Set, *args, &block)
Makes a set from the enumerable object with given arguments. Needs to +require "set"+ to use this method.
enum.zip(arg, ...) => array
enum.zip(arg, ...) {|arr| block } => nil
Converts any arguments to arrays, then merges elements of enum with corresponding elements from each argument. This generates a sequence of enum#size n -element arrays, where n is one more that the count of arguments. If the size of any argument is less than enum#size , nil values are supplied. If a block given, it is invoked for each output array, otherwise an array of arrays is returned.
a = [ 4, 5, 6 ] b = [ 7, 8, 9 ] (1..3).zip(a, b) #=> [[1, 4, 7], [2, 5, 8], [3, 6, 9]] "cat\ndog".zip([1]) #=> [["cat\n", 1], ["dog", nil]] (1..3).zip #=> [[1], [2], [3]]