class Array - RDoc Documentation (original) (raw)

An Array object is an ordered, integer-indexed collection of objects, called elements; the object represents an array data structure.

An element may be any object (even another array); elements may be any mixture of objects of different types.

Important data structures that use arrays include:

There are also array-like data structures:

Array Indexes ↑

Array indexing starts at 0, as in C or Java.

A non-negative index is an offset from the first element:

A negative index is an offset, backwards, from the end of the array:

In-Range and Out-of-Range Indexes ↑

A non-negative index is in range if and only if it is smaller than the size of the array. For a 3-element array:

A negative index is in range if and only if its absolute value is not larger than the size of the array. For a 3-element array:

Effective Index ↑

Although the effective index into an array is always an integer, some methods (both within class Array and elsewhere) accept one or more non-integer arguments that are integer-convertible objects.

Creating Arrays ↑

You can create an Array object explicitly with:

A number of Ruby methods, both in the core and in the standard library, provide instance method to_a, which converts an object to an array.

Example Usage ↑

In addition to the methods it mixes in through the Enumerable module, the Array class has proprietary methods for accessing, searching and otherwise manipulating arrays.

Some of the more common ones are illustrated below.

Accessing Elements ↑

Elements in an array can be retrieved using the Array#[] method. It can take a single integer argument (a numeric index), a pair of arguments (start and length) or a range. Negative indices start counting from the end, with -1 being the last element.

arr = [1, 2, 3, 4, 5, 6] arr[2]
arr[100]
arr[-3]
arr[2, 3] arr[1..4] arr[1..-3]

Another way to access a particular array element is by using the at method

arr.at(0)

The slice method works in an identical manner to Array#[].

To raise an error for indices outside of the array bounds or else to provide a default value when that happens, you can use fetch.

arr = ['a', 'b', 'c', 'd', 'e', 'f'] arr.fetch(100) arr.fetch(100, "oops")

The special methods first and last will return the first and last elements of an array, respectively.

arr.first arr.last

To return the first n elements of an array, use take

arr.take(3)

drop does the opposite of take, by returning the elements after n elements have been dropped:

arr.drop(3)

Obtaining Information about an Array ↑

Arrays keep track of their own length at all times. To query an array about the number of elements it contains, use length, count or size.

browsers = ['Chrome', 'Firefox', 'Safari', 'Opera', 'IE'] browsers.length browsers.count

To check whether an array contains any elements at all

browsers.empty?

To check whether a particular item is included in the array

browsers.include?('Konqueror')

Adding Items to Arrays ↑

Items can be added to the end of an array by using either push or <<

arr = [1, 2, 3, 4] arr.push(5) arr << 6

unshift will add a new item to the beginning of an array.

arr.unshift(0)

With insert you can add a new element to an array at any position.

arr.insert(3, 'apple')

Using the insert method, you can also insert multiple values at once:

arr.insert(3, 'orange', 'pear', 'grapefruit')

Removing Items from an Array ↑

The method pop removes the last element in an array and returns it:

arr = [1, 2, 3, 4, 5, 6] arr.pop arr

To retrieve and at the same time remove the first item, use shift:

arr.shift arr

To delete an element at a particular index:

arr.delete_at(2) arr

To delete a particular element anywhere in an array, use delete:

arr = [1, 2, 2, 3] arr.delete(2) arr

A useful method if you need to remove nil values from an array is compact:

arr = ['foo', 0, nil, 'bar', 7, 'baz', nil] arr.compact
arr
arr.compact! arr

Another common need is to remove duplicate elements from an array.

It has the non-destructive uniq, and destructive method uniq!

arr = [2, 5, 6, 556, 6, 6, 8, 9, 0, 123, 556] arr.uniq

Iterating over Arrays ↑

Like all classes that include the Enumerable module, Array has an each method, which defines what elements should be iterated over and how. In case of Array’s each, all elements in the Array instance are yielded to the supplied block in sequence.

Note that this operation leaves the array unchanged.

arr = [1, 2, 3, 4, 5] arr.each {|a| print a -= 10, " "}

Another sometimes useful iterator is reverse_each which will iterate over the elements in the array in reverse order.

words = %w[first second third fourth fifth sixth] str = "" words.reverse_each {|word| str += "#{word} "} p str

The map method can be used to create a new array based on the original array, but with the values modified by the supplied block:

arr.map {|a| 2*a}
arr
arr.map! {|a| a**2}
arr

Selecting Items from an Array ↑

Elements can be selected from an array according to criteria defined in a block. The selection can happen in a destructive or a non-destructive manner. While the destructive operations will modify the array they were called on, the non-destructive methods usually return a new array with the selected elements, but leave the original array unchanged.

Non-destructive Selection ↑

arr = [1, 2, 3, 4, 5, 6] arr.select {|a| a > 3}
arr.reject {|a| a < 3}
arr.drop_while {|a| a < 4}
arr

Destructive Selection ↑

select! and reject! are the corresponding destructive methods to select and reject

Similar to select vs. reject, delete_if and keep_if have the exact opposite result when supplied with the same block:

arr.delete_if {|a| a < 4}
arr

arr = [1, 2, 3, 4, 5, 6] arr.keep_if {|a| a < 4}
arr

What’s Here ↑

First, what’s elsewhere. Class Array:

Here, class Array provides methods that are useful for:

Methods for Creating an Array ↑

See also Creating Arrays.

Methods for Querying ↑

Methods for Comparing ↑

Methods for Fetching ↑

These methods do not modify self.

Methods for Assigning ↑

These methods add, replace, or reorder elements in self.

Methods for Deleting ↑

Each of these methods removes elements from self:

Methods for Combining ↑

Methods for Iterating ↑

Methods for Converting ↑

Other Methods ↑

Public Class Methods

[](*args) click to toggle source

Returns a new array, populated with the given objects:

Array[1, 'a', /^A/]
Array[]
Array.[](1, 'a', /^A/)

Related: see Methods for Creating an Array.

static VALUE rb_ary_s_create(int argc, VALUE *argv, VALUE klass) { VALUE ary = ary_new(klass, argc); if (argc > 0 && argv) { ary_memcpy(ary, 0, argc, argv); ARY_SET_LEN(ary, argc); }

return ary;

}

new → new_empty_array click to toggle source

new(array) → new_array

new(size, default_value = nil) → new_array

new(size = 0) {|index| ... } → new_array

Returns a new array.

With no block and no argument given, returns a new empty array:

Array.new

With no block and array argument given, returns a new array with the same elements:

Array.new([:foo, 'bar', 2])

With no block and integer argument given, returns a new array containing that many instances of the given default_value:

Array.new(0)
Array.new(3)
Array.new(2, 3)

With a block given, returns an array of the given size; calls the block with each index in the range (0...size); the element at that index in the returned array is the blocks return value:

Array.new(3) {|index| "Element #{index}" }

A common pitfall for new Rubyists is providing an expression as default_value:

array = Array.new(2, {}) array array[0][:a] = 1 array

If you want the elements of the array to be distinct, you should pass a block:

array = Array.new(2) { {} } array array[0][:a] = 1 array

Raises TypeError if the first argument is not either an array or an integer-convertible object). Raises ArgumentError if the first argument is a negative integer.

Related: see Methods for Creating an Array.

static VALUE rb_ary_initialize(int argc, VALUE *argv, VALUE ary) { long len; VALUE size, val;

rb_ary_modify(ary);
if (argc == 0) {
    rb_ary_reset(ary);
    RUBY_ASSERT(ARY_EMBED_P(ary));
    RUBY_ASSERT(ARY_EMBED_LEN(ary) == 0);
    if (rb_block_given_p()) {
        rb_warning("given block not used");
    }
    return ary;
}
rb_scan_args(argc, argv, "02", &size, &val);
if (argc == 1 && !FIXNUM_P(size)) {
    val = rb_check_array_type(size);
    if (!NIL_P(val)) {
        rb_ary_replace(ary, val);
        return ary;
    }
}

len = NUM2LONG(size);
/* NUM2LONG() may call size.to_int, ary can be frozen, modified, etc */
if (len < 0) {
    rb_raise(rb_eArgError, "negative array size");
}
if (len > ARY_MAX_SIZE) {
    rb_raise(rb_eArgError, "array size too big");
}
/* recheck after argument conversion */
rb_ary_modify(ary);
ary_resize_capa(ary, len);
if (rb_block_given_p()) {
    long i;

    if (argc == 2) {
        rb_warn("block supersedes default value argument");
    }
    for (i=0; i<len; i++) {
        rb_ary_store(ary, i, rb_yield(LONG2NUM(i)));
        ARY_SET_LEN(ary, i + 1);
    }
}
else {
    ary_memfill(ary, 0, len, val);
    ARY_SET_LEN(ary, len);
}
return ary;

}

try_convert(object) → object, new_array, or nil click to toggle source

Attempts to return an array, based on the given object.

If object is an array, returns object.

Otherwise if object responds to :to_ary. calls object.to_ary: if the return value is an array or nil, returns that value; if not, raises TypeError.

Otherwise returns nil.

Related: see Methods for Creating an Array.

static VALUE rb_ary_s_try_convert(VALUE dummy, VALUE ary) { return rb_check_array_type(ary); }

Public Instance Methods

self & other_array → new_array click to toggle source

Returns a new array containing the intersection of self and other_array; that is, containing those elements found in both self and other_array:

[0, 1, 2, 3] & [1, 2]

Omits duplicates:

[0, 1, 1, 0] & [0, 1]

Preserves order from self:

[0, 1, 2] & [3, 2, 1, 0]

Identifies common elements using method #eql? (as defined in each element of self).

Related: see Methods for Combining.

static VALUE rb_ary_and(VALUE ary1, VALUE ary2) { VALUE hash, ary3, v; st_data_t vv; long i;

ary2 = to_ary(ary2);
ary3 = rb_ary_new();
if (RARRAY_LEN(ary1) == 0 || RARRAY_LEN(ary2) == 0) return ary3;

if (RARRAY_LEN(ary1) <= SMALL_ARRAY_LEN && RARRAY_LEN(ary2) <= SMALL_ARRAY_LEN) {
    for (i=0; i<RARRAY_LEN(ary1); i++) {
        v = RARRAY_AREF(ary1, i);
        if (!rb_ary_includes_by_eql(ary2, v)) continue;
        if (rb_ary_includes_by_eql(ary3, v)) continue;
        rb_ary_push(ary3, v);
    }
    return ary3;
}

hash = ary_make_hash(ary2);

for (i=0; i<RARRAY_LEN(ary1); i++) {
    v = RARRAY_AREF(ary1, i);
    vv = (st_data_t)v;
    if (rb_hash_stlike_delete(hash, &vv, 0)) {
        rb_ary_push(ary3, v);
    }
}

return ary3;

}

self * n → new_array click to toggle source

self * string_separator → new_string

When non-negative integer argument n is given, returns a new array built by concatenating n copies of self:

a = ['x', 'y'] a * 3

When string argument string_separator is given, equivalent to self.join(string_separator):

[0, [0, 1], {foo: 0}] * ', '

static VALUE rb_ary_times(VALUE ary, VALUE times) { VALUE ary2, tmp; const VALUE *ptr; long t, len;

tmp = rb_check_string_type(times);
if (!NIL_P(tmp)) {
    return rb_ary_join(ary, tmp);
}

len = NUM2LONG(times);
if (len == 0) {
    ary2 = ary_new(rb_cArray, 0);
    goto out;
}
if (len < 0) {
    rb_raise(rb_eArgError, "negative argument");
}
if (ARY_MAX_SIZE/len < RARRAY_LEN(ary)) {
    rb_raise(rb_eArgError, "argument too big");
}
len *= RARRAY_LEN(ary);

ary2 = ary_new(rb_cArray, len);
ARY_SET_LEN(ary2, len);

ptr = RARRAY_CONST_PTR(ary);
t = RARRAY_LEN(ary);
if (0 < t) {
    ary_memcpy(ary2, 0, t, ptr);
    while (t <= len/2) {
        ary_memcpy(ary2, t, t, RARRAY_CONST_PTR(ary2));
        t *= 2;
    }
    if (t < len) {
        ary_memcpy(ary2, t, len-t, RARRAY_CONST_PTR(ary2));
    }
}

out: return ary2; }

self + other_array → new_array click to toggle source

Returns a new array containing all elements of self followed by all elements of other_array:

a = [0, 1] + [2, 3] a

Related: see Methods for Combining.

VALUE rb_ary_plus(VALUE x, VALUE y) { VALUE z; long len, xlen, ylen;

y = to_ary(y);
xlen = RARRAY_LEN(x);
ylen = RARRAY_LEN(y);
len = xlen + ylen;
z = rb_ary_new2(len);

ary_memcpy(z, 0, xlen, RARRAY_CONST_PTR(x));
ary_memcpy(z, xlen, ylen, RARRAY_CONST_PTR(y));
ARY_SET_LEN(z, len);
return z;

}

self - other_array → new_array click to toggle source

Returns a new array containing only those elements of self that are not found in other_array; the order from self is preserved:

[0, 1, 1, 2, 1, 1, 3, 1, 1] - [1]
[0, 1, 1, 2, 1, 1, 3, 1, 1] - [3, 2, 0, :foo] [0, 1, 2] - [:foo]

Element are compared using method #eql? (as defined in each element of self).

Related: see Methods for Combining.

VALUE rb_ary_diff(VALUE ary1, VALUE ary2) { VALUE ary3; VALUE hash; long i;

ary2 = to_ary(ary2);
if (RARRAY_LEN(ary2) == 0) { return ary_make_shared_copy(ary1); }
ary3 = rb_ary_new();

if (RARRAY_LEN(ary1) <= SMALL_ARRAY_LEN || RARRAY_LEN(ary2) <= SMALL_ARRAY_LEN) {
    for (i=0; i<RARRAY_LEN(ary1); i++) {
        VALUE elt = rb_ary_elt(ary1, i);
        if (rb_ary_includes_by_eql(ary2, elt)) continue;
        rb_ary_push(ary3, elt);
    }
    return ary3;
}

hash = ary_make_hash(ary2);
for (i=0; i<RARRAY_LEN(ary1); i++) {
    if (rb_hash_stlike_lookup(hash, RARRAY_AREF(ary1, i), NULL)) continue;
    rb_ary_push(ary3, rb_ary_elt(ary1, i));
}

return ary3;

}

self << object → self click to toggle source

Appends object as the last element in self; returns self:

[:foo, 'bar', 2] << :baz

Appends object as a single element, even if it is another array:

[:foo, 'bar', 2] << [3, 4]

Related: see Methods for Assigning.

VALUE rb_ary_push(VALUE ary, VALUE item) { long idx = RARRAY_LEN((ary_verify(ary), ary)); VALUE target_ary = ary_ensure_room_for_push(ary, 1); RARRAY_PTR_USE(ary, ptr, { RB_OBJ_WRITE(target_ary, &ptr[idx], item); }); ARY_SET_LEN(ary, idx + 1); ary_verify(ary); return ary; }

self <=> other_array → -1, 0, or 1 click to toggle source

Returns -1, 0, or 1 as self is determined to be less than, equal to, or greater than other_array.

Iterates over each index i in (0...self.size):

