empty? | -> | blank? |
An array is blank if it‘s empty:
[].blank? # => true [1,2,3].blank? # => false |
||
to_s | -> | to_default_s |
Wraps its argument in an array unless it is already an array (or array-like).
Specifically:
Array.wrap(nil) # => [] Array.wrap([1, 2, 3]) # => [1, 2, 3] Array.wrap(0) # => [0]
This method is similar in purpose to Kernel#Array, but there are some differences:
moves on to try to_a if the returned value is nil, but Array.wrap returns such a nil right away.
raises an exception, while Array.wrap does not, it just returns the value.
The last point is particularly worth comparing for some enumerables:
Array(:foo => :bar) # => [[:foo, :bar]] Array.wrap(:foo => :bar) # => [{:foo => :bar}] Array("foo\nbar") # => ["foo\n", "bar"], in Ruby 1.8 Array.wrap("foo\nbar") # => ["foo\nbar"]
There‘s also a related idiom that uses the splat operator:
[*object]
which returns [nil] for nil, and calls to Array(object) otherwise.
Thus, in this case the behavior is different for nil, and the differences with Kernel#Array explained above apply to the rest of +object+s.
Extracts options from a set of arguments. Removes and returns the last element in the array if it‘s a hash, otherwise returns a blank hash.
def options(*args) args.extract_options! end options(1, 2) # => {} options(1, 2, :a => :b) # => {:a=>:b}
Returns the tail of the array from position.
%w( a b c d ).from(0) # => %w( a b c d ) %w( a b c d ).from(2) # => %w( c d ) %w( a b c d ).from(10) # => %w() %w().from(0) # => %w()
Splits or iterates over the array in number of groups, padding any remaining slots with fill_with unless it is false.
%w(1 2 3 4 5 6 7 8 9 10).in_groups(3) {|group| p group} ["1", "2", "3", "4"] ["5", "6", "7", nil] ["8", "9", "10", nil] %w(1 2 3 4 5 6 7).in_groups(3, ' ') {|group| p group} ["1", "2", "3"] ["4", "5", " "] ["6", "7", " "] %w(1 2 3 4 5 6 7).in_groups(3, false) {|group| p group} ["1", "2", "3"] ["4", "5"] ["6", "7"]
Splits or iterates over the array in groups of size number, padding any remaining slots with fill_with unless it is false.
%w(1 2 3 4 5 6 7).in_groups_of(3) {|group| p group} ["1", "2", "3"] ["4", "5", "6"] ["7", nil, nil] %w(1 2 3).in_groups_of(2, ' ') {|group| p group} ["1", "2"] ["3", " "] %w(1 2 3).in_groups_of(2, false) {|group| p group} ["1", "2"] ["3"]
Backport of Array#sample based on Marc-Andre Lafortune‘s github.com/marcandre/backports/ Returns a random element or n random elements from the array. If the array is empty and n is nil, returns nil. If n is passed and its value is less than 0, it raises an ArgumentError exception. If the value of n is equal or greater than 0 it returns [].
[1,2,3,4,5,6].sample # => 4 [1,2,3,4,5,6].sample(3) # => [2, 4, 5] [1,2,3,4,5,6].sample(-3) # => ArgumentError: negative array size [].sample # => nil [].sample(3) # => []
Divides the array into one or more subarrays based on a delimiting value or the result of an optional block.
[1, 2, 3, 4, 5].split(3) # => [[1, 2], [4, 5]] (1..10).to_a.split { |i| i % 3 == 0 } # => [[1, 2], [4, 5], [7, 8], [10]]
Returns the beginning of the array up to position.
%w( a b c d ).to(0) # => %w( a ) %w( a b c d ).to(2) # => %w( a b c ) %w( a b c d ).to(10) # => %w( a b c d ) %w().to(0) # => %w()
Converts a collection of elements into a formatted string by calling to_s on all elements and joining them:
Blog.all.to_formatted_s # => "First PostSecond PostThird Post"
Adding in the :db argument as the format yields a prettier output:
Blog.all.to_formatted_s(:db) # => "First Post,Second Post,Third Post"
Calls to_param on all its elements and joins the result with slashes. This is used by url_for in Action Pack.
Converts an array into a string suitable for use as a URL query string, using the given key as the param name.
['Rails', 'coding'].to_query('hobbies') # => "hobbies%5B%5D=Rails&hobbies%5B%5D=coding"
Converts the array to a comma-separated sentence where the last element is joined by the connector word. Options:
Returns a string that represents the array in XML by invoking to_xml on each element. Active Record collections delegate their representation in XML to this method.
All elements are expected to respond to to_xml, if any of them does not then an exception is raised.
The root node reflects the class name of the first element in plural if all elements belong to the same type and that‘s not Hash:
customer.projects.to_xml <?xml version="1.0" encoding="UTF-8"?> <projects type="array"> <project> <amount type="decimal">20000.0</amount> <customer-id type="integer">1567</customer-id> <deal-date type="date">2008-04-09</deal-date> ... </project> <project> <amount type="decimal">57230.0</amount> <customer-id type="integer">1567</customer-id> <deal-date type="date">2008-04-15</deal-date> ... </project> </projects>
Otherwise the root element is "records":
[{:foo => 1, :bar => 2}, {:baz => 3}].to_xml <?xml version="1.0" encoding="UTF-8"?> <records type="array"> <record> <bar type="integer">2</bar> <foo type="integer">1</foo> </record> <record> <baz type="integer">3</baz> </record> </records>
If the collection is empty the root element is "nil-classes" by default:
[].to_xml <?xml version="1.0" encoding="UTF-8"?> <nil-classes type="array"/>
To ensure a meaningful root element use the :root option:
customer_with_no_projects.projects.to_xml(:root => "projects") <?xml version="1.0" encoding="UTF-8"?> <projects type="array"/>
By default name of the node for the children of root is root.singularize. You can change it with the :children option.
The options hash is passed downwards:
Message.all.to_xml(:skip_types => true) <?xml version="1.0" encoding="UTF-8"?> <messages> <message> <created-at>2008-03-07T09:58:18+01:00</created-at> <id>1</id> <name>1</name> <updated-at>2008-03-07T09:58:18+01:00</updated-at> <user-id>1</user-id> </message> </messages>