Class: Array - Noobkit

Arrays are ordered, integer-indexed collections of any object. Array indexing starts at 0, as in C or Java. A negative index is assumed to be relative to the end of the array—that is, an index of -1 indicates the last element of the array, -2 is the next to last element in the array, and so on.

Public Methods
\|	Set Union—Returns a new array by joining this array with
&	Set Intersection—Returns a new array containing elements common to the two arrays, with no duplicates.
*	Repetition—With a String argument, equivalent to self.join(str). Otherwise, returns a new array built by concatenating the int copies of self.
+	Concatenation—Returns a new array built by concatenating the two arrays together to produce a third array.
-	Array Difference—Returns a new array that is a copy of the original array, removing any items that also appear in other_array. (If you need set-like behavior, see the library class Set.)
<<	Append—Pushes the given object on to the end of this array. This
<=>	Comparison—Returns an integer (-1, 0, or +1) if this array is less than, equal to, or greater than other_array. Each object in each array is compared (using <=>). If any value isn’t equal, then that inequality is the return value. If all the values found are equal, then the return is based on a comparison of the array lengths. Thus, two arrays are ``equal’’ according to `Array#<=>` if and only if they have the same length and the value of each element is equal to the value of the corresponding element in the other array.
==	Equality—Two arrays are equal if they contain the same number of elements and if each element is equal to (according to Object.==) the corresponding element in the other array.
[]	Returns a new array populated with the given objects.
[]	Element Reference—Returns the element at index,
[]=	Element Assignment—Sets the element at index, or replaces a subarray starting at start and continuing for length elements, or replaces a subarray specified by range. If indices are greater than the current capacity of the array, the array grows automatically. A negative indices will count backward from the end of the array. Inserts elements if length is zero. If `nil` is used in the second and third form, deletes elements from self. An `IndexError` is raised if a negative index points past the beginning of the array. See also `Array#push`, and `Array#unshift`.
assoc	Searches through an array whose elements are also arrays comparing obj with the first element of each contained array using obj.==. Returns the first contained array that matches (that is, the first associated array), or `nil` if no match is found. See also `Array#rassoc`.
at	Returns the element at index. A negative index counts from the end of self. Returns `nil` if the index is out of range. See also `Array#[]`. (`Array#at` is slightly faster than `Array#[]`, as it does not accept ranges and so on.)
clear	Removes all elements from self.
collect	Invokes block once for each element of self. Creates a new array containing the values returned by the block. See also `Enumerable#collect`.
collect!	Invokes the block once for each element of self, replacing the element with the value returned by block. See also `Enumerable#collect`.
compact	Returns a copy of self with all `nil` elements removed.
compact!	Removes `nil` elements from array. Returns `nil` if no changes were made.
concat	Appends the elements in other_array to self.
delete	Deletes items from self that are equal to obj. If the item is not found, returns `nil`. If the optional code block is given, returns the result of block if the item is not found.
delete_at	Deletes the element at the specified index, returning that element, or `nil` if the index is out of range. See also `Array#slice!`.
delete_if	Deletes every element of self for which block evaluates to `true`.
each	Calls block once for each element in self, passing that element as a parameter.
each_index	Same as `Array#each`, but passes the index of the element instead of the element itself.
empty?	Returns `true` if self array contains no elements.
eql?	Returns `true` if array and other are the same object, or are both arrays with the same content.
fetch	Tries to return the element at position index. If the index lies outside the array, the first form throws an `IndexError` exception, the second form returns default, and the third form returns the value of invoking the block, passing in the index. Negative values of index count from the end of the array.
fill	The first three forms set the selected elements of self (which may be the entire array) to obj. A start of `nil` is equivalent to zero. A length of `nil` is equivalent to self.length. The last three forms fill the array with the value of the block. The block is passed the absolute index of each element to be filled.
first	Returns the first element, or the first `n` elements, of the array. If the array is empty, the first form returns `nil`, and the second form returns an empty array.
flatten	Returns a new array that is a one-dimensional flattening of this array (recursively). That is, for every element that is an array, extract its elements into the new array.
flatten!	Flattens self in place. Returns `nil` if no modifications were made (i.e., array contains no subarrays.)
frozen?	Return `true` if this array is frozen (or temporarily frozen while being sorted).
hash	Compute a hash-code for this array. Two arrays with the same content will have the same hash code (and will compare using `eql?`).
include?	Returns `true` if the given object is present in self (that is, if any object `==` anObject), `false` otherwise.
index	Returns the index of the first object in self such that is `==` to obj. Returns `nil` if no match is found.
indexes	Deprecated; use `Array#values_at`.
indices	Deprecated; use `Array#values_at`.
initialize_copy	Replaces the contents of self with the contents of other_array, truncating or expanding if necessary.
insert	Inserts the given values before the element with the given index (which may be negative).
inspect	Create a printable version of array.
join	Returns a string created by converting each element of the array to a string, separated by sep.
last	Returns the last element(s) of self. If the array is empty, the first form returns `nil`.
length	Returns the number of elements in self. May be zero.
map	Invokes block once for each element of self. Creates a new array containing the values returned by the block. See also `Enumerable#collect`.
map!	Invokes the block once for each element of self, replacing the element with the value returned by block. See also `Enumerable#collect`.
new	Returns a new array. In the first form, the new array is
nitems	Returns the number of non-`nil` elements in self. May be zero.
pack	Packs the contents of arr into a binary sequence according to the directives in aTemplateString (see the table below) Directives ``A,’’ ``a,’’ and ``Z’’ may be followed by a count, which gives the width of the resulting field. The remaining directives also may take a count, indicating the number of array elements to convert. If the count is an asterisk (```*`’’), all remaining array elements will be converted. Any of the directives ```sSiIlL`’’ may be followed by an underscore (```_`’’) to use the underlying platform’s native size for the specified type; otherwise, they use a platform-independent size. Spaces are ignored in the template string. See also `String#unpack`.
pop	Removes the last element from self and returns it, or `nil` if the array is empty.
push	Append—Pushes the given object(s) on to the end of this array. This
rassoc	Searches through the array whose elements are also arrays. Compares key with the second element of each contained array using `==`. Returns the first contained array that matches. See also `Array#assoc`.
reject	Returns a new array containing the items in self for which the block is not true.
reject!	Equivalent to `Array#delete_if`, deleting elements from self for which the block evaluates to true, but returns `nil` if no changes were made. Also see `Enumerable#reject`.
replace	Replaces the contents of self with the contents of other_array, truncating or expanding if necessary.
reverse	Returns a new array containing self’s elements in reverse order.
reverse!	Reverses self in place.
reverse_each	Same as `Array#each`, but traverses self in reverse order.
rindex	Returns the index of the last object in array `==` to obj. Returns `nil` if no match is found.
select	Invokes the block passing in successive elements from array, returning an array containing those elements for which the block returns a true value (equivalent to `Enumerable#select`).
shift	Returns the first element of self and removes it (shifting all other elements down by one). Returns `nil` if the array is empty.
size	Alias for #length
slice	Element Reference—Returns the element at index,
slice!	Deletes the element(s) given by an index (optionally with a length) or by a range. Returns the deleted object, subarray, or `nil` if the index is out of range. Equivalent to:
sort	Returns a new array created by sorting self. Comparisons for the sort will be done using the `<=>` operator or using an optional code block. The block implements a comparison between a and b, returning -1, 0, or +1. See also `Enumerable#sort_by`.
sort!	Sorts self. Comparisons for the sort will be done using the `<=>` operator or using an optional code block. The block implements a comparison between a and b, returning -1, 0, or +1. See also `Enumerable#sort_by`.
to_a	Returns self. If called on a subclass of Array, converts the receiver to an Array object.
to_ary	Returns self.
to_s	Returns self`.join`.
transpose	Assumes that self is an array of arrays and transposes the rows and columns.
uniq	Returns a new array by removing duplicate values in self.
uniq!	Removes duplicate elements from self. Returns `nil` if no changes are made (that is, no duplicates are found).
unshift	Prepends objects to the front of array. other elements up one.
values_at	Returns an array containing the elements in self corresponding to the given selector(s). The selectors may be either integer indices or ranges. See also `Array#select`.
zip	Converts any arguments to arrays, then merges elements of self with corresponding elements from each argument. This generates a sequence of `self.size` n-element arrays, where n is one more that the count of arguments. If the size of any argument is less than `enumObj.size`, `nil` values are supplied. If a block given, it is invoked for each output array, otherwise an array of arrays is returned.

Array

Ruby on Rails documentation... on Rails.