When every result is 0, returns self.size <=> other_array.size (see Integer#<=>):

[0, 1, 2] <=> [0, 1]
[0, 1, 2] <=> [0, 1, 2]
[0, 1, 2] <=> [0, 1, 2, 3]

Note that when other_array is larger than self, its trailing elements do not affect the result:

[0, 1, 2] <=> [0, 1, 2, -3] [0, 1, 2] <=> [0, 1, 2, 0]
[0, 1, 2] <=> [0, 1, 2, 3]

Related: see Methods for Comparing.

VALUE rb_ary_cmp(VALUE ary1, VALUE ary2) { long len; VALUE v;

ary2 = rb_check_array_type(ary2);
if (NIL_P(ary2)) return Qnil;
if (ary1 == ary2) return INT2FIX(0);
v = rb_exec_recursive_paired(recursive_cmp, ary1, ary2, ary2);
if (!UNDEF_P(v)) return v;
len = RARRAY_LEN(ary1) - RARRAY_LEN(ary2);
if (len == 0) return INT2FIX(0);
if (len > 0) return INT2FIX(1);
return INT2FIX(-1);

}

self == other_array → true or false click to toggle source

Returns whether both:

Examples:

[:foo, 'bar', 2] == [:foo, 'bar', 2]
[:foo, 'bar', 2] == [:foo, 'bar', 2.0] [:foo, 'bar', 2] == [:foo, 'bar']
[:foo, 'bar', 2] == [:foo, 'bar', 3]

This method is different from method Array#eql?, which compares elements using Object#eql?.

Related: see Methods for Comparing.

static VALUE rb_ary_equal(VALUE ary1, VALUE ary2) { if (ary1 == ary2) return Qtrue; if (!RB_TYPE_P(ary2, T_ARRAY)) { if (!rb_respond_to(ary2, idTo_ary)) { return Qfalse; } return rb_equal(ary2, ary1); } if (RARRAY_LEN(ary1) != RARRAY_LEN(ary2)) return Qfalse; if (RARRAY_CONST_PTR(ary1) == RARRAY_CONST_PTR(ary2)) return Qtrue; return rb_exec_recursive_paired(recursive_equal, ary1, ary2, ary2); }

self[index] → object or nil click to toggle source

self[start, length] → object or nil

self[range] → object or nil

self[aseq] → object or nil

Returns elements from self; does not modify self.

In brief:

a = [:foo, 'bar', 2]

a[0]
a[-1]

a[1, 2]
a[-2, 2]

a[0..1]
a[0..-2] a[-2..2]

When a single integer argument index is given, returns the element at offset index:

a = [:foo, 'bar', 2] a[0] a[2] a

If index is negative, counts backwards from the end of self:

a = [:foo, 'bar', 2] a[-1] a[-2]

If index is out of range, returns nil.

When two Integer arguments start and length are given, returns a new Array of size length containing successive elements beginning at offset start:

a = [:foo, 'bar', 2] a[0, 2] a[1, 2]

If start + length is greater than self.length, returns all elements from offset start to the end:

a = [:foo, 'bar', 2] a[0, 4] a[1, 3] a[2, 2]

If start == self.size and length >= 0, returns a new empty Array.

If length is negative, returns nil.

When a single Range argument range is given, treats range.min as start above and range.size as length above:

a = [:foo, 'bar', 2] a[0..1] a[1..2]

Special case: If range.start == a.size, returns a new empty Array.

If range.end is negative, calculates the end index from the end:

a = [:foo, 'bar', 2] a[0..-1] a[0..-2] a[0..-3]

If range.start is negative, calculates the start index from the end:

a = [:foo, 'bar', 2] a[-1..2] a[-2..2] a[-3..2]

If range.start is larger than the array size, returns nil.

a = [:foo, 'bar', 2] a[4..1] a[4..0] a[4..-1]

When a single Enumerator::ArithmeticSequence argument aseq is given, returns an Array of elements corresponding to the indexes produced by the sequence.

a = ['--', 'data1', '--', 'data2', '--', 'data3'] a[(1..).step(2)]

Unlike slicing with range, if the start or the end of the arithmetic sequence is larger than array size, throws RangeError.

a = ['--', 'data1', '--', 'data2', '--', 'data3'] a[(1..11).step(2)]

a[(7..).step(2)]

If given a single argument, and its type is not one of the listed, tries to convert it to Integer, and raises if it is impossible:

a = [:foo, 'bar', 2]

a[:foo]

Related: see Methods for Fetching.

VALUE rb_ary_aref(int argc, const VALUE *argv, VALUE ary) { rb_check_arity(argc, 1, 2); if (argc == 2) { return rb_ary_aref2(ary, argv[0], argv[1]); } return rb_ary_aref1(ary, argv[0]); }

Also aliased as: slice

self[index] = object → object click to toggle source

self[start, length] = object → object

self[range] = object → object

Assigns elements in self, based on the given object; returns object.

In brief:

a_orig = [:foo, 'bar', 2]

a = a_orig.dup a[0] = 'foo' a a = a_orig.dup a[7] = 'foo' a

a = a_orig.dup a[0, 2] = 'foo' a a = a_orig.dup a[6, 50] = 'foo' a

a = a_orig.dup a[0..1] = 'foo' a a = a_orig.dup a[6..50] = 'foo' a

When Integer argument index is given, assigns object to an element in self.

If index is non-negative, assigns object the element at offset index:

a = [:foo, 'bar', 2] a[0] = 'foo' a

If index is greater than self.length, extends the array:

a = [:foo, 'bar', 2] a[7] = 'foo' a

If index is negative, counts backwards from the end of the array:

a = [:foo, 'bar', 2] a[-1] = 'two' a

When Integer arguments start and length are given and object is not an Array, removes length - 1 elements beginning at offset start, and assigns object at offset start:

a = [:foo, 'bar', 2] a[0, 2] = 'foo' a

If start is negative, counts backwards from the end of the array:

a = [:foo, 'bar', 2] a[-2, 2] = 'foo' a

If start is non-negative and outside the array ( >= self.size), extends the array with nil, assigns object at offset start, and ignores length:

a = [:foo, 'bar', 2] a[6, 50] = 'foo' a

If length is zero, shifts elements at and following offset start and assigns object at offset start:

a = [:foo, 'bar', 2] a[1, 0] = 'foo' a

If length is too large for the existing array, does not extend the array:

a = [:foo, 'bar', 2] a[1, 5] = 'foo' a

When Range argument range is given and object is not an Array, removes length - 1 elements beginning at offset start, and assigns object at offset start:

a = [:foo, 'bar', 2] a[0..1] = 'foo' a

if range.begin is negative, counts backwards from the end of the array:

a = [:foo, 'bar', 2] a[-2..2] = 'foo' a

If the array length is less than range.begin, extends the array with nil, assigns object at offset range.begin, and ignores length:

a = [:foo, 'bar', 2] a[6..50] = 'foo' a

If range.end is zero, shifts elements at and following offset start and assigns object at offset start:

a = [:foo, 'bar', 2] a[1..0] = 'foo' a

If range.end is negative, assigns object at offset start, retains range.end.abs -1 elements past that, and removes those beyond:

a = [:foo, 'bar', 2] a[1..-1] = 'foo' a a = [:foo, 'bar', 2] a[1..-2] = 'foo' a a = [:foo, 'bar', 2] a[1..-3] = 'foo' a a = [:foo, 'bar', 2]

If range.end is too large for the existing array, replaces array elements, but does not extend the array with nil values:

a = [:foo, 'bar', 2] a[1..5] = 'foo' a

Related: see Methods for Assigning.

static VALUE rb_ary_aset(int argc, VALUE *argv, VALUE ary) { long offset, beg, len;

rb_check_arity(argc, 2, 3);
rb_ary_modify_check(ary);
if (argc == 3) {
    beg = NUM2LONG(argv[0]);
    len = NUM2LONG(argv[1]);
    return ary_aset_by_rb_ary_splice(ary, beg, len, argv[2]);
}
if (FIXNUM_P(argv[0])) {
    offset = FIX2LONG(argv[0]);
    return ary_aset_by_rb_ary_store(ary, offset, argv[1]);
}
if (rb_range_beg_len(argv[0], &beg, &len, RARRAY_LEN(ary), 1)) {
    /* check if idx is Range */
    return ary_aset_by_rb_ary_splice(ary, beg, len, argv[1]);
}

offset = NUM2LONG(argv[0]);
return ary_aset_by_rb_ary_store(ary, offset, argv[1]);

}

all? → true or false click to toggle source

all?(object) → true or false

all? {|element| ... } → true or false

Returns whether for every element of self, a given criterion is satisfied.

With no block and no argument, returns whether every element of self is truthy:

[[], {}, '', 0, 0.0, Object.new].all? [[], {}, '', 0, 0.0, nil].all?
[[], {}, '', 0, 0.0, false].all?

With argument object given, returns whether object === ele for every element ele in self:

[0, 0, 0].all?(0)
[0, 1, 2].all?(1)
['food', 'fool', 'foot'].all?(/foo/) ['food', 'drink'].all?(/foo/)

With a block given, calls the block with each element in self; returns whether the block returns only truthy values:

[0, 1, 2].all? { |ele| ele < 3 } [0, 1, 2].all? { |ele| ele < 2 }

With both a block and argument object given, ignores the block and uses object as above.

Special case: returns true if self is empty (regardless of any given argument or block).

Related: see Methods for Querying.

static VALUE rb_ary_all_p(int argc, VALUE *argv, VALUE ary) { long i, len = RARRAY_LEN(ary);

rb_check_arity(argc, 0, 1);
if (!len) return Qtrue;
if (argc) {
    if (rb_block_given_p()) {
        rb_warn("given block not used");
    }
    for (i = 0; i < RARRAY_LEN(ary); ++i) {
        if (!RTEST(rb_funcall(argv[0], idEqq, 1, RARRAY_AREF(ary, i)))) return Qfalse;
    }
}
else if (!rb_block_given_p()) {
    for (i = 0; i < len; ++i) {
        if (!RTEST(RARRAY_AREF(ary, i))) return Qfalse;
    }
}
else {
    for (i = 0; i < RARRAY_LEN(ary); ++i) {
        if (!RTEST(rb_yield(RARRAY_AREF(ary, i)))) return Qfalse;
    }
}
return Qtrue;

}

any? → true or false click to toggle source

any?(object) → true or false

any? {|element| ... } → true or false

Returns whether for any element of self, a given criterion is satisfied.

With no block and no argument, returns whether any element of self is truthy:

[nil, false, []].any? [nil, false, {}].any? [nil, false, ''].any? [nil, false].any?

With argument object given, returns whether object === ele for any element ele in self:

[nil, false, 0].any?(0)
[nil, false, 1].any?(0)
[nil, false, 'food'].any?(/foo/) [nil, false, 'food'].any?(/bar/)

With a block given, calls the block with each element in self; returns whether the block returns any truthy value:

[0, 1, 2].any? {|ele| ele < 1 } [0, 1, 2].any? {|ele| ele < 0 }

With both a block and argument object given, ignores the block and uses object as above.

Special case: returns false if self is empty (regardless of any given argument or block).

Related: see Methods for Querying.

static VALUE rb_ary_any_p(int argc, VALUE *argv, VALUE ary) { long i, len = RARRAY_LEN(ary);

rb_check_arity(argc, 0, 1);
if (!len) return Qfalse;
if (argc) {
    if (rb_block_given_p()) {
        rb_warn("given block not used");
    }
    for (i = 0; i < RARRAY_LEN(ary); ++i) {
        if (RTEST(rb_funcall(argv[0], idEqq, 1, RARRAY_AREF(ary, i)))) return Qtrue;
    }
}
else if (!rb_block_given_p()) {
    for (i = 0; i < len; ++i) {
        if (RTEST(RARRAY_AREF(ary, i))) return Qtrue;
    }
}
else {
    for (i = 0; i < RARRAY_LEN(ary); ++i) {
        if (RTEST(rb_yield(RARRAY_AREF(ary, i)))) return Qtrue;
    }
}
return Qfalse;

}

append(*objects) → self

Appends each argument in objects to self; returns self:

a = [:foo, 'bar', 2] a.push(:baz, :bat)

Appends each argument as a single element, even if it is another array:

a = [:foo, 'bar', 2]
a.push([:baz, :bat], [:bam, :bad])

Related: see Methods for Assigning.

assoc(object) → found_array or nil click to toggle source

Returns the first element ele in self such that ele is an array and ele[0] == object:

a = [{foo: 0}, [2, 4], [4, 5, 6], [4, 5]] a.assoc(4)

Returns nil if no such element is found.

Related: Array#rassoc; see also Methods for Fetching.

VALUE rb_ary_assoc(VALUE ary, VALUE key) { long i; VALUE v;

for (i = 0; i < RARRAY_LEN(ary); ++i) {
    v = rb_check_array_type(RARRAY_AREF(ary, i));
    if (!NIL_P(v) && RARRAY_LEN(v) > 0 &&
        rb_equal(RARRAY_AREF(v, 0), key))
        return v;
}
return Qnil;

}

at(index) → object or nil click to toggle source

Returns the element of self specified by the given index or nil if there is no such element; index must be an integer-convertible object.

For non-negative index, returns the element of self at offset index:

a = [:foo, 'bar', 2] a.at(0)
a.at(2)
a.at(2.0)

For negative index, counts backwards from the end of self:

a.at(-2)

Related: Array#[]; see also Methods for Fetching.

VALUE rb_ary_at(VALUE ary, VALUE pos) { return rb_ary_entry(ary, NUM2LONG(pos)); }

bsearch {|element| ... } → found_element or nil click to toggle source

bsearch → new_enumerator

Returns the element from self found by a binary search, or nil if the search found no suitable element.

See Binary Searching.

Related: see Methods for Fetching.

static VALUE rb_ary_bsearch(VALUE ary) { VALUE index_result = rb_ary_bsearch_index(ary);

if (FIXNUM_P(index_result)) {
    return rb_ary_entry(ary, FIX2LONG(index_result));
}
return index_result;

}

bsearch_index {|element| ... } → integer or nil click to toggle source

bsearch_index → new_enumerator

Returns the integer index of the element from self found by a binary search, or nil if the search found no suitable element.

See Binary Searching.

Related: see Methods for Fetching.

static VALUE rb_ary_bsearch_index(VALUE ary) { long low = 0, high = RARRAY_LEN(ary), mid; int smaller = 0, satisfied = 0; VALUE v, val;

RETURN_ENUMERATOR(ary, 0, 0);
while (low < high) {
    mid = low + ((high - low) / 2);
    val = rb_ary_entry(ary, mid);
    v = rb_yield(val);
    if (FIXNUM_P(v)) {
        if (v == INT2FIX(0)) return INT2FIX(mid);
        smaller = (SIGNED_VALUE)v < 0; /* Fixnum preserves its sign-bit */
    }
    else if (v == Qtrue) {
        satisfied = 1;
        smaller = 1;
    }
    else if (!RTEST(v)) {
        smaller = 0;
    }
    else if (rb_obj_is_kind_of(v, rb_cNumeric)) {
        const VALUE zero = INT2FIX(0);
        switch (rb_cmpint(rb_funcallv(v, id_cmp, 1, &zero), v, zero)) {
          case 0: return INT2FIX(mid);
          case 1: smaller = 0; break;
          case -1: smaller = 1;
        }
    }
    else {
        rb_raise(rb_eTypeError, "wrong argument type %"PRIsVALUE
                 " (must be numeric, true, false or nil)",
                 rb_obj_class(v));
    }
    if (smaller) {
        high = mid;
    }
    else {
        low = mid + 1;
    }
}
if (!satisfied) return Qnil;
return INT2FIX(low);

}

clear → self click to toggle source

Removes all elements from self; returns self:

a = [:foo, 'bar', 2] a.clear

Related: see Methods for Deleting.

VALUE rb_ary_clear(VALUE ary) { rb_ary_modify_check(ary); if (ARY_SHARED_P(ary)) { rb_ary_unshare(ary); FL_SET_EMBED(ary); ARY_SET_EMBED_LEN(ary, 0); } else { ARY_SET_LEN(ary, 0); if (ARY_DEFAULT_SIZE * 2 < ARY_CAPA(ary)) { ary_resize_capa(ary, ARY_DEFAULT_SIZE * 2); } } ary_verify(ary); return ary; }

collect {|element| ... } → new_array click to toggle source

collect → new_enumerator

With a block given, calls the block with each element of self; returns a new array whose elements are the return values from the block:

a = [:foo, 'bar', 2] a1 = a.map {|element| element.class } a1

With no block given, returns a new Enumerator.

Related: collect!; see also Methods for Converting.

static VALUE rb_ary_collect(VALUE ary) { long i; VALUE collect;

RETURN_SIZED_ENUMERATOR(ary, 0, 0, ary_enum_length);
collect = rb_ary_new2(RARRAY_LEN(ary));
for (i = 0; i < RARRAY_LEN(ary); i++) {
    rb_ary_push(collect, rb_yield(RARRAY_AREF(ary, i)));
}
return collect;

}

Also aliased as: map

collect! {|element| ... } → new_array click to toggle source

collect! → new_enumerator

With a block given, calls the block with each element of self and replaces the element with the block’s return value; returns self:

a = [:foo, 'bar', 2] a.map! { |element| element.class }

With no block given, returns a new Enumerator.

Related: collect; see also Methods for Converting.

static VALUE rb_ary_collect_bang(VALUE ary) { long i;

RETURN_SIZED_ENUMERATOR(ary, 0, 0, ary_enum_length);
rb_ary_modify(ary);
for (i = 0; i < RARRAY_LEN(ary); i++) {
    rb_ary_store(ary, i, rb_yield(RARRAY_AREF(ary, i)));
}
return ary;

}

Also aliased as: map!

combination(count) {|element| ... } → self click to toggle source

combination(count) → new_enumerator

When a block and a positive integer-convertible object argument count (0 < count <= self.size) are given, calls the block with each combination of self of size count; returns self:

a = %w[a b c]
a.combination(2) {|combination| p combination }

Output:

["a", "b"] ["a", "c"] ["b", "c"]

The order of the yielded combinations is not guaranteed.

When count is zero, calls the block once with a new empty array:

a.combination(0) {|combination| p combination } [].combination(0) {|combination| p combination }

Output:

[] []

When count is negative or larger than self.size and self is non-empty, does not call the block:

a.combination(-1) {|combination| fail 'Cannot happen' } a.combination(4) {|combination| fail 'Cannot happen' }

With no block given, returns a new Enumerator.

Related: Array#permutation; see also Methods for Iterating.

static VALUE rb_ary_combination(VALUE ary, VALUE num) { long i, n, len;

n = NUM2LONG(num);
RETURN_SIZED_ENUMERATOR(ary, 1, &num, rb_ary_combination_size);
len = RARRAY_LEN(ary);
if (n < 0 || len < n) {
    /* yield nothing */
}
else if (n == 0) {
    rb_yield(rb_ary_new2(0));
}
else if (n == 1) {
    for (i = 0; i < RARRAY_LEN(ary); i++) {
        rb_yield(rb_ary_new3(1, RARRAY_AREF(ary, i)));
    }
}
else {
    VALUE ary0 = ary_make_shared_copy(ary); /* private defensive copy of ary */
    volatile VALUE t0;
    long *stack = ALLOCV_N(long, t0, n+1);

    RBASIC_CLEAR_CLASS(ary0);
    combinate0(len, n, stack, ary0);
    ALLOCV_END(t0);
    RBASIC_SET_CLASS_RAW(ary0, rb_cArray);
}
return ary;

}

compact → new_array click to toggle source

Returns a new array containing only the non-nil elements from self; element order is preserved:

a = [nil, 0, nil, false, nil, '', nil, [], nil, {}] a.compact

Related: Array#compact!; see also Methods for Deleting.

static VALUE rb_ary_compact(VALUE ary) { ary = rb_ary_dup(ary); rb_ary_compact_bang(ary); return ary; }

compact! → self or nil click to toggle source

Removes all nil elements from self; Returns self if any elements are removed, nil otherwise:

a = [nil, 0, nil, false, nil, '', nil, [], nil, {}] a.compact! a
a.compact!

Related: Array#compact; see also Methods for Deleting.

static VALUE rb_ary_compact_bang(VALUE ary) { VALUE *p, *t, *end; long n;

rb_ary_modify(ary);
p = t = (VALUE *)RARRAY_CONST_PTR(ary); /* WB: no new reference */
end = p + RARRAY_LEN(ary);

while (t < end) {
    if (NIL_P(*t)) t++;
    else *p++ = *t++;
}
n = p - RARRAY_CONST_PTR(ary);
if (RARRAY_LEN(ary) == n) {
    return Qnil;
}
ary_resize_smaller(ary, n);

return ary;

}

concat(*other_arrays) → self click to toggle source

Adds to self all elements from each array in other_arrays; returns self:

a = [0, 1] a.concat(['two', 'three'], [:four, :five], a)

Related: see Methods for Assigning.

static VALUE rb_ary_concat_multi(int argc, VALUE *argv, VALUE ary) { rb_ary_modify_check(ary);

if (argc == 1) {
    rb_ary_concat(ary, argv[0]);
}
else if (argc > 1) {
    int i;
    VALUE args = rb_ary_hidden_new(argc);
    for (i = 0; i < argc; i++) {
        rb_ary_concat(args, argv[i]);
    }
    ary_append(ary, args);
}

ary_verify(ary);
return ary;

}

count → integer click to toggle source

count(object) → integer

count {|element| ... } → integer

Returns a count of specified elements.

With no argument and no block, returns the count of all elements:

[0, :one, 'two', 3, 3.0].count

With argument object given, returns the count of elements == to object:

[0, :one, 'two', 3, 3.0].count(3)

With no argument and a block given, calls the block with each element; returns the count of elements for which the block returns a truthy value:

[0, 1, 2, 3].count {|element| element > 1 }

With argument object and a block given, issues a warning, ignores the block, and returns the count of elements == to object.

Related: see Methods for Querying.

static VALUE rb_ary_count(int argc, VALUE *argv, VALUE ary) { long i, n = 0;

if (rb_check_arity(argc, 0, 1) == 0) {
    VALUE v;

    if (!rb_block_given_p())
        return LONG2NUM(RARRAY_LEN(ary));

    for (i = 0; i < RARRAY_LEN(ary); i++) {
        v = RARRAY_AREF(ary, i);
        if (RTEST(rb_yield(v))) n++;
    }
}
else {
    VALUE obj = argv[0];

    if (rb_block_given_p()) {
        rb_warn("given block not used");
    }
    for (i = 0; i < RARRAY_LEN(ary); i++) {
        if (rb_equal(RARRAY_AREF(ary, i), obj)) n++;
    }
}

return LONG2NUM(n);

}

cycle(count = nil) {|element| ... } → nil click to toggle source

cycle(count = nil) → new_enumerator

With a block given, may call the block, depending on the value of argument count; count must be an integer-convertible object, or nil.

When count is positive, calls the block with each element, then does so repeatedly, until it has done so count times; returns nil:

output = [] [0, 1].cycle(2) {|element| output.push(element) } output

When count is zero or negative, does not call the block:

[0, 1].cycle(0) {|element| fail 'Cannot happen' }
[0, 1].cycle(-1) {|element| fail 'Cannot happen' }

When count is nil, cycles forever:

[0, 1].cycle {|element| puts element } [0, 1].cycle(nil) {|element| puts element }

With no block given, returns a new Enumerator.

Related: see Methods for Iterating.

static VALUE rb_ary_cycle(int argc, VALUE *argv, VALUE ary) { long n, i;

rb_check_arity(argc, 0, 1);

RETURN_SIZED_ENUMERATOR(ary, argc, argv, rb_ary_cycle_size);
if (argc == 0 || NIL_P(argv[0])) {
    n = -1;
}
else {
    n = NUM2LONG(argv[0]);
    if (n <= 0) return Qnil;
}

while (RARRAY_LEN(ary) > 0 && (n < 0 || 0 < n--)) {
    for (i=0; i<RARRAY_LEN(ary); i++) {
        rb_yield(RARRAY_AREF(ary, i));
    }
}
return Qnil;

}

delete(object) → last_removed_object click to toggle source

delete(object) {|element| ... } → last_removed_object or block_return

Removes zero or more elements from self.

With no block given, removes from self each element ele such that ele == object; returns the last removed element:

a = [0, 1, 2, 2.0] a.delete(2) a

Returns nil if no elements removed:

a.delete(2)

With a block given, removes from self each element ele such that ele == object.

If any such elements are found, ignores the block and returns the last removed element:

a = [0, 1, 2, 2.0] a.delete(2) {|element| fail 'Cannot happen' } a

If no such element is found, returns the block’s return value:

a.delete(2) {|element| "Element #{element} not found." }

Related: see Methods for Deleting.

VALUE rb_ary_delete(VALUE ary, VALUE item) { VALUE v = item; long i1, i2;

for (i1 = i2 = 0; i1 < RARRAY_LEN(ary); i1++) {
    VALUE e = RARRAY_AREF(ary, i1);

    if (rb_equal(e, item)) {
        v = e;
        continue;
    }
    if (i1 != i2) {
        rb_ary_store(ary, i2, e);
    }
    i2++;
}
if (RARRAY_LEN(ary) == i2) {
    if (rb_block_given_p()) {
        return rb_yield(item);
    }
    return Qnil;
}

ary_resize_smaller(ary, i2);

ary_verify(ary);
return v;

}

delete_at(index) → removed_object or nil click to toggle source

Removes the element of self at the given index, which must be an integer-convertible object.

When index is non-negative, deletes the element at offset index:

a = [:foo, 'bar', 2] a.delete_at(1) a

When index is negative, counts backward from the end of the array:

a = [:foo, 'bar', 2] a.delete_at(-2) a

When index is out of range, returns nil.

a = [:foo, 'bar', 2] a.delete_at(3)
a.delete_at(-4)

Related: see Methods for Deleting.

static VALUE rb_ary_delete_at_m(VALUE ary, VALUE pos) { return rb_ary_delete_at(ary, NUM2LONG(pos)); }

delete_if {|element| ... } → self click to toggle source

delete_if → new_numerator

With a block given, calls the block with each element of self; removes the element if the block returns a truthy value; returns self:

a = [:foo, 'bar', 2, 'bat'] a.delete_if {|element| element.to_s.start_with?('b') }

With no block given, returns a new Enumerator.

Related: see Methods for Deleting.

static VALUE rb_ary_delete_if(VALUE ary) { ary_verify(ary); RETURN_SIZED_ENUMERATOR(ary, 0, 0, ary_enum_length); ary_reject_bang(ary); return ary; }

difference(*other_arrays = []) → new_array click to toggle source

Returns a new array containing only those elements from self that are not found in any of the given other_arrays; items are compared using eql?; order from self is preserved:

[0, 1, 1, 2, 1, 1, 3, 1, 1].difference([1]) [0, 1, 2, 3].difference([3, 0], [1, 3])
[0, 1, 2].difference([4])
[0, 1, 2].difference

Returns a copy of self if no arguments are given.

Related: Array#-; see also Methods for Combining.

static VALUE rb_ary_difference_multi(int argc, VALUE *argv, VALUE ary) { VALUE ary_diff; long i, length; volatile VALUE t0; bool *is_hash = ALLOCV_N(bool, t0, argc); ary_diff = rb_ary_new(); length = RARRAY_LEN(ary);

for (i = 0; i < argc; i++) {
    argv[i] = to_ary(argv[i]);
    is_hash[i] = (length > SMALL_ARRAY_LEN && RARRAY_LEN(argv[i]) > SMALL_ARRAY_LEN);
    if (is_hash[i]) argv[i] = ary_make_hash(argv[i]);
}

for (i = 0; i < RARRAY_LEN(ary); i++) {
    int j;
    VALUE elt = rb_ary_elt(ary, i);
    for (j = 0; j < argc; j++) {
        if (is_hash[j]) {
            if (rb_hash_stlike_lookup(argv[j], RARRAY_AREF(ary, i), NULL))
                break;
        }
        else {
            if (rb_ary_includes_by_eql(argv[j], elt)) break;
        }
    }
    if (j == argc) rb_ary_push(ary_diff, elt);
}

ALLOCV_END(t0);

return ary_diff;

}

dig(index, *identifiers) → object click to toggle source

Finds and returns the object in nested object specified by index and identifiers; the nested objects may be instances of various classes. See Dig Methods.

Examples:

a = [:foo, [:bar, :baz, [:bat, :bam]]] a.dig(1) a.dig(1, 2) a.dig(1, 2, 0) a.dig(1, 2, 3)

Related: see Methods for Fetching.

static VALUE rb_ary_dig(int argc, VALUE *argv, VALUE self) { rb_check_arity(argc, 1, UNLIMITED_ARGUMENTS); self = rb_ary_at(self, *argv); if (!--argc) return self; ++argv; return rb_obj_dig(argc, argv, self, Qnil); }

drop(count) → new_array click to toggle source

Returns a new array containing all but the first count element of self, where count is a non-negative integer; does not modify self.

Examples:

a = [0, 1, 2, 3, 4, 5] a.drop(0) a.drop(1) a.drop(2) a.drop(9)

Related: see Methods for Fetching.

static VALUE rb_ary_drop(VALUE ary, VALUE n) { VALUE result; long pos = NUM2LONG(n); if (pos < 0) { rb_raise(rb_eArgError, "attempt to drop negative size"); }

result = rb_ary_subseq(ary, pos, RARRAY_LEN(ary));
if (NIL_P(result)) result = rb_ary_new();
return result;

}

drop_while {|element| ... } → new_array click to toggle source

drop_while → new_enumerator

With a block given, calls the block with each successive element of self; stops if the block returns false or nil; returns a new array omitting those elements for which the block returned a truthy value; does not modify self:

a = [0, 1, 2, 3, 4, 5] a.drop_while {|element| element < 3 }

With no block given, returns a new Enumerator.

Related: see Methods for Fetching.

static VALUE rb_ary_drop_while(VALUE ary) { long i;

RETURN_ENUMERATOR(ary, 0, 0);
for (i = 0; i < RARRAY_LEN(ary); i++) {
    if (!RTEST(rb_yield(RARRAY_AREF(ary, i)))) break;
}
return rb_ary_drop(ary, LONG2FIX(i));

}

each {|element| ... } → self click to toggle source

each → new_enumerator

With a block given, iterates over the elements of self, passing each element to the block; returns self:

a = [:foo, 'bar', 2] a.each {|element| puts "#{element.class} #{element}" }

Output:

Symbol foo String bar Integer 2

Allows the array to be modified during iteration:

a = [:foo, 'bar', 2] a.each {|element| puts element; a.clear if element.to_s.start_with?('b') }

Output:

foo bar

With no block given, returns a new Enumerator.

Related: see Methods for Iterating.

VALUE rb_ary_each(VALUE ary) { long i; ary_verify(ary); RETURN_SIZED_ENUMERATOR(ary, 0, 0, ary_enum_length); for (i=0; i<RARRAY_LEN(ary); i++) { rb_yield(RARRAY_AREF(ary, i)); } return ary; }

each_index {|index| ... } → self click to toggle source

each_index → new_enumerator

With a block given, iterates over the elements of self, passing each array index to the block; returns self:

a = [:foo, 'bar', 2] a.each_index {|index| puts "#{index} #{a[index]}" }

Output:

0 foo 1 bar 2 2

Allows the array to be modified during iteration:

a = [:foo, 'bar', 2] a.each_index {|index| puts index; a.clear if index > 0 } a

Output:

0 1

With no block given, returns a new Enumerator.

Related: see Methods for Iterating.

static VALUE rb_ary_each_index(VALUE ary) { long i; RETURN_SIZED_ENUMERATOR(ary, 0, 0, ary_enum_length);

for (i=0; i<RARRAY_LEN(ary); i++) {
    rb_yield(LONG2NUM(i));
}
return ary;

}

empty? → true or false click to toggle source

Returns true if the count of elements in self is zero, false otherwise.

Related: see Methods for Querying.

static VALUE rb_ary_empty_p(VALUE ary) { return RBOOL(RARRAY_LEN(ary) == 0); }

eql?(other_array) → true or false click to toggle source

Returns true if self and other_array are the same size, and if, for each index i in self, self[i].eql?(other_array[i]):

a0 = [:foo, 'bar', 2] a1 = [:foo, 'bar', 2] a1.eql?(a0)

Otherwise, returns false.

This method is different from method Array#==, which compares using method Object#==.

Related: see Methods for Querying.

static VALUE rb_ary_eql(VALUE ary1, VALUE ary2) { if (ary1 == ary2) return Qtrue; if (!RB_TYPE_P(ary2, T_ARRAY)) return Qfalse; if (RARRAY_LEN(ary1) != RARRAY_LEN(ary2)) return Qfalse; if (RARRAY_CONST_PTR(ary1) == RARRAY_CONST_PTR(ary2)) return Qtrue; return rb_exec_recursive_paired(recursive_eql, ary1, ary2, ary2); }

fetch(index) → element click to toggle source

fetch(index, default_value) → element or default_value

fetch(index) {|index| ... } → element or block_return_value

Returns the element of self at offset index if index is in range; index must be an integer-convertible object.

With the single argument index and no block, returns the element at offset index:

a = [:foo, 'bar', 2] a.fetch(1)
a.fetch(1.1)

If index is negative, counts from the end of the array:

a = [:foo, 'bar', 2] a.fetch(-1) a.fetch(-2)

With arguments index and default_value (which may be any object) and no block, returns default_value if index is out-of-range:

a = [:foo, 'bar', 2] a.fetch(1, nil)
a.fetch(3, :foo)

With argument index and a block, returns the element at offset index if index is in range (and the block is not called); otherwise calls the block with index and returns its return value:

a = [:foo, 'bar', 2] a.fetch(1) {|index| raise 'Cannot happen' } a.fetch(50) {|index| "Value for #{index}" }

Related: see Methods for Fetching.

static VALUE rb_ary_fetch(int argc, VALUE *argv, VALUE ary) { VALUE pos, ifnone; long block_given; long idx;

rb_scan_args(argc, argv, "11", &pos, &ifnone);
block_given = rb_block_given_p();
if (block_given && argc == 2) {
    rb_warn("block supersedes default value argument");
}
idx = NUM2LONG(pos);

if (idx < 0) {
    idx +=  RARRAY_LEN(ary);
}
if (idx < 0 || RARRAY_LEN(ary) <= idx) {
    if (block_given) return rb_yield(pos);
    if (argc == 1) {
        rb_raise(rb_eIndexError, "index %ld outside of array bounds: %ld...%ld",
                    idx - (idx < 0 ? RARRAY_LEN(ary) : 0), -RARRAY_LEN(ary), RARRAY_LEN(ary));
    }
    return ifnone;
}
return RARRAY_AREF(ary, idx);

}

fetch_values(*indexes) → new_array click to toggle source

fetch_values(*indexes) { |index| ... } → new_array

With no block given, returns a new array containing the elements of self at the offsets specified by indexes. Each of the indexes must be an integer-convertible object:

a = [:foo, :bar, :baz] a.fetch_values(2, 0)
a.fetch_values(2.1, 0) a.fetch_values

For a negative index, counts backwards from the end of the array:

a.fetch_values(-2, -1)

When no block is given, raises an exception if any index is out of range.

With a block given, for each index:

Example:

a = [:foo, :bar, :baz] a.fetch_values(1, 0, 42, 777) { |index| index.to_s }

Related: see Methods for Fetching.

def fetch_values(*indexes, &block) indexes.map! { |i| fetch(i, &block) } indexes end

fill(object, start = nil, count = nil) → new_array click to toggle source

fill(object, range) → new_array

fill(start = nil, count = nil) {|element| ... } → new_array

fill(range) {|element| ... } → new_array

Replaces selected elements in self; may add elements to self; always returns self (never a new array).

In brief:

['a', 'b', 'c', 'd'].fill('-', 1, 2)
['a', 'b', 'c', 'd'].fill(1, 2) {|e| e.to_s }

['a', 'b', 'c', 'd'].fill('-', 3, 2)
['a', 'b', 'c', 'd'].fill(3, 2) {|e| e.to_s }

['a', 'b', 'c', 'd'].fill('-', 6, 2)
['a', 'b', 'c', 'd'].fill(6, 2) {|e| e.to_s }

['a', 'b', 'c', 'd'].fill('-', -3, 3)
['a', 'b', 'c', 'd'].fill(-3, 3) {|e| e.to_s }

['a', 'b', 'c', 'd'].fill('-', 1..2)
['a', 'b', 'c', 'd'].fill(1..2) {|e| e.to_s }

When arguments start and count are given, they select the elements of self to be replaced; each must be an integer-convertible object (or nil):

With argument object given, that one object is used for all replacements:

o = Object.new
a = ['a', 'b', 'c', 'd'] a.fill(o, 1, 2)

With a block given, the block is called once for each element to be replaced; the value passed to the block is the index of the element to be replaced (not the element itself); the block’s return value replaces the element:

a = ['a', 'b', 'c', 'd']
a.fill(1, 2) {|element| element.to_s }

For arguments start and count:

When argument range is given, it must be a Range object whose members are numeric; its begin and end values determine the elements of self to be replaced:

Related: see Methods for Assigning.

static VALUE rb_ary_fill(int argc, VALUE *argv, VALUE ary) { VALUE item = Qundef, arg1, arg2; long beg = 0, end = 0, len = 0;

if (rb_block_given_p()) {
    rb_scan_args(argc, argv, "02", &arg1, &arg2);
    argc += 1;              /* hackish */
}
else {
    rb_scan_args(argc, argv, "12", &item, &arg1, &arg2);
}
switch (argc) {
  case 1:
    beg = 0;
    len = RARRAY_LEN(ary);
    break;
  case 2:
    if (rb_range_beg_len(arg1, &beg, &len, RARRAY_LEN(ary), 1)) {
        break;
    }
    /* fall through */
  case 3:
    beg = NIL_P(arg1) ? 0 : NUM2LONG(arg1);
    if (beg < 0) {
        beg = RARRAY_LEN(ary) + beg;
        if (beg < 0) beg = 0;
    }
    len = NIL_P(arg2) ? RARRAY_LEN(ary) - beg : NUM2LONG(arg2);
    break;
}
rb_ary_modify(ary);
if (len < 0) {
    return ary;
}
if (beg >= ARY_MAX_SIZE || len > ARY_MAX_SIZE - beg) {
    rb_raise(rb_eArgError, "argument too big");
}
end = beg + len;
if (RARRAY_LEN(ary) < end) {
    if (end >= ARY_CAPA(ary)) {
        ary_resize_capa(ary, end);
    }
    ary_mem_clear(ary, RARRAY_LEN(ary), end - RARRAY_LEN(ary));
    ARY_SET_LEN(ary, end);
}

if (UNDEF_P(item)) {
    VALUE v;
    long i;

    for (i=beg; i<end; i++) {
        v = rb_yield(LONG2NUM(i));
        if (i>=RARRAY_LEN(ary)) break;
        ARY_SET(ary, i, v);
    }
}
else {
    ary_memfill(ary, beg, len, item);
}
return ary;

}

filter {|element| ... } → new_array

filter → new_enumerator

With a block given, calls the block with each element of self; returns a new array containing those elements of self for which the block returns a truthy value:

a = [:foo, 'bar', 2, :bam] a.select {|element| element.to_s.start_with?('b') }

With no block given, returns a new Enumerator.

Related: see Methods for Fetching.

filter! {|element| ... } → self or nil

filter! → new_enumerator

With a block given, calls the block with each element of self; removes from self those elements for which the block returns false or nil.

Returns self if any elements were removed:

a = [:foo, 'bar', 2, :bam] a.select! {|element| element.to_s.start_with?('b') }

Returns nil if no elements were removed.

With no block given, returns a new Enumerator.

Related: see Methods for Deleting.

find_index -> new_enumerator click to toggle source

Returns the zero-based integer index of a specified element, or nil.

With only argument object given, returns the index of the first element element for which object == element:

a = [:foo, 'bar', 2, 'bar'] a.index('bar')

Returns nil if no such element found.

With only a block given, calls the block with each successive element; returns the index of the first element for which the block returns a truthy value:

a = [:foo, 'bar', 2, 'bar'] a.index {|element| element == 'bar' }

Returns nil if the block never returns a truthy value.

With neither an argument nor a block given, returns a new Enumerator.

Related: see Methods for Querying.

static VALUE rb_ary_index(int argc, VALUE *argv, VALUE ary) { VALUE val; long i;

if (argc == 0) {
    RETURN_ENUMERATOR(ary, 0, 0);
    for (i=0; i<RARRAY_LEN(ary); i++) {
        if (RTEST(rb_yield(RARRAY_AREF(ary, i)))) {
            return LONG2NUM(i);
        }
    }
    return Qnil;
}
rb_check_arity(argc, 0, 1);
val = argv[0];
if (rb_block_given_p())
    rb_warn("given block not used");
for (i=0; i<RARRAY_LEN(ary); i++) {
    VALUE e = RARRAY_AREF(ary, i);
    if (rb_equal(e, val)) {
        return LONG2NUM(i);
    }
}
return Qnil;

}

Also aliased as: index

first → object or nil click to toggle source

first(count) → new_array

Returns elements from self, or nil; does not modify self.

With no argument given, returns the first element (if available):

a = [:foo, 'bar', 2] a.first a

If self is empty, returns nil.

[].first

With a non-negative integer argument count given, returns the first count elements (as available) in a new array:

a.first(0)
a.first(2)
a.first(50)

Related: see Methods for Querying.

def first n = unspecified = true if Primitive.mandatory_only? Primitive.attr! :leaf Primitive.cexpr! %q{ ary_first(self) } else if unspecified Primitive.cexpr! %q{ ary_first(self) } else Primitive.cexpr! %q{ ary_take_first_or_last_n(self, NUM2LONG(n), ARY_TAKE_FIRST) } end end end

flatten(depth = nil) → new_array click to toggle source

Returns a new array that is a recursive flattening of self to depth levels of recursion; depth must be an integer-convertible object or nil. At each level of recursion:

With non-negative integer argument depth, flattens recursively through depth levels:

a = [ 0, [ 1, [2, 3], 4 ], 5, {foo: 0}, Set.new([6, 7]) ] a
a.flatten(0)
a.flatten(1 ) a.flatten(1.1) a.flatten(2)
a.flatten(3)

With nil or negative depth, flattens all levels.

a.flatten
a.flatten(-1)

Related: Array#flatten!; see also Methods for Converting.

static VALUE rb_ary_flatten(int argc, VALUE *argv, VALUE ary) { int level = -1; VALUE result;

if (rb_check_arity(argc, 0, 1) && !NIL_P(argv[0])) {
    level = NUM2INT(argv[0]);
    if (level == 0) return ary_make_shared_copy(ary);
}

result = flatten(ary, level);
if (result == ary) {
    result = ary_make_shared_copy(ary);
}

return result;

}

flatten!(depth = nil) → self or nil click to toggle source

Returns self as a recursively flattening of self to depth levels of recursion; depth must be an integer-convertible object, or nil. At each level of recursion:

Returns nil if no elements were flattened.

With non-negative integer argument depth, flattens recursively through depth levels:

a = [ 0, [ 1, [2, 3], 4 ], 5, {foo: 0}, Set.new([6, 7]) ] a
a.dup.flatten!(1)
a.dup.flatten!(1.1) a.dup.flatten!(2)
a.dup.flatten!(3)

With nil or negative argument depth, flattens all levels:

a.dup.flatten!
a.dup.flatten!(-1)

Related: Array#flatten; see also Methods for Assigning.

static VALUE rb_ary_flatten_bang(int argc, VALUE *argv, VALUE ary) { int mod = 0, level = -1; VALUE result, lv;

lv = (rb_check_arity(argc, 0, 1) ? argv[0] : Qnil);
rb_ary_modify_check(ary);
if (!NIL_P(lv)) level = NUM2INT(lv);
if (level == 0) return Qnil;

result = flatten(ary, level);
if (result == ary) {
    return Qnil;
}
if (!(mod = ARY_EMBED_P(result))) rb_ary_freeze(result);
rb_ary_replace(ary, result);
if (mod) ARY_SET_EMBED_LEN(result, 0);

return ary;

}

freeze → self click to toggle source

Freezes self (if not already frozen); returns self:

a = [] a.frozen? a.freeze a.frozen?

No further changes may be made to self; raises FrozenError if a change is attempted.

Related: Kernel#frozen?.

VALUE rb_ary_freeze(VALUE ary) { RUBY_ASSERT(RB_TYPE_P(ary, T_ARRAY));

if (OBJ_FROZEN(ary)) return ary;

if (!ARY_EMBED_P(ary) && !ARY_SHARED_P(ary) && !ARY_SHARED_ROOT_P(ary)) {
    ary_shrink_capa(ary);
}

return rb_obj_freeze(ary);

}

hash → integer click to toggle source

Returns the integer hash value for self.

Two arrays with the same content will have the same hash value (and will compare using eql?):

['a', 'b'].hash == ['a', 'b'].hash ['a', 'b'].hash == ['a', 'c'].hash ['a', 'b'].hash == ['a'].hash

static VALUE rb_ary_hash(VALUE ary) { return rb_ary_hash_values(RARRAY_LEN(ary), RARRAY_CONST_PTR(ary)); }

include?(object) → true or false click to toggle source

Returns whether for some element element in self, object == element:

[0, 1, 2].include?(2)
[0, 1, 2].include?(2.0) [0, 1, 2].include?(2.1)

Related: see Methods for Querying.

VALUE rb_ary_includes(VALUE ary, VALUE item) { long i; VALUE e;

for (i=0; i<RARRAY_LEN(ary); i++) {
    e = RARRAY_AREF(ary, i);
    if (rb_equal(e, item)) {
        return Qtrue;
    }
}
return Qfalse;

}

index(object) → integer or nil

index {|element| ... } → integer or nil

index → new_enumerator

Returns the zero-based integer index of a specified element, or nil.

With only argument object given, returns the index of the first element element for which object == element:

a = [:foo, 'bar', 2, 'bar'] a.index('bar')

Returns nil if no such element found.

With only a block given, calls the block with each successive element; returns the index of the first element for which the block returns a truthy value:

a = [:foo, 'bar', 2, 'bar'] a.index {|element| element == 'bar' }

Returns nil if the block never returns a truthy value.

With neither an argument nor a block given, returns a new Enumerator.

Related: see Methods for Querying.

initialize_copy(other_array) → self click to toggle source

Replaces the elements of self with the elements of other_array, which must be an array-convertible object; returns self:

a = ['a', 'b', 'c']
a.replace(['d', 'e'])

Related: see Methods for Assigning.

VALUE rb_ary_replace(VALUE copy, VALUE orig) { rb_ary_modify_check(copy); orig = to_ary(orig); if (copy == orig) return copy;

rb_ary_reset(copy);

/* orig has enough space to embed the contents of orig. */
if (RARRAY_LEN(orig) <= ary_embed_capa(copy)) {
    RUBY_ASSERT(ARY_EMBED_P(copy));
    ary_memcpy(copy, 0, RARRAY_LEN(orig), RARRAY_CONST_PTR(orig));
    ARY_SET_EMBED_LEN(copy, RARRAY_LEN(orig));
}
/* orig is embedded but copy does not have enough space to embed the
 * contents of orig. */
else if (ARY_EMBED_P(orig)) {
    long len = ARY_EMBED_LEN(orig);
    VALUE *ptr = ary_heap_alloc_buffer(len);

    FL_UNSET_EMBED(copy);
    ARY_SET_PTR(copy, ptr);
    ARY_SET_LEN(copy, len);
    ARY_SET_CAPA(copy, len);

    // No allocation and exception expected that could leave `copy` in a
    // bad state from the edits above.
    ary_memcpy(copy, 0, len, RARRAY_CONST_PTR(orig));
}
/* Otherwise, orig is on heap and copy does not have enough space to embed
 * the contents of orig. */
else {
    VALUE shared_root = ary_make_shared(orig);
    FL_UNSET_EMBED(copy);
    ARY_SET_PTR(copy, ARY_HEAP_PTR(orig));
    ARY_SET_LEN(copy, ARY_HEAP_LEN(orig));
    rb_ary_set_shared(copy, shared_root);
}
ary_verify(copy);
return copy;

}

insert(index, *objects) → self click to toggle source

Inserts the given objects as elements of self; returns self.

When index is non-negative, inserts objects before the element at offset index:

a = ['a', 'b', 'c']
a.insert(1, :x, :y, :z)

Extends the array if index is beyond the array (index >= self.size):

a = ['a', 'b', 'c']
a.insert(5, :x, :y, :z)

When index is negative, inserts objects after the element at offset index + self.size:

a = ['a', 'b', 'c']
a.insert(-2, :x, :y, :z)

With no objects given, does nothing:

a = ['a', 'b', 'c'] a.insert(1)
a.insert(50)
a.insert(-50)

Raises IndexError if objects are given and index is negative and out of range.

Related: see Methods for Assigning.

static VALUE rb_ary_insert(int argc, VALUE *argv, VALUE ary) { long pos;

rb_check_arity(argc, 1, UNLIMITED_ARGUMENTS);
rb_ary_modify_check(ary);
pos = NUM2LONG(argv[0]);
if (argc == 1) return ary;
if (pos == -1) {
    pos = RARRAY_LEN(ary);
}
else if (pos < 0) {
    long minpos = -RARRAY_LEN(ary) - 1;
    if (pos < minpos) {
        rb_raise(rb_eIndexError, "index %ld too small for array; minimum: %ld",
                 pos, minpos);
    }
    pos++;
}
rb_ary_splice(ary, pos, 0, argv + 1, argc - 1);
return ary;

}

inspect → new_string click to toggle source

Returns the new string formed by calling method #inspect on each array element:

a = [:foo, 'bar', 2] a.inspect

Related: see Methods for Converting.

static VALUE rb_ary_inspect(VALUE ary) { if (RARRAY_LEN(ary) == 0) return rb_usascii_str_new2("[]"); return rb_exec_recursive(inspect_ary, ary, 0); }

Also aliased as: to_s

intersect?(other_array) → true or false click to toggle source

Returns whether other_array has at least one element that is #eql? to some element of self:

[1, 2, 3].intersect?([3, 4, 5]) [1, 2, 3].intersect?([4, 5, 6])

Each element must correctly implement method #hash.

Related: see Methods for Querying.

static VALUE rb_ary_intersect_p(VALUE ary1, VALUE ary2) { VALUE hash, v, result, shorter, longer; st_data_t vv; long i;

ary2 = to_ary(ary2);
if (RARRAY_LEN(ary1) == 0 || RARRAY_LEN(ary2) == 0) return Qfalse;

if (RARRAY_LEN(ary1) <= SMALL_ARRAY_LEN && RARRAY_LEN(ary2) <= SMALL_ARRAY_LEN) {
    for (i=0; i<RARRAY_LEN(ary1); i++) {
        v = RARRAY_AREF(ary1, i);
        if (rb_ary_includes_by_eql(ary2, v)) return Qtrue;
    }
    return Qfalse;
}

shorter = ary1;
longer = ary2;
if (RARRAY_LEN(ary1) > RARRAY_LEN(ary2)) {
    longer = ary1;
    shorter = ary2;
}

hash = ary_make_hash(shorter);
result = Qfalse;

for (i=0; i<RARRAY_LEN(longer); i++) {
    v = RARRAY_AREF(longer, i);
    vv = (st_data_t)v;
    if (rb_hash_stlike_lookup(hash, vv, 0)) {
        result = Qtrue;
        break;
    }
}

return result;

}

intersection(*other_arrays) → new_array click to toggle source

Returns a new array containing each element in self that is #eql? to at least one element in each of the given other_arrays; duplicates are omitted:

[0, 0, 1, 1, 2, 3].intersection([0, 1, 2], [0, 1, 3])

Each element must correctly implement method #hash.

Order from self is preserved:

[0, 1, 2].intersection([2, 1, 0])

Returns a copy of self if no arguments are given.

Related: see Methods for Combining.

static VALUE rb_ary_intersection_multi(int argc, VALUE *argv, VALUE ary) { VALUE result = rb_ary_dup(ary); int i;

for (i = 0; i < argc; i++) {
    result = rb_ary_and(result, argv[i]);
}

return result;

}

join(separator = $,) → new_string click to toggle source

Returns the new string formed by joining the converted elements of self; for each element element:

With no argument given, joins using the output field separator, $,:

a = [:foo, 'bar', 2] $, a.join

With string argument separator given, joins using that separator:

a = [:foo, 'bar', 2] a.join("\n")

Joins recursively for nested arrays:

a = [:foo, [:bar, [:baz, :bat]]] a.join

Related: see Methods for Converting.

static VALUE rb_ary_join_m(int argc, VALUE *argv, VALUE ary) { VALUE sep;

if (rb_check_arity(argc, 0, 1) == 0 || NIL_P(sep = argv[0])) {
    sep = rb_output_fs;
    if (!NIL_P(sep)) {
        rb_category_warn(RB_WARN_CATEGORY_DEPRECATED, "$, is set to non-nil value");
    }
}

return rb_ary_join(ary, sep);

}

keep_if {|element| ... } → self click to toggle source

keep_if → new_enumerator

With a block given, calls the block with each element of self; removes the element from self if the block does not return a truthy value:

a = [:foo, 'bar', 2, :bam] a.keep_if {|element| element.to_s.start_with?('b') }

With no block given, returns a new Enumerator.

Related: see Methods for Deleting.

static VALUE rb_ary_keep_if(VALUE ary) { RETURN_SIZED_ENUMERATOR(ary, 0, 0, ary_enum_length); rb_ary_select_bang(ary); return ary; }

last → last_object or nil click to toggle source

last(count) → new_array

Returns elements from self, or nil; self is not modified.

With no argument given, returns the last element, or nil if self is empty:

a = [:foo, 'bar', 2] a.last a [].last

With non-negative integer argument count given, returns a new array containing the trailing count elements of self, as available:

a = [:foo, 'bar', 2] a.last(2)
a.last(50) a.last(0)
[].last(3)

Related: see Methods for Fetching.

def last n = unspecified = true if Primitive.mandatory_only? Primitive.attr! :leaf Primitive.cexpr! %q{ ary_last(self) } else if unspecified Primitive.cexpr! %q{ ary_last(self) } else Primitive.cexpr! %q{ ary_take_first_or_last_n(self, NUM2LONG(n), ARY_TAKE_LAST) } end end end

length → integer click to toggle source

Returns the count of elements in self:

[0, 1, 2].length [].length

Related: see Methods for Querying.

static VALUE rb_ary_length(VALUE ary) { long len = RARRAY_LEN(ary); return LONG2NUM(len); }

Also aliased as: size

map {|element| ... } → new_array

map → new_enumerator

With a block given, calls the block with each element of self; returns a new array whose elements are the return values from the block:

a = [:foo, 'bar', 2] a1 = a.map {|element| element.class } a1

With no block given, returns a new Enumerator.

Related: collect!; see also Methods for Converting.

Also aliased as: collect

map! {|element| ... } → new_array

map! → new_enumerator

With a block given, calls the block with each element of self and replaces the element with the block’s return value; returns self:

a = [:foo, 'bar', 2] a.map! { |element| element.class }

With no block given, returns a new Enumerator.

Related: collect; see also Methods for Converting.

max → element click to toggle source

max(count) → new_array

max {|a, b| ... } → element

max(count) {|a, b| ... } → new_array

Returns one of the following:

Does not modify self.

With no block given, each element in self must respond to method #<=> with a numeric.

With no argument and no block, returns the element in self having the maximum value per method #<=>:

[1, 0, 3, 2].max

With non-negative numeric argument count and no block, returns a new array with at most count elements, in descending order, per method #<=>:

[1, 0, 3, 2].max(3)
[1, 0, 3, 2].max(3.0) [1, 0, 3, 2].max(9)
[1, 0, 3, 2].max(0)

With a block given, the block must return a numeric.

With a block and no argument, calls the block self.size - 1 times to compare elements; returns the element having the maximum value per the block:

['0', '', '000', '00'].max {|a, b| a.size <=> b.size }

With non-negative numeric argument count and a block, returns a new array with at most count elements, in descending order, per the block:

['0', '', '000', '00'].max(2) {|a, b| a.size <=> b.size }

Related: see Methods for Fetching.

static VALUE rb_ary_max(int argc, VALUE *argv, VALUE ary) { VALUE result = Qundef, v; VALUE num; long i;

if (rb_check_arity(argc, 0, 1) && !NIL_P(num = argv[0]))
   return rb_nmin_run(ary, num, 0, 1, 1);

const long n = RARRAY_LEN(ary);
if (rb_block_given_p()) {
    for (i = 0; i < RARRAY_LEN(ary); i++) {
       v = RARRAY_AREF(ary, i);
       if (UNDEF_P(result) || rb_cmpint(rb_yield_values(2, v, result), v, result) > 0) {
           result = v;
       }
    }
}
else if (n > 0) {
    result = RARRAY_AREF(ary, 0);
    if (n > 1) {
        if (FIXNUM_P(result) && CMP_OPTIMIZABLE(INTEGER)) {
            return ary_max_opt_fixnum(ary, 1, result);
        }
        else if (STRING_P(result) && CMP_OPTIMIZABLE(STRING)) {
            return ary_max_opt_string(ary, 1, result);
        }
        else if (RB_FLOAT_TYPE_P(result) && CMP_OPTIMIZABLE(FLOAT)) {
            return ary_max_opt_float(ary, 1, result);
        }
        else {
            return ary_max_generic(ary, 1, result);
        }
    }
}
if (UNDEF_P(result)) return Qnil;
return result;

}

min → element click to toggle source

min(count) → new_array

min {|a, b| ... } → element

min(count) {|a, b| ... } → new_array

Returns one of the following:

Does not modify self.

With no block given, each element in self must respond to method #<=> with a numeric.

With no argument and no block, returns the element in self having the minimum value per method #<=>:

[1, 0, 3, 2].min

With non-negative numeric argument count and no block, returns a new array with at most count elements, in ascending order, per method #<=>:

[1, 0, 3, 2].min(3)
[1, 0, 3, 2].min(3.0) [1, 0, 3, 2].min(9)
[1, 0, 3, 2].min(0)

With a block given, the block must return a numeric.

With a block and no argument, calls the block self.size - 1 times to compare elements; returns the element having the minimum value per the block:

['0', '', '000', '00'].min {|a, b| a.size <=> b.size }

With non-negative numeric argument count and a block, returns a new array with at most count elements, in ascending order, per the block:

['0', '', '000', '00'].min(2) {|a, b| a.size <=> b.size }

Related: see Methods for Fetching.

static VALUE rb_ary_min(int argc, VALUE *argv, VALUE ary) { VALUE result = Qundef, v; VALUE num; long i;

if (rb_check_arity(argc, 0, 1) && !NIL_P(num = argv[0]))
   return rb_nmin_run(ary, num, 0, 0, 1);

const long n = RARRAY_LEN(ary);
if (rb_block_given_p()) {
    for (i = 0; i < RARRAY_LEN(ary); i++) {
       v = RARRAY_AREF(ary, i);
       if (UNDEF_P(result) || rb_cmpint(rb_yield_values(2, v, result), v, result) < 0) {
           result = v;
       }
    }
}
else if (n > 0) {
    result = RARRAY_AREF(ary, 0);
    if (n > 1) {
        if (FIXNUM_P(result) && CMP_OPTIMIZABLE(INTEGER)) {
            return ary_min_opt_fixnum(ary, 1, result);
        }
        else if (STRING_P(result) && CMP_OPTIMIZABLE(STRING)) {
            return ary_min_opt_string(ary, 1, result);
        }
        else if (RB_FLOAT_TYPE_P(result) && CMP_OPTIMIZABLE(FLOAT)) {
            return ary_min_opt_float(ary, 1, result);
        }
        else {
            return ary_min_generic(ary, 1, result);
        }
    }
}
if (UNDEF_P(result)) return Qnil;
return result;

}

minmax → array click to toggle source

minmax {|a, b| ... } → array

Returns a 2-element array containing the minimum-valued and maximum-valued elements from self; does not modify self.

With no block given, the minimum and maximum values are determined using method #<=>:

[1, 0, 3, 2].minmax

With a block given, the block must return a numeric; the block is called self.size - 1 times to compare elements; returns the elements having the minimum and maximum values per the block:

['0', '', '000', '00'].minmax {|a, b| a.size <=> b.size }

Related: see Methods for Fetching.

static VALUE rb_ary_minmax(VALUE ary) { if (rb_block_given_p()) { return rb_call_super(0, NULL); } return rb_assoc_new(rb_ary_min(0, 0, ary), rb_ary_max(0, 0, ary)); }

none? → true or false click to toggle source

none?(object) → true or false

none? {|element| ... } → true or false

Returns true if no element of self meets a given criterion, false otherwise.

With no block given and no argument, returns true if self has no truthy elements, false otherwise:

[nil, false].none?
[nil, 0, false].none? [].none?

With argument object given, returns false if for any element element, object === element; true otherwise:

['food', 'drink'].none?(/bar/) ['food', 'drink'].none?(/foo/) [].none?(/foo/)
[0, 1, 2].none?(3)
[0, 1, 2].none?(1)

With a block given, calls the block with each element in self; returns true if the block returns no truthy value, false otherwise:

[0, 1, 2].none? {|element| element > 3 } [0, 1, 2].none? {|element| element > 1 }

Related: see Methods for Querying.

static VALUE rb_ary_none_p(int argc, VALUE *argv, VALUE ary) { long i, len = RARRAY_LEN(ary);

rb_check_arity(argc, 0, 1);
if (!len) return Qtrue;
if (argc) {
    if (rb_block_given_p()) {
        rb_warn("given block not used");
    }
    for (i = 0; i < RARRAY_LEN(ary); ++i) {
        if (RTEST(rb_funcall(argv[0], idEqq, 1, RARRAY_AREF(ary, i)))) return Qfalse;
    }
}
else if (!rb_block_given_p()) {
    for (i = 0; i < len; ++i) {
        if (RTEST(RARRAY_AREF(ary, i))) return Qfalse;
    }
}
else {
    for (i = 0; i < RARRAY_LEN(ary); ++i) {
        if (RTEST(rb_yield(RARRAY_AREF(ary, i)))) return Qfalse;
    }
}
return Qtrue;

}

one? → true or false click to toggle source

one? {|element| ... } → true or false

one?(object) → true or false

Returns true if exactly one element of self meets a given criterion.

With no block given and no argument, returns true if self has exactly one truthy element, false otherwise:

[nil, 0].one? [0, 0].one? [nil, nil].one? [].one?

With a block given, calls the block with each element in self; returns true if the block a truthy value for exactly one element, false otherwise:

[0, 1, 2].one? {|element| element > 0 } [0, 1, 2].one? {|element| element > 1 } [0, 1, 2].one? {|element| element > 2 }

With argument object given, returns true if for exactly one element element, object === element; false otherwise:

[0, 1, 2].one?(0) [0, 0, 1].one?(0) [1, 1, 2].one?(0) ['food', 'drink'].one?(/bar/) ['food', 'drink'].one?(/foo/) [].one?(/foo/)

Related: see Methods for Querying.

static VALUE rb_ary_one_p(int argc, VALUE *argv, VALUE ary) { long i, len = RARRAY_LEN(ary); VALUE result = Qfalse;

rb_check_arity(argc, 0, 1);
if (!len) return Qfalse;
if (argc) {
    if (rb_block_given_p()) {
        rb_warn("given block not used");
    }
    for (i = 0; i < RARRAY_LEN(ary); ++i) {
        if (RTEST(rb_funcall(argv[0], idEqq, 1, RARRAY_AREF(ary, i)))) {
            if (result) return Qfalse;
            result = Qtrue;
        }
    }
}
else if (!rb_block_given_p()) {
    for (i = 0; i < len; ++i) {
        if (RTEST(RARRAY_AREF(ary, i))) {
            if (result) return Qfalse;
            result = Qtrue;
        }
    }
}
else {
    for (i = 0; i < RARRAY_LEN(ary); ++i) {
        if (RTEST(rb_yield(RARRAY_AREF(ary, i)))) {
            if (result) return Qfalse;
            result = Qtrue;
        }
    }
}
return result;

}

pack(template, buffer: nil) → string click to toggle source

Formats each element in self into a binary string; returns that string. See Packed Data.

def pack(fmt, buffer: nil) Primitive.pack_pack(fmt, buffer) end

permutation(count = self.size) {|permutation| ... } → self click to toggle source

permutation(count = self.size) → new_enumerator

Iterates over permutations of the elements of self; the order of permutations is indeterminate.

With a block and an in-range positive integer argument count (0 < count <= self.size) given, calls the block with each permutation of self of size count; returns self:

a = [0, 1, 2] perms = [] a.permutation(1) {|perm| perms.push(perm) } perms

perms = [] a.permutation(2) {|perm| perms.push(perm) } perms

perms = [] a.permutation(3) {|perm| perms.push(perm) } perms

When count is zero, calls the block once with a new empty array:

perms = [] a.permutation(0) {|perm| perms.push(perm) } perms

When count is out of range (negative or larger than self.size), does not call the block:

a.permutation(-1) {|permutation| fail 'Cannot happen' } a.permutation(4) {|permutation| fail 'Cannot happen' }

With no block given, returns a new Enumerator.

Related: Methods for Iterating.

static VALUE rb_ary_permutation(int argc, VALUE *argv, VALUE ary) { long r, n, i;

n = RARRAY_LEN(ary);                  /* Array length */
RETURN_SIZED_ENUMERATOR(ary, argc, argv, rb_ary_permutation_size);   /* Return enumerator if no block */
r = n;
if (rb_check_arity(argc, 0, 1) && !NIL_P(argv[0]))
    r = NUM2LONG(argv[0]);            /* Permutation size from argument */

if (r < 0 || n < r) {
    /* no permutations: yield nothing */
}
else if (r == 0) { /* exactly one permutation: the zero-length array */
    rb_yield(rb_ary_new2(0));
}
else if (r == 1) { /* this is a special, easy case */
    for (i = 0; i < RARRAY_LEN(ary); i++) {
        rb_yield(rb_ary_new3(1, RARRAY_AREF(ary, i)));
    }
}
else {             /* this is the general case */
    volatile VALUE t0;
    long *p = ALLOCV_N(long, t0, r+roomof(n, sizeof(long)));
    char *used = (char*)(p + r);
    VALUE ary0 = ary_make_shared_copy(ary); /* private defensive copy of ary */
    RBASIC_CLEAR_CLASS(ary0);

    MEMZERO(used, char, n); /* initialize array */

    permute0(n, r, p, used, ary0); /* compute and yield permutations */
    ALLOCV_END(t0);
    RBASIC_SET_CLASS_RAW(ary0, rb_cArray);
}
return ary;

}

pop → object or nil click to toggle source

pop(count) → new_array

Removes and returns trailing elements of self.

With no argument given, removes and returns the last element, if available; otherwise returns nil:

a = [:foo, 'bar', 2] a.pop
a
[].pop

With non-negative integer argument count given, returns a new array containing the trailing count elements of self, as available:

a = [:foo, 'bar', 2] a.pop(2) a

a = [:foo, 'bar', 2] a.pop(50) a

Related: Array#push; see also Methods for Deleting.

static VALUE rb_ary_pop_m(int argc, VALUE *argv, VALUE ary) { VALUE result;

if (argc == 0) {
    return rb_ary_pop(ary);
}

rb_ary_modify_check(ary);
result = ary_take_first_or_last(argc, argv, ary, ARY_TAKE_LAST);
ARY_INCREASE_LEN(ary, -RARRAY_LEN(result));
ary_verify(ary);
return result;

}

product(*other_arrays) → new_array click to toggle source

product(*other_arrays) {|combination| ... } → self

Computes all combinations of elements from all the arrays, including both self and other_arrays:

With no block given, returns the combinations as an array of arrays:

p = [0, 1].product([2, 3])

p.size p = [0, 1].product([2, 3], [4, 5])

p.size

If self or any argument is empty, returns an empty array:

[].product([2, 3], [4, 5]) [0, 1].product([2, 3], [])

If no argument is given, returns an array of 1-element arrays, each containing an element of self:

a.product

With a block given, calls the block with each combination; returns self:

p = [] [0, 1].product([2, 3]) {|combination| p.push(combination) } p

If self or any argument is empty, does not call the block:

[].product([2, 3], [4, 5]) {|combination| fail 'Cannot happen' }

[0, 1].product([2, 3], []) {|combination| fail 'Cannot happen' }

If no argument is given, calls the block with each element of self as a 1-element array:

p = [] [0, 1].product {|combination| p.push(combination) } p

Related: see Methods for Combining.

static VALUE rb_ary_product(int argc, VALUE argv, VALUE ary) { int n = argc+1; / How many arrays we're operating on */ volatile VALUE t0 = rb_ary_hidden_new(n); volatile VALUE t1 = Qundef; VALUE arrays = RARRAY_PTR(t0); / The arrays we're computing the product of */ int counters = ALLOCV_N(int, t1, n); / The current position in each one / VALUE result = Qnil; / The array we'll be returning, when no block given */ long i,j; long resultlen = 1;

RBASIC_CLEAR_CLASS(t0);

/* initialize the arrays of arrays */
ARY_SET_LEN(t0, n);
arrays[0] = ary;
for (i = 1; i < n; i++) arrays[i] = Qnil;
for (i = 1; i < n; i++) arrays[i] = to_ary(argv[i-1]);

/* initialize the counters for the arrays */
for (i = 0; i < n; i++) counters[i] = 0;

/* Otherwise, allocate and fill in an array of results */
if (rb_block_given_p()) {
    /* Make defensive copies of arrays; exit if any is empty */
    for (i = 0; i < n; i++) {
        if (RARRAY_LEN(arrays[i]) == 0) goto done;
        arrays[i] = ary_make_shared_copy(arrays[i]);
    }
}
else {
    /* Compute the length of the result array; return [] if any is empty */
    for (i = 0; i < n; i++) {
        long k = RARRAY_LEN(arrays[i]);
        if (k == 0) {
            result = rb_ary_new2(0);
            goto done;
        }
        if (MUL_OVERFLOW_LONG_P(resultlen, k))
            rb_raise(rb_eRangeError, "too big to product");
        resultlen *= k;
    }
    result = rb_ary_new2(resultlen);
}
for (;;) {
    int m;
    /* fill in one subarray */
    VALUE subarray = rb_ary_new2(n);
    for (j = 0; j < n; j++) {
        rb_ary_push(subarray, rb_ary_entry(arrays[j], counters[j]));
    }

    /* put it on the result array */
    if (NIL_P(result)) {
        FL_SET(t0, RARRAY_SHARED_ROOT_FLAG);
        rb_yield(subarray);
        if (!FL_TEST(t0, RARRAY_SHARED_ROOT_FLAG)) {
            rb_raise(rb_eRuntimeError, "product reentered");
        }
        else {
            FL_UNSET(t0, RARRAY_SHARED_ROOT_FLAG);
        }
    }
    else {
        rb_ary_push(result, subarray);
    }

    /*
     * Increment the last counter.  If it overflows, reset to 0
     * and increment the one before it.
     */
    m = n-1;
    counters[m]++;
    while (counters[m] == RARRAY_LEN(arrays[m])) {
        counters[m] = 0;
        /* If the first counter overflows, we are done */
        if (--m < 0) goto done;
        counters[m]++;
    }
}

done: ALLOCV_END(t1);

return NIL_P(result) ? ary : result;

}

push(*objects) → self click to toggle source

Appends each argument in objects to self; returns self:

a = [:foo, 'bar', 2] a.push(:baz, :bat)

Appends each argument as a single element, even if it is another array:

a = [:foo, 'bar', 2]
a.push([:baz, :bat], [:bam, :bad])

Related: see Methods for Assigning.

static VALUE rb_ary_push_m(int argc, VALUE *argv, VALUE ary) { return rb_ary_cat(ary, argv, argc); }

rassoc(object) → found_array or nil click to toggle source

Returns the first element ele in self such that ele is an array and ele[1] == object:

a = [{foo: 0}, [2, 4], [4, 5, 6], [4, 5]] a.rassoc(4) a.rassoc(5)

Returns nil if no such element is found.

Related: Array#assoc; see also Methods for Fetching.

VALUE rb_ary_rassoc(VALUE ary, VALUE value) { long i; VALUE v;

for (i = 0; i < RARRAY_LEN(ary); ++i) {
    v = rb_check_array_type(RARRAY_AREF(ary, i));
    if (RB_TYPE_P(v, T_ARRAY) &&
        RARRAY_LEN(v) > 1 &&
        rb_equal(RARRAY_AREF(v, 1), value))
        return v;
}
return Qnil;

}

reject {|element| ... } → new_array click to toggle source

reject → new_enumerator

With a block given, returns a new array whose elements are all those from self for which the block returns false or nil:

a = [:foo, 'bar', 2, 'bat'] a1 = a.reject {|element| element.to_s.start_with?('b') } a1

With no block given, returns a new Enumerator.

Related: Methods for Fetching.

static VALUE rb_ary_reject(VALUE ary) { VALUE rejected_ary;

RETURN_SIZED_ENUMERATOR(ary, 0, 0, ary_enum_length);
rejected_ary = rb_ary_new();
ary_reject(ary, rejected_ary);
return rejected_ary;

}

reject! {|element| ... } → self or nil click to toggle source

reject! → new_enumerator

With a block given, calls the block with each element of self; removes each element for which the block returns a truthy value.

Returns self if any elements removed:

a = [:foo, 'bar', 2, 'bat'] a.reject! {|element| element.to_s.start_with?('b') }

Returns nil if no elements removed.

With no block given, returns a new Enumerator.

Related: see Methods for Deleting.

static VALUE rb_ary_reject_bang(VALUE ary) { RETURN_SIZED_ENUMERATOR(ary, 0, 0, ary_enum_length); rb_ary_modify(ary); return ary_reject_bang(ary); }

repeated_combination(size) {|combination| ... } → self click to toggle source

repeated_combination(size) → new_enumerator

With a block given, calls the block with each repeated combination of length size of the elements of self; each combination is an array; returns self. The order of the combinations is indeterminate.

If a positive integer argument size is given, calls the block with each size-tuple repeated combination of the elements of self. The number of combinations is (size+1)(size+2)/2.

Examples:

If size is zero, calls the block once with an empty array.

If size is negative, does not call the block:

[0, 1, 2].repeated_combination(-1) {|combination| fail 'Cannot happen' }

With no block given, returns a new Enumerator.

Related: see Methods for Combining.

static VALUE rb_ary_repeated_combination(VALUE ary, VALUE num) { long n, i, len;

n = NUM2LONG(num);                 /* Combination size from argument */
RETURN_SIZED_ENUMERATOR(ary, 1, &num, rb_ary_repeated_combination_size);   /* Return enumerator if no block */
len = RARRAY_LEN(ary);
if (n < 0) {
    /* yield nothing */
}
else if (n == 0) {
    rb_yield(rb_ary_new2(0));
}
else if (n == 1) {
    for (i = 0; i < RARRAY_LEN(ary); i++) {
        rb_yield(rb_ary_new3(1, RARRAY_AREF(ary, i)));
    }
}
else if (len == 0) {
    /* yield nothing */
}
else {
    volatile VALUE t0;
    long *p = ALLOCV_N(long, t0, n);
    VALUE ary0 = ary_make_shared_copy(ary); /* private defensive copy of ary */
    RBASIC_CLEAR_CLASS(ary0);

    rcombinate0(len, n, p, n, ary0); /* compute and yield repeated combinations */
    ALLOCV_END(t0);
    RBASIC_SET_CLASS_RAW(ary0, rb_cArray);
}
return ary;

}

repeated_permutation(size) {|permutation| ... } → self click to toggle source

repeated_permutation(size) → new_enumerator

With a block given, calls the block with each repeated permutation of length size of the elements of self; each permutation is an array; returns self. The order of the permutations is indeterminate.

If a positive integer argument size is given, calls the block with each size-tuple repeated permutation of the elements of self. The number of permutations is self.size**size.

Examples:

If size is zero, calls the block once with an empty array.

If size is negative, does not call the block:

[0, 1, 2].repeated_permutation(-1) {|permutation| fail 'Cannot happen' }

With no block given, returns a new Enumerator.

Related: see Methods for Combining.

static VALUE rb_ary_repeated_permutation(VALUE ary, VALUE num) { long r, n, i;

n = RARRAY_LEN(ary);                  /* Array length */
RETURN_SIZED_ENUMERATOR(ary, 1, &num, rb_ary_repeated_permutation_size);      /* Return Enumerator if no block */
r = NUM2LONG(num);                    /* Permutation size from argument */

if (r < 0) {
    /* no permutations: yield nothing */
}
else if (r == 0) { /* exactly one permutation: the zero-length array */
    rb_yield(rb_ary_new2(0));
}
else if (r == 1) { /* this is a special, easy case */
    for (i = 0; i < RARRAY_LEN(ary); i++) {
        rb_yield(rb_ary_new3(1, RARRAY_AREF(ary, i)));
    }
}
else {             /* this is the general case */
    volatile VALUE t0;
    long *p = ALLOCV_N(long, t0, r);
    VALUE ary0 = ary_make_shared_copy(ary); /* private defensive copy of ary */
    RBASIC_CLEAR_CLASS(ary0);

    rpermute0(n, r, p, ary0); /* compute and yield repeated permutations */
    ALLOCV_END(t0);
    RBASIC_SET_CLASS_RAW(ary0, rb_cArray);
}
return ary;

}

replace(other_array) → self

reverse → new_array click to toggle source

Returns a new array containing the elements of self in reverse order:

[0, 1, 2].reverse

Related: see Methods for Combining.

static VALUE rb_ary_reverse_m(VALUE ary) { long len = RARRAY_LEN(ary); VALUE dup = rb_ary_new2(len);

if (len > 0) {
    const VALUE *p1 = RARRAY_CONST_PTR(ary);
    VALUE *p2 = (VALUE *)RARRAY_CONST_PTR(dup) + len - 1;
    do *p2-- = *p1++; while (--len > 0);
}
ARY_SET_LEN(dup, RARRAY_LEN(ary));
return dup;

}

reverse! → self click to toggle source

Reverses the order of the elements of self; returns self:

a = [0, 1, 2] a.reverse! a

Related: see Methods for Assigning.

static VALUE rb_ary_reverse_bang(VALUE ary) { return rb_ary_reverse(ary); }

reverse_each {|element| ... } → self click to toggle source

reverse_each → Enumerator

When a block given, iterates backwards over the elements of self, passing, in reverse order, each element to the block; returns self:

a = [] [0, 1, 2].reverse_each {|element| a.push(element) } a

Allows the array to be modified during iteration:

a = ['a', 'b', 'c'] a.reverse_each {|element| a.clear if element.start_with?('b') } a

When no block given, returns a new Enumerator.

Related: see Methods for Iterating.

static VALUE rb_ary_reverse_each(VALUE ary) { long len;

RETURN_SIZED_ENUMERATOR(ary, 0, 0, ary_enum_length);
len = RARRAY_LEN(ary);
while (len--) {
    long nlen;
    rb_yield(RARRAY_AREF(ary, len));
    nlen = RARRAY_LEN(ary);
    if (nlen < len) {
        len = nlen;
    }
}
return ary;

}

rindex(object) → integer or nil click to toggle source

rindex {|element| ... } → integer or nil

rindex → new_enumerator

Returns the index of the last element for which object == element.

With argument object given, returns the index of the last such element found:

a = [:foo, 'bar', 2, 'bar'] a.rindex('bar')

Returns nil if no such object found.

With a block given, calls the block with each successive element; returns the index of the last element for which the block returns a truthy value:

a = [:foo, 'bar', 2, 'bar'] a.rindex {|element| element == 'bar' }

Returns nil if the block never returns a truthy value.

When neither an argument nor a block is given, returns a new Enumerator.

Related: see Methods for Querying.

static VALUE rb_ary_rindex(int argc, VALUE *argv, VALUE ary) { VALUE val; long i = RARRAY_LEN(ary), len;

if (argc == 0) {
    RETURN_ENUMERATOR(ary, 0, 0);
    while (i--) {
        if (RTEST(rb_yield(RARRAY_AREF(ary, i))))
            return LONG2NUM(i);
        if (i > (len = RARRAY_LEN(ary))) {
            i = len;
        }
    }
    return Qnil;
}
rb_check_arity(argc, 0, 1);
val = argv[0];
if (rb_block_given_p())
    rb_warn("given block not used");
while (i--) {
    VALUE e = RARRAY_AREF(ary, i);
    if (rb_equal(e, val)) {
        return LONG2NUM(i);
    }
    if (i > RARRAY_LEN(ary)) {
        break;
    }
}
return Qnil;

}

rotate(count = 1) → new_array click to toggle source

Returns a new array formed from self with elements rotated from one end to the other.

With non-negative numeric count, rotates elements from the beginning to the end:

[0, 1, 2, 3].rotate(2)
[0, 1, 2, 3].rotate(2.1)

If count is large, uses count % array.size as the count:

[0, 1, 2, 3].rotate(22)

With a count of zero, rotates no elements:

[0, 1, 2, 3].rotate(0)

With negative numeric count, rotates in the opposite direction, from the end to the beginning:

[0, 1, 2, 3].rotate(-1)

If count is small (far from zero), uses count % array.size as the count:

[0, 1, 2, 3].rotate(-21)

Related: see Methods for Fetching.

static VALUE rb_ary_rotate_m(int argc, VALUE *argv, VALUE ary) { VALUE rotated; const VALUE *ptr; long len; long cnt = (rb_check_arity(argc, 0, 1) ? NUM2LONG(argv[0]) : 1);

len = RARRAY_LEN(ary);
rotated = rb_ary_new2(len);
if (len > 0) {
    cnt = rotate_count(cnt, len);
    ptr = RARRAY_CONST_PTR(ary);
    len -= cnt;
    ary_memcpy(rotated, 0, len, ptr + cnt);
    ary_memcpy(rotated, len, cnt, ptr);
}
ARY_SET_LEN(rotated, RARRAY_LEN(ary));
return rotated;

}

rotate!(count = 1) → self click to toggle source

Rotates self in place by moving elements from one end to the other; returns self.

With non-negative numeric count, rotates count elements from the beginning to the end:

[0, 1, 2, 3].rotate!(2)
[0, 1, 2, 3].rotate!(2.1)

If count is large, uses count % array.size as the count:

[0, 1, 2, 3].rotate!(21)

If count is zero, rotates no elements:

[0, 1, 2, 3].rotate!(0)

With a negative numeric count, rotates in the opposite direction, from end to beginning:

[0, 1, 2, 3].rotate!(-1)

If count is small (far from zero), uses count % array.size as the count:

[0, 1, 2, 3].rotate!(-21)

Related: see Methods for Assigning.

static VALUE rb_ary_rotate_bang(int argc, VALUE *argv, VALUE ary) { long n = (rb_check_arity(argc, 0, 1) ? NUM2LONG(argv[0]) : 1); rb_ary_rotate(ary, n); return ary; }

sample(random: Random) → object click to toggle source

sample(count, random: Random) → new_ary

Returns random elements from self, as selected by the object given by the keyword argument random.

With no argument count given, returns one random element from self:

a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] a.sample a.sample

