Ruby Array Methods

Front 1

Set Intersection—Returns a new array containing elements common to the two arrays, with no duplicates.

Back 1

&

usage:
array & other_array

Front 2

Repetition—With a String argument, equivalent to self.join(str). Otherwise, returns a new array built by concatenating the int copies of self.

Back 2

*

usage:
array * int → an_array
array * str → a_string

Front 3

Concatenation—Returns a new array built by concatenating the two arrays together to produce a third array.

Back 3

+

usage:
array + other_array → an_array

Front 4

Array Difference—Returns a new array that is a copy of the original array, removing any items that also appear in other_array.

Back 4

-

usage:
array - other_array → an_array

Front 5

Append—Pushes the given object on to the end of this array. This expression returns the array itself, so several appends may be chained together.

Back 5

<<

usage:
array << obj → array

Front 6

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.

Back 6

<=>

usage:
array <=> other_array → -1, 0, +1

Front 7

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.

Back 7

==

usage:
array == other_array → bool

Front 8

Element Reference—Returns the element at index, or returns a subarray starting at start and continuing for length elements, or returns a subarray specified by range. Negative indices count backward from the end of the array (-1 is the last element). Returns nil if the index (or starting index) are out of range.

Back 8

array[] or slice()

usage:
array[index] → obj or nil
array[start, length] → an_array or nil
array[range] → an_array or nil
array.slice(index) → obj or nil
array.slice(start, length) → an_array or nil
array.slice(range) → an_array or nil

Front 9

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.

Back 9

array[]

Front 10

Calculates the set of unambiguous abbreviations for the strings in self. If passed a pattern or a string, only the strings matching the pattern or starting with the string are considered.

Back 10

abbrev

usage:
abbrev(pattern = nil)

Front 11

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.

Back 11

assoc()

usage:
array.assoc(obj) → an_array or nil

Front 12

Returns the element at index. A negative index counts from the end of self. Returns nil if the index is out of range.

Back 12

at()

usage:
array.at(index) → obj or nil

See also Array#[]. (Array#at is slightly faster than Array#[], as it does not accept ranges and so on.)

Front 13

Removes all elements from self.

Back 13

clear

usage:
array.clear → array

Front 14

Invokes block once for each element of self. Creates a new array containing the values returned by the block.

Back 14

collect or map

usage:
array.collect {|item| block } → an_array
array.map {|item| block } → an_array

See also Enumerable#collect.

Front 15

Invokes the block once for each element of self, replacing the element with the value returned by block.

Back 15

collect! or map!

usage:
array.collect! {|item| block } → array
array.map! {|item| block } → array
See also Enumerable#collect.

Front 16

Returns a copy of self with all nil elements removed.

Back 16

compact

usage:
array.compact → an_array

Front 17

Removes nil elements from array. Returns nil if no changes were made.

Back 17

compact!

usage:
array.compact! → array or nil

Front 18

Appends the elements in other_array to self.

Back 18

concat()

usage:
array.concat(other_array) → array

Front 19

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.

Back 19

delete()

usage:
array.delete(obj) → obj or nil
array.delete(obj) { block } → obj or nil

Front 20

Deletes the element at the specified index, returning that element, or nil if the index is out of range.

Back 20

delete_at()

usage:
array.delete_at(index) → obj or nil
See also Array#slice!.

Front 21

Deletes every element of self for which block evaluates to true.

Back 21

delete_if{}

usage:
array.delete_if {|item| block } → array

Front 22

Calls block once for each element in self, passing that element as a parameter.

Back 22

each{}

usage:
array.each {|item| block } → array

Front 23

Same as Array#each, but passes the index of the element instead of the element itself.

Back 23

each_index{}

usage:
array.each_index {|index| block } → array

Front 24

Returns true if self array contains no elements.

Back 24

empty?

usage:
array.empty? → true or false

Front 25

Returns true if array and other are the same object, or are both arrays with the same content.

Back 25

eql?

usage:
array.eql?(other) → true or false

Front 26

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.

Back 26

fetch()

usage:
array.fetch(index) → obj
array.fetch(index, default ) → obj
array.fetch(index) {|index| block } → obj

Front 27

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.

Back 27

fill()

usage:
array.fill(obj) → array
array.fill(obj, start [, length]) → array
array.fill(obj, range ) → array
array.fill {|index| block } → array
array.fill(start [, length] ) {|index| block } → array
array.fill(range) {|index| block } → array

Front 28

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.

Back 28

first

usage:
array.first → obj or nil
array.first(n) → an_array

Front 29

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.

Back 29

flatten

usage:
array.flatten → an_array

Front 30

Flattens self in place. Returns nil if no modifications were made (i.e., array contains no subarrays.)

Back 30

flatten!

usage:
array.flatten! → array or nil

Front 31

Return true if this array is frozen (or temporarily frozen while being sorted).

Back 31

frozen?

usage:
array.frozen? → true or false

Front 32

Compute a hash-code for this array. Two arrays with the same content will have the same hash code (and will compare using eql?).

Back 32

hash

usage:
array.hash → fixnum

Front 33

Returns true if the given object is present in self (that is, if any object == anObject), false otherwise.

Back 33

include?

usage:
array.include?(obj) → true or false

Front 34

Returns the index of the first object in self such that is == to obj. Returns nil if no match is found.

Back 34

index

usage:
array.index(obj) → int or nil

Front 35