Returns nil if self is empty:

[].sample

With a non-negative numeric argument count given, returns a new array containing count random elements from self:

a.sample(3) a.sample(6)

The order of the result array is unrelated to the order of self.

Returns a new empty Array if self is empty:

[].sample(4)

May return duplicates in self:

a = [1, 1, 1, 2, 2, 3] a.sample(a.size)

Returns no more than a.size elements (because no new duplicates are introduced):

a.sample(50)

The object given with the keyword argument random is used as the random number generator:

a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] a.sample(random: Random.new(1))
a.sample(4, random: Random.new(1))

Related: see Methods for Fetching.

def sample(n = (ary = false), random: Random) if Primitive.mandatory_only?

Primitive.ary_sample0

else

Primitive.ary_sample(random, n, ary)

end end

select {|element| ... } → new_array click to toggle source

select → new_enumerator

With a block given, calls the block with each element of self; returns a new array containing those elements of self for which the block returns a truthy value:

a = [:foo, 'bar', 2, :bam] a.select {|element| element.to_s.start_with?('b') }

With no block given, returns a new Enumerator.

Related: see Methods for Fetching.

static VALUE rb_ary_select(VALUE ary) { VALUE result; long i;

RETURN_SIZED_ENUMERATOR(ary, 0, 0, ary_enum_length);
result = rb_ary_new2(RARRAY_LEN(ary));
for (i = 0; i < RARRAY_LEN(ary); i++) {
    if (RTEST(rb_yield(RARRAY_AREF(ary, i)))) {
        rb_ary_push(result, rb_ary_elt(ary, i));
    }
}
return result;

}

Also aliased as: filter, filter

select! {|element| ... } → self or nil click to toggle source

select! → new_enumerator

With a block given, calls the block with each element of self; removes from self those elements for which the block returns false or nil.

Returns self if any elements were removed:

a = [:foo, 'bar', 2, :bam] a.select! {|element| element.to_s.start_with?('b') }

Returns nil if no elements were removed.

With no block given, returns a new Enumerator.

Related: see Methods for Deleting.

static VALUE rb_ary_select_bang(VALUE ary) { struct select_bang_arg args;

RETURN_SIZED_ENUMERATOR(ary, 0, 0, ary_enum_length);
rb_ary_modify(ary);

args.ary = ary;
args.len[0] = args.len[1] = 0;
return rb_ensure(select_bang_i, (VALUE)&args, select_bang_ensure, (VALUE)&args);

}

shift → object or nil click to toggle source

shift(count) → new_array or nil

Removes and returns leading elements from self.

With no argument, removes and returns one element, if available, or nil otherwise:

a = [0, 1, 2, 3] a.shift
a
[].shift

With non-negative numeric argument count given, removes and returns the first count elements:

a = [0, 1, 2, 3] a.shift(2)
a
a.shift(1.1) a
a.shift(0)
a

If count is large, removes and returns all elements:

a = [0, 1, 2, 3] a.shift(50) a

If self is empty, returns a new empty array.

Related: see Methods for Deleting.

static VALUE rb_ary_shift_m(int argc, VALUE *argv, VALUE ary) { VALUE result; long n;

if (argc == 0) {
    return rb_ary_shift(ary);
}

rb_ary_modify_check(ary);
result = ary_take_first_or_last(argc, argv, ary, ARY_TAKE_FIRST);
n = RARRAY_LEN(result);
rb_ary_behead(ary,n);

return result;

}

shuffle(random: Random) → new_array click to toggle source

Returns a new array containing all elements from self in a random order, as selected by the object given by the keyword argument random:

a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] a.shuffle a.shuffle

Duplicate elements are included:

a = [0, 1, 0, 1, 0, 1, 0, 1, 0, 1] a.shuffle a.shuffle

The object given with the keyword argument random is used as the random number generator.

Related: see Methods for Fetching.

def shuffle(random: Random) Primitive.rb_ary_shuffle(random) end

shuffle!(random: Random) → self click to toggle source

Shuffles all elements in self into a random order, as selected by the object given by the keyword argument random. Returns self:

a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] a.shuffle! a.shuffle!

Duplicate elements are included:

a = [0, 1, 0, 1, 0, 1, 0, 1, 0, 1] a.shuffle! a.shuffle!