Replaces the contents of self with the contents of other_array, truncating or expanding if necessary.

Back 35

replace

usage:
array.replace(other_array) → array

Front 36

Inserts the given values before the element with the given index (which may be negative).

Back 36

insert

usage:
array.insert(index, obj...) → array

Front 37

Create a printable version of array.

Back 37

inspect

usage:
array.inspect → string

Front 38

Returns a string created by converting each element of the array to a string, separated by sep.

Back 38

join

usage:
array.join(sep=$,) → str

Front 39

Returns the last element(s) of self. If the array is empty, the first form returns nil.

Back 39

last

usage:
array.last → obj or nil
array.last(n) → an_array

Front 40

Returns the number of elements in self. May be zero.

Back 40

length

usage:
array.length → int

Front 41

Invokes block once for each element of self. Creates a new array containing the values returned by the block.

Back 41

collect or map

usage:
array.collect {|item| block } → an_array
array.map {|item| block } → an_array
See also Enumerable#collect.

Front 42

Invokes the block once for each element of self, replacing the element with the value returned by block.

Back 42

collect! or map!

usage:
array.collect! {|item| block } → array
array.map! {|item| block } → array
See also Enumerable#collect.

Front 43

Returns the number of non-nil elements in self. May be zero.

Back 43

nitems

usage:
array.nitems → int

Front 44

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.

Back 44

pack

usage:
arr.pack ( aTemplateString ) → aBinaryString
See also String#unpack.

Front 45

Removes the last element from self and returns it, or nil if the array is empty.

Back 45

pop

usage:
array.pop → obj or nil

Front 46

Append—Pushes the given object(s) on to the end of this array. This expression returns the array itself, so several appends may be chained together.

Back 46

push

usage:
array.push(obj, ... ) → array

Front 47

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.

Back 47

rassoc

usage:
array.rassoc(key) → an_array or nil
See also Array#assoc.

Front 48

Returns a new array containing the items in self for which the block is not true.

Back 48

reject

usage:
array.reject {|item| block } → an_array

Front 49

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.

Back 49

reject!

usage:
array.reject! {|item| block } → array or nil

Front 50

Replaces the contents of self with the contents of other_array, truncating or expanding if necessary.

Back 50

replace

usage:
array.replace(other_array) → array

Front 51

Returns a new array containing self‘s elements in reverse order.

Back 51

reverse

usage:
array.reverse → an_array

Front 52

Reverses self in place.

Back 52

reverse!

usage:
array.reverse! → array

Front 53

Same as Array#each, but traverses self in reverse order.

Back 53

reverse_each

usage:
array.reverse_each {|item| block }

Front 54

Returns the index of the last object in array == to obj. Returns nil if no match is found.

Back 54

rindex

usage:
array.rindex(obj) → int or nil

Front 55

Invokes the block passing in successive elements from array, returning an array containing those elements for which the block returns a true value

Back 55

select

usage:
array.select {|item| block } → an_array
(equivalent to Enumerable#select).

Front 56

Returns the first element of self and removes it (shifting all other elements down by one). Returns nil if the array is empty.

Back 56

shift

usage:
array.shift → obj or nil

Front 57

Alias for length

Back 57

size()

Front 58

Element Reference—Returns the element at index, or returns a subarray starting at start and continuing for length elements, or returns a subarray specified by range. Negative indices count backward from the end of the array (-1 is the last element). Returns nil if the index (or starting index) are out of range.

Back 58

[] or slice

usage:
array[index] → obj or nil
array[start, length] → an_array or nil
array[range] → an_array or nil
array.slice(index) → obj or nil
array.slice(start, length) → an_array or nil
array.slice(range) → an_array or nil

Front 59

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.

Back 59

slice!

usage:
array.slice!(index) → obj or nil
array.slice!(start, length) → sub_array or nil
array.slice!(range) → sub_array or nil

Front 60

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.

Back 60

array.sort → an_array
array.sort {| a,b | block } → an_array
See also Enumerable#sort_by.

Front 61

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

Back 61

sort!

usage:
array.sort! → array
array.sort! {| a,b | block } → array

Front 62

Returns self. If called on a subclass of Array, converts the receiver to an Array object.

Back 62

to_a

usage:
array.to_a → array

Front 63

Returns self.

Back 63

array.to_ary → array

Front 64

Returns self.join.

Back 64

to_s

usage:
array.to_s → string

Front 65

Assumes that self is an array of arrays and transposes the rows and columns.

Back 65

transpose

usage:
array.transpose → an_array

Front 66

Returns a new array by removing duplicate values in self.

Back 66

uniq

usage:
array.uniq → an_array

Front 67

Removes duplicate elements from self. Returns nil if no changes are made (that is, no duplicates are found).

Back 67

uniq!

usage:
array.uniq! → array or nil

Front 68

Prepends objects to the front of array. other elements up one.

Back 68

unshift

usage:
array.unshift(obj, ...) → array

Front 69

Returns an array containing the elements in self corresponding to the given selector(s). The selectors may be either integer indices or ranges.

Back 69

values_at

usage:
array.values_at(selector,... ) → an_array

Front 70

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.

Back 70

zip

usage:
array.zip(arg, ...) → an_array
array.zip(arg, ...) {| arr | block } → nil

Front 71

Set Union—Returns a new array by joining this array with other_array, removing duplicates.

Back 71

|

usage:
array | other_array → an_array