The object given with the keyword argument random is used as the random number generator.

Related: see Methods for Assigning.

def shuffle!(random: Random) Primitive.rb_ary_shuffle_bang(random) end

size → integer

Returns the count of elements in self:

[0, 1, 2].length [].length

Related: see Methods for Querying.

slice(index) → object or nil

slice(start, length) → object or nil

slice(range) → object or nil

slice(aseq) → object or nil

Returns elements from self; does not modify self.

In brief:

a = [:foo, 'bar', 2]

a[0]
a[-1]

a[1, 2]
a[-2, 2]

a[0..1]
a[0..-2] a[-2..2]

When a single integer argument index is given, returns the element at offset index:

a = [:foo, 'bar', 2] a[0] a[2] a

If index is negative, counts backwards from the end of self:

a = [:foo, 'bar', 2] a[-1] a[-2]

If index is out of range, returns nil.

When two Integer arguments start and length are given, returns a new Array of size length containing successive elements beginning at offset start:

a = [:foo, 'bar', 2] a[0, 2] a[1, 2]

If start + length is greater than self.length, returns all elements from offset start to the end:

a = [:foo, 'bar', 2] a[0, 4] a[1, 3] a[2, 2]

If start == self.size and length >= 0, returns a new empty Array.

If length is negative, returns nil.

When a single Range argument range is given, treats range.min as start above and range.size as length above:

a = [:foo, 'bar', 2] a[0..1] a[1..2]

Special case: If range.start == a.size, returns a new empty Array.

If range.end is negative, calculates the end index from the end:

a = [:foo, 'bar', 2] a[0..-1] a[0..-2] a[0..-3]

If range.start is negative, calculates the start index from the end:

a = [:foo, 'bar', 2] a[-1..2] a[-2..2] a[-3..2]

If range.start is larger than the array size, returns nil.

a = [:foo, 'bar', 2] a[4..1] a[4..0] a[4..-1]

When a single Enumerator::ArithmeticSequence argument aseq is given, returns an Array of elements corresponding to the indexes produced by the sequence.

a = ['--', 'data1', '--', 'data2', '--', 'data3'] a[(1..).step(2)]

Unlike slicing with range, if the start or the end of the arithmetic sequence is larger than array size, throws RangeError.

a = ['--', 'data1', '--', 'data2', '--', 'data3'] a[(1..11).step(2)]

a[(7..).step(2)]

If given a single argument, and its type is not one of the listed, tries to convert it to Integer, and raises if it is impossible:

a = [:foo, 'bar', 2]

a[:foo]

Related: see Methods for Fetching.

Alias for: []

slice!(index) → object or nil click to toggle source

slice!(start, length) → new_array or nil

slice!(range) → new_array or nil

Removes and returns elements from self.

With numeric argument index given, removes and returns the element at offset index:

a = ['a', 'b', 'c', 'd'] a.slice!(2)
a
a.slice!(2.1) a

If index is negative, counts backwards from the end of self:

a = ['a', 'b', 'c', 'd'] a.slice!(-2) a

If index is out of range, returns nil.

With numeric arguments start and length given, removes length elements from self beginning at zero-based offset start; returns the removed objects in a new array:

a = ['a', 'b', 'c', 'd'] a.slice!(1, 2)
a
a.slice!(0.1, 1.1) a

If start is negative, counts backwards from the end of self:

a = ['a', 'b', 'c', 'd'] a.slice!(-2, 1) a

If start is out-of-range, returns nil:

a = ['a', 'b', 'c', 'd'] a.slice!(5, 1)
a.slice!(-5, 1)

If start + length exceeds the array size, removes and returns all elements from offset start to the end:

a = ['a', 'b', 'c', 'd'] a.slice!(2, 50) a

If start == a.size and length is non-negative, returns a new empty array.

If length is negative, returns nil.

With Range argument range given, treats range.min as start (as above) and range.size as length (as above):

a = ['a', 'b', 'c', 'd'] a.slice!(1..2) a

If range.start == a.size, returns a new empty array:

a = ['a', 'b', 'c', 'd'] a.slice!(4..5)

If range.start is larger than the array size, returns nil:

a = ['a', 'b', 'c', 'd'] a.slice!(5..6)

If range.start is negative, calculates the start index by counting backwards from the end of self:

a = ['a', 'b', 'c', 'd'] a.slice!(-2..2)

If range.end is negative, calculates the end index by counting backwards from the end of self:

a = ['a', 'b', 'c', 'd'] a.slice!(0..-2)

Related: see Methods for Deleting.

static VALUE rb_ary_slice_bang(int argc, VALUE *argv, VALUE ary) { VALUE arg1; long pos, len;

rb_ary_modify_check(ary);
rb_check_arity(argc, 1, 2);
arg1 = argv[0];

if (argc == 2) {
    pos = NUM2LONG(argv[0]);
    len = NUM2LONG(argv[1]);
    return ary_slice_bang_by_rb_ary_splice(ary, pos, len);
}

if (!FIXNUM_P(arg1)) {
    switch (rb_range_beg_len(arg1, &pos, &len, RARRAY_LEN(ary), 0)) {
      case Qtrue:
        /* valid range */
        return ary_slice_bang_by_rb_ary_splice(ary, pos, len);
      case Qnil:
        /* invalid range */
        return Qnil;
      default:
        /* not a range */
        break;
    }
}

return rb_ary_delete_at(ary, NUM2LONG(arg1));

}

sort → new_array click to toggle source

sort {|a, b| ... } → new_array

Returns a new array containing the elements of self, sorted.

With no block given, compares elements using operator #<=> (see Object#<=>):

[0, 2, 3, 1].sort

With a block given, calls the block with each combination of pairs of elements from self; for each pair a and b, the block should return a numeric:

Example:

a = [3, 2, 0, 1] a.sort {|a, b| a <=> b } a.sort {|a, b| b <=> a }

When the block returns zero, the order for a and b is indeterminate, and may be unstable.

Related: see Methods for Fetching.

VALUE rb_ary_sort(VALUE ary) { ary = rb_ary_dup(ary); rb_ary_sort_bang(ary); return ary; }

sort! → self click to toggle source

sort! {|a, b| ... } → self

Like Array#sort, but returns self with its elements sorted in place.

Related: see Methods for Assigning.

VALUE rb_ary_sort_bang(VALUE ary) { rb_ary_modify(ary); RUBY_ASSERT(!ARY_SHARED_P(ary)); if (RARRAY_LEN(ary) > 1) { VALUE tmp = ary_make_substitution(ary); /* only ary refers tmp / struct ary_sort_data data; long len = RARRAY_LEN(ary); RBASIC_CLEAR_CLASS(tmp); data.ary = tmp; data.receiver = ary; RARRAY_PTR_USE(tmp, ptr, { ruby_qsort(ptr, len, sizeof(VALUE), rb_block_given_p()?sort_1:sort_2, &data); }); / WB: no new reference / rb_ary_modify(ary); if (ARY_EMBED_P(tmp)) { if (ARY_SHARED_P(ary)) { / ary might be destructively operated in the given block / rb_ary_unshare(ary); FL_SET_EMBED(ary); } if (ARY_EMBED_LEN(tmp) > ARY_CAPA(ary)) { ary_resize_capa(ary, ARY_EMBED_LEN(tmp)); } ary_memcpy(ary, 0, ARY_EMBED_LEN(tmp), ARY_EMBED_PTR(tmp)); ARY_SET_LEN(ary, ARY_EMBED_LEN(tmp)); } else { if (!ARY_EMBED_P(ary) && ARY_HEAP_PTR(ary) == ARY_HEAP_PTR(tmp)) { FL_UNSET_SHARED(ary); ARY_SET_CAPA(ary, RARRAY_LEN(tmp)); } else { RUBY_ASSERT(!ARY_SHARED_P(tmp)); if (ARY_EMBED_P(ary)) { FL_UNSET_EMBED(ary); } else if (ARY_SHARED_P(ary)) { / ary might be destructively operated in the given block / rb_ary_unshare(ary); } else { ary_heap_free(ary); } ARY_SET_PTR(ary, ARY_HEAP_PTR(tmp)); ARY_SET_HEAP_LEN(ary, len); ARY_SET_CAPA(ary, ARY_HEAP_LEN(tmp)); } / tmp was lost ownership for the ptr / FL_UNSET(tmp, FL_FREEZE); FL_SET_EMBED(tmp); ARY_SET_EMBED_LEN(tmp, 0); FL_SET(tmp, FL_FREEZE); } / tmp will be GC'ed. / RBASIC_SET_CLASS_RAW(tmp, rb_cArray); / rb_cArray must be marked */ } ary_verify(ary); return ary; }

sort_by! {|element| ... } → self click to toggle source

sort_by! → new_enumerator

With a block given, sorts the elements of self in place; returns self.

Calls the block with each successive element; sorts elements based on the values returned from the block:

a = ['aaaa', 'bbb', 'cc', 'd'] a.sort_by! {|element| element.size } a

For duplicate values returned by the block, the ordering is indeterminate, and may be unstable.

With no block given, returns a new Enumerator.

Related: see Methods for Assigning.

static VALUE rb_ary_sort_by_bang(VALUE ary) { VALUE sorted;

RETURN_SIZED_ENUMERATOR(ary, 0, 0, ary_enum_length);
rb_ary_modify(ary);
sorted = rb_block_call(ary, rb_intern("sort_by"), 0, 0, sort_by_i, 0);
rb_ary_replace(ary, sorted);
return ary;

}

sum(init = 0) → object click to toggle source

sum(init = 0) {|element| ... } → object

With no block given, returns the sum of init and all elements of self; for array array and value init, equivalent to:

sum = init array.each {|element| sum += element } sum

For example, [e0, e1, e2].sum returns init + e0 + e1 + e2.

Examples:

[0, 1, 2, 3].sum
[0, 1, 2, 3].sum(100)
['abc', 'def', 'ghi'].sum('jkl') [[:foo, :bar], ['foo', 'bar']].sum([2, 3])

The init value and elements need not be numeric, but must all be +-compatible:

[[:foo, :bar], ['foo', 'bar']].sum(2)

With a block given, calls the block with each element of self; the block’s return value (instead of the element itself) is used as the addend:

['zero', 1, :two].sum('Coerced and concatenated: ') {|element| element.to_s }

Notes:

static VALUE rb_ary_sum(int argc, VALUE *argv, VALUE ary) { VALUE e, v, r; long i, n; int block_given;

v = (rb_check_arity(argc, 0, 1) ? argv[0] : LONG2FIX(0));

block_given = rb_block_given_p();

if (RARRAY_LEN(ary) == 0)
    return v;

n = 0;
r = Qundef;

if (!FIXNUM_P(v) && !RB_BIGNUM_TYPE_P(v) && !RB_TYPE_P(v, T_RATIONAL)) {
    i = 0;
    goto init_is_a_value;
}

for (i = 0; i < RARRAY_LEN(ary); i++) {
    e = RARRAY_AREF(ary, i);
    if (block_given)
        e = rb_yield(e);
    if (FIXNUM_P(e)) {
        n += FIX2LONG(e); /* should not overflow long type */
        if (!FIXABLE(n)) {
            v = rb_big_plus(LONG2NUM(n), v);
            n = 0;
        }
    }
    else if (RB_BIGNUM_TYPE_P(e))
        v = rb_big_plus(e, v);
    else if (RB_TYPE_P(e, T_RATIONAL)) {
        if (UNDEF_P(r))
            r = e;
        else
            r = rb_rational_plus(r, e);
    }
    else
        goto not_exact;
}
v = finish_exact_sum(n, r, v, argc!=0);
return v;

not_exact: v = finish_exact_sum(n, r, v, i!=0);

if (RB_FLOAT_TYPE_P(e)) {
    /*
     * Kahan-Babuska balancing compensated summation algorithm
     * See https://link.springer.com/article/10.1007/s00607-005-0139-x
     */
    double f, c;
    double x, t;

    f = NUM2DBL(v);
    c = 0.0;
    goto has_float_value;
    for (; i < RARRAY_LEN(ary); i++) {
        e = RARRAY_AREF(ary, i);
        if (block_given)
            e = rb_yield(e);
        if (RB_FLOAT_TYPE_P(e))
          has_float_value:
            x = RFLOAT_VALUE(e);
        else if (FIXNUM_P(e))
            x = FIX2LONG(e);
        else if (RB_BIGNUM_TYPE_P(e))
            x = rb_big2dbl(e);
        else if (RB_TYPE_P(e, T_RATIONAL))
            x = rb_num2dbl(e);
        else
            goto not_float;

        if (isnan(f)) continue;
        if (isnan(x)) {
            f = x;
            continue;
        }
        if (isinf(x)) {
            if (isinf(f) && signbit(x) != signbit(f))
                f = NAN;
            else
                f = x;
            continue;
        }
        if (isinf(f)) continue;

        t = f + x;
        if (fabs(f) >= fabs(x))
            c += ((f - t) + x);
        else
            c += ((x - t) + f);
        f = t;
    }
    f += c;
    return DBL2NUM(f);

  not_float:
    v = DBL2NUM(f);
}

goto has_some_value;
init_is_a_value:
for (; i < RARRAY_LEN(ary); i++) {
    e = RARRAY_AREF(ary, i);
    if (block_given)
        e = rb_yield(e);
  has_some_value:
    v = rb_funcall(v, idPLUS, 1, e);
}
return v;

}

take(count) → new_array click to toggle source

Returns a new array containing the first count element of self (as available); count must be a non-negative numeric; does not modify self:

a = ['a', 'b', 'c', 'd'] a.take(2)
a.take(2.1) a.take(50)
a.take(0)

Related: see Methods for Fetching.

static VALUE rb_ary_take(VALUE obj, VALUE n) { long len = NUM2LONG(n); if (len < 0) { rb_raise(rb_eArgError, "attempt to take negative size"); } return rb_ary_subseq(obj, 0, len); }

take_while {|element| ... } → new_array click to toggle source

take_while → new_enumerator

With a block given, calls the block with each successive element of self; stops iterating if the block returns false or nil; returns a new array containing those elements for which the block returned a truthy value:

a = [0, 1, 2, 3, 4, 5] a.take_while {|element| element < 3 } a.take_while {|element| true }
a.take_while {|element| false }

With no block given, returns a new Enumerator.

Does not modify self.

Related: see Methods for Fetching.

static VALUE rb_ary_take_while(VALUE ary) { long i;

RETURN_ENUMERATOR(ary, 0, 0);
for (i = 0; i < RARRAY_LEN(ary); i++) {
    if (!RTEST(rb_yield(RARRAY_AREF(ary, i)))) break;
}
return rb_ary_take(ary, LONG2FIX(i));

}

to_a → self or new_array click to toggle source

When self is an instance of Array, returns self.

Otherwise, returns a new array containing the elements of self:

class MyArray < Array; end my_a = MyArray.new(['foo', 'bar', 'two']) a = my_a.to_a a a.class

Related: see Methods for Converting.

static VALUE rb_ary_to_a(VALUE ary) { if (rb_obj_class(ary) != rb_cArray) { VALUE dup = rb_ary_new2(RARRAY_LEN(ary)); rb_ary_replace(dup, ary); return dup; } return ary; }

to_ary → self click to toggle source

Returns self.

static VALUE rb_ary_to_ary_m(VALUE ary) { return ary; }

to_h → new_hash click to toggle source

to_h {|element| ... } → new_hash

Returns a new hash formed from self.

With no block given, each element of self must be a 2-element sub-array; forms each sub-array into a key-value pair in the new hash:

a = [['foo', 'zero'], ['bar', 'one'], ['baz', 'two']] a.to_h [].to_h

With a block given, the block must return a 2-element array; calls the block with each element of self; forms each returned array into a key-value pair in the returned hash:

a = ['foo', :bar, 1, [2, 3], {baz: 4}] a.to_h {|element| [element, element.class] }

Related: see Methods for Converting.

static VALUE rb_ary_to_h(VALUE ary) { long i; VALUE hash = rb_hash_new_with_size(RARRAY_LEN(ary)); int block_given = rb_block_given_p();

for (i=0; i<RARRAY_LEN(ary); i++) {
    const VALUE e = rb_ary_elt(ary, i);
    const VALUE elt = block_given ? rb_yield_force_blockarg(e) : e;
    const VALUE key_value_pair = rb_check_array_type(elt);
    if (NIL_P(key_value_pair)) {
        rb_raise(rb_eTypeError, "wrong element type %"PRIsVALUE" at %ld (expected array)",
                 rb_obj_class(elt), i);
    }
    if (RARRAY_LEN(key_value_pair) != 2) {
        rb_raise(rb_eArgError, "wrong array length at %ld (expected 2, was %ld)",
            i, RARRAY_LEN(key_value_pair));
    }
    rb_hash_aset(hash, RARRAY_AREF(key_value_pair, 0), RARRAY_AREF(key_value_pair, 1));
}
return hash;

}

to_s → new_string

Returns the new string formed by calling method #inspect on each array element:

a = [:foo, 'bar', 2] a.inspect

Related: see Methods for Converting.

transpose → new_array click to toggle source

Returns a new array that is self as a transposed matrix:

a = [[:a0, :a1], [:b0, :b1], [:c0, :c1]] a.transpose

The elements of self must all be the same size.

Related: see Methods for Converting.

static VALUE rb_ary_transpose(VALUE ary) { long elen = -1, alen, i, j; VALUE tmp, result = 0;

alen = RARRAY_LEN(ary);
if (alen == 0) return rb_ary_dup(ary);
for (i=0; i<alen; i++) {
    tmp = to_ary(rb_ary_elt(ary, i));
    if (elen < 0) {         /* first element */
        elen = RARRAY_LEN(tmp);
        result = rb_ary_new2(elen);
        for (j=0; j<elen; j++) {
            rb_ary_store(result, j, rb_ary_new2(alen));
        }
    }
    else if (elen != RARRAY_LEN(tmp)) {
        rb_raise(rb_eIndexError, "element size differs (%ld should be %ld)",
                 RARRAY_LEN(tmp), elen);
    }
    for (j=0; j<elen; j++) {
        rb_ary_store(rb_ary_elt(result, j), i, rb_ary_elt(tmp, j));
    }
}
return result;

}

union(*other_arrays) → new_array click to toggle source

Returns a new array that is the union of the elements of self and all given arrays other_arrays; items are compared using eql?:

[0, 1, 2, 3].union([4, 5], [6, 7])

Removes duplicates (preserving the first found):

[0, 1, 1].union([2, 1], [3, 1])

Preserves order (preserving the position of the first found):

[3, 2, 1, 0].union([5, 3], [4, 2])

With no arguments given, returns a copy of self.

Related: see Methods for Combining.

static VALUE rb_ary_union_multi(int argc, VALUE *argv, VALUE ary) { int i; long sum; VALUE hash;

sum = RARRAY_LEN(ary);
for (i = 0; i < argc; i++) {
    argv[i] = to_ary(argv[i]);
    sum += RARRAY_LEN(argv[i]);
}

if (sum <= SMALL_ARRAY_LEN) {
    VALUE ary_union = rb_ary_new();

    rb_ary_union(ary_union, ary);
    for (i = 0; i < argc; i++) rb_ary_union(ary_union, argv[i]);

    return ary_union;
}

hash = ary_make_hash(ary);
for (i = 0; i < argc; i++) rb_ary_union_hash(hash, argv[i]);

return rb_hash_values(hash);

}

uniq → new_array click to toggle source

uniq {|element| ... } → new_array

Returns a new array containing those elements from self that are not duplicates, the first occurrence always being retained.

With no block given, identifies and omits duplicate elements using method eql? to compare elements:

a = [0, 0, 1, 1, 2, 2] a.uniq

With a block given, calls the block for each element; identifies and omits “duplicate” elements using method eql? to compare block return values; that is, an element is a duplicate if its block return value is the same as that of a previous element:

a = ['a', 'aa', 'aaa', 'b', 'bb', 'bbb'] a.uniq {|element| element.size }

Related: Methods for Fetching.

static VALUE rb_ary_uniq(VALUE ary) { VALUE hash, uniq;

if (RARRAY_LEN(ary) <= 1) {
    hash = 0;
    uniq = rb_ary_dup(ary);
}
else if (rb_block_given_p()) {
    hash = ary_make_hash_by(ary);
    uniq = rb_hash_values(hash);
}
else {
    hash = ary_make_hash(ary);
    uniq = rb_hash_values(hash);
}

return uniq;

}

uniq! → self or nil click to toggle source

uniq! {|element| ... } → self or nil

Removes duplicate elements from self, the first occurrence always being retained; returns self if any elements removed, nil otherwise.

With no block given, identifies and removes elements using method eql? to compare elements:

a = [0, 0, 1, 1, 2, 2] a.uniq! a.uniq!

With a block given, calls the block for each element; identifies and omits “duplicate” elements using method eql? to compare block return values; that is, an element is a duplicate if its block return value is the same as that of a previous element:

a = ['a', 'aa', 'aaa', 'b', 'bb', 'bbb'] a.uniq! {|element| element.size } a.uniq! {|element| element.size }

Related: see Methods for Deleting.

static VALUE rb_ary_uniq_bang(VALUE ary) { VALUE hash; long hash_size;

rb_ary_modify_check(ary);
if (RARRAY_LEN(ary) <= 1)
    return Qnil;
if (rb_block_given_p())
    hash = ary_make_hash_by(ary);
else
    hash = ary_make_hash(ary);

hash_size = RHASH_SIZE(hash);
if (RARRAY_LEN(ary) == hash_size) {
    return Qnil;
}
rb_ary_modify_check(ary);
ARY_SET_LEN(ary, 0);
if (ARY_SHARED_P(ary)) {
    rb_ary_unshare(ary);
    FL_SET_EMBED(ary);
}
ary_resize_capa(ary, hash_size);
rb_hash_foreach(hash, push_value, ary);

return ary;

}

unshift(*objects) → self click to toggle source

Prepends the given objects to self:

a = [:foo, 'bar', 2] a.unshift(:bam, :bat)

Related: Array#shift; see also Methods for Assigning.

VALUE rb_ary_unshift_m(int argc, VALUE *argv, VALUE ary) { long len = RARRAY_LEN(ary); VALUE target_ary;

if (argc == 0) {
    rb_ary_modify_check(ary);
    return ary;
}

target_ary = ary_ensure_room_for_unshift(ary, argc);
ary_memcpy0(ary, 0, argc, argv, target_ary);
ARY_SET_LEN(ary, len + argc);
return ary;

}

values_at(*specifiers) → new_array click to toggle source

Returns elements from self in a new array; does not modify self.

The objects included in the returned array are the elements of self selected by the given specifiers, each of which must be a numeric index or a Range.

In brief:

a = ['a', 'b', 'c', 'd']

a.values_at(2, 0, 2, 0)
a.values_at(-4, -3, -2, -1) a.values_at(-50, 50)

a.values_at(1..3)
a.values_at(1...3)
a.values_at(3..1)

a.values_at(-3..3)
a.values_at(-50..3)

a.values_at(1..-2)
a.values_at(1..-50)

a.values_at(2..3, 3, 0..1, 0)

With no specifiers given, returns a new empty array:

a = ['a', 'b', 'c', 'd'] a.values_at

For each numeric specifier index, includes an element:

The given indexes may be in any order, and may repeat:

a.values_at(2, 0, 1, 0, 2)

For each index that is out-of-range, includes nil:

a.values_at(4, -5)

For each Range specifier range, includes elements according to range.begin and range.end:

The given ranges may be in any order and may repeat:

a.values_at(2..3, 0..1, 2..3)

The given specifiers may be any mixture of indexes and ranges:

a.values_at(3, 1..2, 0, 2..3)

Related: see Methods for Fetching.

static VALUE rb_ary_values_at(int argc, VALUE *argv, VALUE ary) { long i, olen = RARRAY_LEN(ary); VALUE result = rb_ary_new_capa(argc); for (i = 0; i < argc; ++i) { append_values_at_single(result, ary, olen, argv[i]); } RB_GC_GUARD(ary); return result; }

zip(*other_arrays) → new_array click to toggle source

zip(*other_arrays) {|sub_array| ... } → nil

With no block given, combines self with the collection of other_arrays; returns a new array of sub-arrays:

[0, 1].zip(['zero', 'one'], [:zero, :one])

Returned:

Example:

a = [0, 1] zipped = a.zip(['zero', 'one'], [:zero, :one])

zipped.size
zipped.first.size

When the other arrays are all the same size as self, the returned sub-arrays are a rearrangement containing exactly elements of all the arrays (including self), with no omissions or additions:

a = [:a0, :a1, :a2, :a3] b = [:b0, :b1, :b2, :b3] c = [:c0, :c1, :c2, :c3] d = a.zip(b, c) pp d

[[:a0, :b0, :c0], [:a1, :b1, :c1], [:a2, :b2, :c2], [:a3, :b3, :c3]]

When one of the other arrays is smaller than self, pads the corresponding sub-array with nil elements:

a = [:a0, :a1, :a2, :a3] b = [:b0, :b1, :b2] c = [:c0, :c1] d = a.zip(b, c) pp d

[[:a0, :b0, :c0], [:a1, :b1, :c1], [:a2, :b2, nil], [:a3, nil, nil]]

When one of the other arrays is larger than self, ignores its trailing elements:

a = [:a0, :a1, :a2, :a3] b = [:b0, :b1, :b2, :b3, :b4] c = [:c0, :c1, :c2, :c3, :c4, :c5] d = a.zip(b, c) pp d

[[:a0, :b0, :c0], [:a1, :b1, :c1], [:a2, :b2, :c2], [:a3, :b3, :c3]]

With a block given, calls the block with each of the other arrays; returns nil:

d = [] a = [:a0, :a1, :a2, :a3] b = [:b0, :b1, :b2, :b3] c = [:c0, :c1, :c2, :c3] a.zip(b, c) {|sub_array| d.push(sub_array.reverse) } pp d

[[:c0, :b0, :a0], [:c1, :b1, :a1], [:c2, :b2, :a2], [:c3, :b3, :a3]]

For an object in other_arrays that is not actually an array, forms the the “other array” as object.to_ary, if defined, or as object.each.to_a otherwise.

Related: see Methods for Converting.

static VALUE rb_ary_zip(int argc, VALUE *argv, VALUE ary) { int i, j; long len = RARRAY_LEN(ary); VALUE result = Qnil;

for (i=0; i<argc; i++) {
    argv[i] = take_items(argv[i], len);
}

if (rb_block_given_p()) {
    int arity = rb_block_arity();

    if (arity > 1) {
        VALUE work, *tmp;

        tmp = ALLOCV_N(VALUE, work, argc+1);

        for (i=0; i<RARRAY_LEN(ary); i++) {
            tmp[0] = RARRAY_AREF(ary, i);
            for (j=0; j<argc; j++) {
                tmp[j+1] = rb_ary_elt(argv[j], i);
            }
            rb_yield_values2(argc+1, tmp);
        }

        if (work) ALLOCV_END(work);
    }
    else {
        for (i=0; i<RARRAY_LEN(ary); i++) {
            VALUE tmp = rb_ary_new2(argc+1);

            rb_ary_push(tmp, RARRAY_AREF(ary, i));
            for (j=0; j<argc; j++) {
                rb_ary_push(tmp, rb_ary_elt(argv[j], i));
            }
            rb_yield(tmp);
        }
    }
}
else {
    result = rb_ary_new_capa(len);

    for (i=0; i<len; i++) {
        VALUE tmp = rb_ary_new_capa(argc+1);

        rb_ary_push(tmp, RARRAY_AREF(ary, i));
        for (j=0; j<argc; j++) {
            rb_ary_push(tmp, rb_ary_elt(argv[j], i));
        }
        rb_ary_push(result, tmp);
    }
}

return result;

}

self | other_array → new_array click to toggle source

Returns the union of self and other_array; duplicates are removed; order is preserved; items are compared using eql?:

[0, 1] | [2, 3] [0, 1, 1] | [2, 2, 3] [0, 1, 2] | [3, 2, 1, 0]

Related: see Methods for Combining.

static VALUE rb_ary_or(VALUE ary1, VALUE ary2) { VALUE hash;

ary2 = to_ary(ary2);
if (RARRAY_LEN(ary1) + RARRAY_LEN(ary2) <= SMALL_ARRAY_LEN) {
    VALUE ary3 = rb_ary_new();
    rb_ary_union(ary3, ary1);
    rb_ary_union(ary3, ary2);
    return ary3;
}

hash = ary_make_hash(ary1);
rb_ary_union_hash(hash, ary2);

return rb_hash_values(hash);

}