類別陣列

陣列是物件的有序、整數索引集合,稱為元素。任何物件(甚至另一個陣列)都可以是陣列元素,而陣列可以包含不同類型的物件。

陣列索引

陣列索引從 0 開始,如同 C 或 Java。

正向索引是從第一個元素的偏移量

負向索引是從陣列結尾往回的偏移量

非負數索引只有在小於陣列大小時才在範圍內。對於 3 個元素的陣列

負向索引只有在絕對值不大於陣列大小時才在範圍內。對於 3 個元素的陣列

雖然陣列的有效索引永遠是整數,但某些方法(在類別 Array 內外)接受一個或多個非整數參數,這些參數是 可轉換為整數的物件

建立陣列

您可以使用下列方式明確建立陣列物件

核心和標準函式庫中許多 Ruby 方法提供實例方法 to_a,它會將物件轉換成陣列。

範例用法

除了透過 Enumerable 模組混合的方法之外,Array 類別有專屬方法來存取、搜尋和操作陣列。

以下說明一些較常見的方法。

存取元素

可以使用 Array#[] 方法來擷取陣列中的元素。它可以接受單一整數引數(數字索引)、一對引數(開始和長度)或範圍。負索引會從結尾開始計算,-1 是最後一個元素。

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

存取特定陣列元素的另一種方法是使用 at 方法

arr.at(0) #=> 1

slice 方法的運作方式與 Array#[] 相同。

若要對陣列界限之外的索引引發錯誤,或是在發生這種情況時提供預設值,可以使用 fetch

arr = ['a', 'b', 'c', 'd', 'e', 'f']
arr.fetch(100) #=> IndexError: index 100 outside of array bounds: -6...6
arr.fetch(100, "oops") #=> "oops"

特殊方法 firstlast 分別會傳回陣列的第一個和最後一個元素。

arr.first #=> 1
arr.last  #=> 6

若要傳回陣列的前 n 個元素,請使用 take

arr.take(3) #=> [1, 2, 3]

droptake 相反,會在捨棄 n 個元素後,傳回其後的元素

arr.drop(3) #=> [4, 5, 6]

取得陣列資訊

陣列會隨時追蹤自己的長度。若要查詢陣列包含的元素數量,請使用 lengthcountsize

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

若要檢查陣列是否包含任何元素

browsers.empty? #=> false

若要檢查陣列是否包含特定項目

browsers.include?('Konqueror') #=> false

將項目新增至陣列

可以使用 push<< 將項目新增至陣列尾端

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

unshift 會將新項目新增至陣列開頭。

arr.unshift(0) #=> [0, 1, 2, 3, 4, 5, 6]

使用 insert 可以將新元素新增至陣列的任何位置。

arr.insert(3, 'apple')  #=> [0, 1, 2, 'apple', 3, 4, 5, 6]

使用 insert 方法,也可以一次新增多個值

arr.insert(3, 'orange', 'pear', 'grapefruit')
#=> [0, 1, 2, "orange", "pear", "grapefruit", "apple", 3, 4, 5, 6]

從陣列中移除項目

方法 pop 會移除陣列中的最後一個元素並傳回

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

若要同時擷取和移除第一個項目,請使用 shift

arr.shift #=> 1
arr #=> [2, 3, 4, 5]

若要刪除特定索引的元素

arr.delete_at(2) #=> 4
arr #=> [2, 3, 5]

若要刪除陣列中任何位置的特定元素,請使用 delete

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

若需要從陣列中移除 nil 值,compact 會是一個有用的方法

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

另一個常見需求是從陣列中移除重複元素。

它有非破壞性的 uniq,以及破壞性的方法 uniq!

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

迭代陣列

與所有包含 Enumerable 模組的類別一樣,Array 有 each 方法,定義應如何迭代哪些元素。在 Array 的 each 中,Array 執行個體中的所有元素都會依序傳遞給所提供的區塊。

請注意,此操作不會變更陣列。

arr = [1, 2, 3, 4, 5]
arr.each {|a| print a -= 10, " "}
# prints: -9 -8 -7 -6 -5
#=> [1, 2, 3, 4, 5]

另一個有時有用的迭代器是 reverse_each,它會以反向順序迭代陣列中的元素。

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

可以使用 map 方法根據原始陣列建立新的陣列,但值會由所提供的區塊修改

arr.map {|a| 2*a}     #=> [2, 4, 6, 8, 10]
arr                   #=> [1, 2, 3, 4, 5]
arr.map! {|a| a**2}   #=> [1, 4, 9, 16, 25]
arr                   #=> [1, 4, 9, 16, 25]

從陣列中選取項目

可以根據區塊中定義的條件從陣列中選取元素。選取可以以破壞性或非破壞性的方式進行。破壞性操作會修改呼叫它們的陣列,而非破壞性方法通常會傳回包含選取元素的新陣列,但不會變更原始陣列。

非破壞性選擇

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

破壞性選擇

select!reject!selectreject 對應的破壞性方法

類似於 selectrejectdelete_ifkeep_if 在提供相同的區塊時,會產生完全相反的結果

arr.delete_if {|a| a < 4}   #=> [4, 5, 6]
arr                         #=> [4, 5, 6]

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

這裡有什麼

首先,其他地方有什麼。類別陣列

在這裡,類別陣列提供了對下列事項有用的方法

建立陣列的方法

查詢方法

比較方法

擷取方法

這些方法不會修改 self

指定方法

這些方法會在 self 中新增、取代或重新排序元素。

刪除方法

這些方法都會從 self 中移除元素

組合方法

反覆運算方法

轉換方法

其他方法

公開類別方法

[](*args) 按一下以切換來源

傳回一個新的陣列,其中填入指定的物件。

Array.[]( 1, 'a', /^A/)  # => [1, "a", /^A/]
Array[ 1, 'a', /^A/ ]    # => [1, "a", /^A/]
[ 1, 'a', /^A/ ]         # => [1, "a", /^A/]
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 按一下以切換來源
new(array) → new_array
new(size) → new_array
new(size, default_value) → new_array
new(size) {|index| ... } → new_array

傳回一個新的陣列。

如果沒有區塊和引數,傳回一個新的空陣列物件。

如果沒有區塊和單一陣列引數 array,傳回一個由 array 形成的新陣列

a = Array.new([:foo, 'bar', 2])
a.class # => Array
a # => [:foo, "bar", 2]

如果沒有區塊和單一 Integer 引數 size,傳回一個給定大小的新陣列,其元素皆為 nil

a = Array.new(3)
a # => [nil, nil, nil]

如果沒有區塊和引數 sizedefault_value,傳回一個給定大小的陣列;每個元素都是相同的 default_value

a = Array.new(3, 'x')
a # => ['x', 'x', 'x']

如果有一個區塊和引數 size,傳回一個給定大小的陣列;區塊會呼叫每個連續整數 index;該 index 的元素是區塊的傳回值

a = Array.new(3) {|index| "Element #{index}" }
a # => ["Element 0", "Element 1", "Element 2"]

如果 size 為負數,則引發 ArgumentError

如果有一個區塊但沒有引數,或單一引數 0,則忽略區塊並傳回一個新的空陣列。

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);
        assert(ARY_EMBED_P(ary));
        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 按一下以切換來源

如果 object 是陣列物件,傳回 object

否則,如果 object 回應 :to_ary,呼叫 object.to_ary 並傳回結果。

如果 object 沒有回應 :to_ary,傳回 nil

引發例外,除非 object.to_ary 傳回陣列物件。

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

公開實例方法

array & other_array → new_array 按一下以切換來源

傳回一個新的陣列,其中包含在 array 和陣列 other_array 中找到的每個元素;省略重複的項目;使用 eql? 比較項目(項目也必須正確實作 hash

[0, 1, 2, 3] & [1, 2] # => [1, 2]
[0, 1, 0, 1] & [0, 1] # => [0, 1]

保留來自 array 的順序

[0, 1, 2] & [3, 2, 1, 0] # => [0, 1, 2]

相關:Array#intersection

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;
}
array * n → new_array 按一下以切換來源
array * string_separator → new_string

當給定非負數引數 Integer n 時,傳回一個新的陣列,透過串接 nself 產生

a = ['x', 'y']
a * 3 # => ["x", "y", "x", "y", "x", "y"]

當給定 String 引數 string_separator 時,等同於 array.join(string_separator)

[0, [0, 1], {foo: 0}] * ', ' # => "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;
}
array + other_array → new_array 按一下以切換來源

傳回一個新的陣列,包含 array 的所有元素,接著是 other_array 的所有元素

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

相關:concat

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;
}
array - other_array → new_array 按一下以切換來源

傳回一個新的陣列,只包含 array 中未在陣列 other_array 中找到的元素;使用 eql? 比較項目;保留來自 array 的順序

[0, 1, 1, 2, 1, 1, 3, 1, 1] - [1] # => [0, 2, 3]
[0, 1, 2, 3] - [3, 0] # => [1, 2]
[0, 1, 2] - [4] # => [0, 1, 2]

相關:Array#difference

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;
}
array << object → self 按一下以切換來源

object 附加到 self;傳回 self

a = [:foo, 'bar', 2]
a << :baz # => [:foo, "bar", 2, :baz]

object 附加為一個元素,即使它是另一個陣列

a = [:foo, 'bar', 2]
a1 = a << [3, 4]
a1 # => [:foo, "bar", 2, [3, 4]]
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;
}
array <=> other_array → -1、0 或 1 按一下以切換來源

傳回 -1、0 或 1,表示 self 小於、等於或大於 other_array。對於 self 中的每個索引 i,評估 result = self[i] <=> other_array[i]

如果任何結果為 -1,則傳回 -1

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

如果任何結果為 1,則傳回 1

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

當所有結果為零時

  • 如果 array 小於 other_array,則傳回 -1

    [0, 1, 2] <=> [0, 1, 2, 3] # => -1
    
  • 如果 array 大於 other_array,則傳回 1

    [0, 1, 2] <=> [0, 1] # => 1
    
  • 如果 arrayother_array 大小相同,則傳回 0

    [0, 1, 2] <=> [0, 1, 2] # => 0
    
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);
}
array == other_array → true 或 false 按一下以切換來源

如果 array.size == other_array.size,且對於 array 中的每個索引 iarray[i] == other_array[i],則傳回 true

a0 = [:foo, 'bar', 2]
a1 = [:foo, 'bar', 2.0]
a1 == a0 # => true
[] == [] # => true

否則,傳回 false

此方法與方法 Array#eql? 不同,後者使用 Object#eql? 比較元素。

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);
}
陣列[索引] → 物件或 nil 按一下以切換來源
陣列[開始,長度] → 物件或 nil
陣列[範圍] → 物件或 nil
陣列[算術序列] → 物件或 nil

self 傳回元素;不會修改 self

當提供單一 整數 參數 index 時,傳回偏移量 index 處的元素

a = [:foo, 'bar', 2]
a[0] # => :foo
a[2] # => 2
a # => [:foo, "bar", 2]

如果 index 為負數,則從 self 的尾端開始計算

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

如果 index 超出範圍,則傳回 nil

當提供兩個 整數 參數 startlength 時,傳回一個大小為 length 的新陣列,其中包含從偏移量 start 開始的連續元素

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

如果 start + length 大於 self.length,則從偏移量 start 傳回所有元素至尾端

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

如果 start == self.sizelength >= 0,則傳回一個新的空陣列。

如果 length 為負數,則傳回 nil

當提供單一 範圍 參數 range 時,將 range.min 視為上述的 start,將 range.size 視為上述的 length

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

特殊情況:如果 range.start == a.size,則傳回一個新的空陣列。

如果 range.end 為負數,則從尾端計算結束索引

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

如果 range.start 為負數,則從尾端計算開始索引

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

如果 range.start 大於陣列大小,則傳回 nil

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

當提供單一 列舉器/算術序列 參數 aseq 時,傳回一個陣列,其中包含對應於序列所產生索引的元素。

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

與範圍切片不同,如果算術序列的開始或結束大於陣列大小,則會擲回 範圍錯誤

a = ['--', 'data1', '--', 'data2', '--', 'data3']
a[(1..11).step(2)]
# RangeError (((1..11).step(2)) out of range)
a[(7..).step(2)]
# RangeError (((7..).step(2)) out of range)

如果提供單一參數,且其類型不在所列類型中,則會嘗試將其轉換為 整數,如果無法轉換,則會引發錯誤

a = [:foo, 'bar', 2]
# Raises TypeError (no implicit conversion of Symbol into Integer):
a[:foo]
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]);
}
別名為: 切片
陣列[索引] = 物件 → 物件 按一下以切換來源
陣列[開始,長度] = 物件 → 物件
陣列[範圍] = 物件 → 物件

指定 self 中的元素;傳回指定的 object

當給定 Integer 參數 index 時,將 object 指定給 self 中的元素。

如果 index 為非負數,將 object 指定給偏移量 index 處的元素

a = [:foo, 'bar', 2]
a[0] = 'foo' # => "foo"
a # => ["foo", "bar", 2]

如果 index 大於 self.length,則延伸陣列

a = [:foo, 'bar', 2]
a[7] = 'foo' # => "foo"
a # => [:foo, "bar", 2, nil, nil, nil, nil, "foo"]

如果 index 為負數,則從陣列尾端開始往回算

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

當給定 Integer 參數 startlength,且 object 不是陣列時,會移除從偏移量 start 開始的 length - 1 個元素,並在偏移量 start 處指定 object

a = [:foo, 'bar', 2]
a[0, 2] = 'foo' # => "foo"
a # => ["foo", 2]

如果 start 為負數,則從陣列尾端開始往回算

a = [:foo, 'bar', 2]
a[-2, 2] = 'foo' # => "foo"
a # => [:foo, "foo"]

如果 start 為非負數且超出陣列範圍 ( >= self.size),則以 nil 延伸陣列,在偏移量 start 處指定 object,並忽略 length

a = [:foo, 'bar', 2]
a[6, 50] = 'foo' # => "foo"
a # => [:foo, "bar", 2, nil, nil, nil, "foo"]

如果 length 為零,則移動偏移量 start 及其後的元素,並在偏移量 start 處指定 object

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

如果 length 超過現有陣列,則不會延伸陣列

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

當給定 Range 參數 range,且 object 是陣列時,會移除從偏移量 start 開始的 length - 1 個元素,並在偏移量 start 處指定 object

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

如果 range.begin 為負數,則從陣列尾端開始往回算

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

如果陣列長度小於 range.begin,則在偏移量 range.begin 處指定 object,並忽略 length

a = [:foo, 'bar', 2]
a[6..50] = 'foo' # => "foo"
a # => [:foo, "bar", 2, nil, nil, nil, "foo"]

如果 range.end 為零,則移動偏移量 start 及其後的元素,並在偏移量 start 處指定 object

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

如果 range.end 為負數,則在偏移量 start 處指定 object,保留其後的 range.end.abs -1 個元素,並移除其後的元素

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

如果 range.end 超過現有陣列,則取代陣列元素,但不會以 nil 值延伸陣列

a = [:foo, 'bar', 2]
a[1..5] = 'foo' # => "foo"
a # => [:foo, "foo"]
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]);
}
abbrev(pattern = nil) 按一下以切換來源

計算 self 中字串的明確縮寫集。

require 'abbrev'
%w{ car cone }.abbrev
#=> {"car"=>"car", "ca"=>"car", "cone"=>"cone", "con"=>"cone", "co"=>"cone"}

選用的 pattern 參數是樣式或字串。只有符合樣式或以字串開頭的輸入字串會包含在輸出雜湊中。

%w{ fast boat day }.abbrev(/^.a/)
#=> {"fast"=>"fast", "fas"=>"fast", "fa"=>"fast", "day"=>"day", "da"=>"day"}

Abbrev.abbrev(%w{car box cone}, "ca")
#=> {"car"=>"car", "ca"=>"car"}

另請參閱 Abbrev.abbrev

# File lib/abbrev.rb, line 130
def abbrev(pattern = nil)
  Abbrev::abbrev(self, pattern)
end
all? → true 或 false 按一下以切換來源
all? {|element| ... } → true 或 false
all?(obj) → true 或 false

如果 self 的所有元素都符合給定的條件,則傳回 true

如果 self 沒有元素,則傳回 true,且不會使用參數或區塊。

如果沒有給定區塊且沒有參數,則如果 self 僅包含真值元素,則傳回 true,否則傳回 false

[0, 1, :foo].all? # => true
[0, nil, 2].all? # => false
[].all? # => true

如果給定區塊且沒有參數,則使用 self 中的每個元素呼叫區塊;如果區塊僅傳回真值,則傳回 true,否則傳回 false

[0, 1, 2].all? { |element| element < 3 } # => true
[0, 1, 2].all? { |element| element < 2 } # => false

如果給定參數 obj,則如果 obj.=== 每個元素,則傳回 true,否則傳回 false

['food', 'fool', 'foot'].all?(/foo/) # => true
['food', 'drink'].all?(/bar/) # => false
[].all?(/foo/) # => true
[0, 0, 0].all?(0) # => true
[0, 1, 2].all?(1) # => false

相關:Enumerable#all?

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 或 false 按一下以切換來源
any? {|element| ... } → true 或 false
any?(obj) → true 或 false

如果 self 的任何元素都符合給定的條件,則傳回 true

如果 self 沒有元素,則傳回 false,且不會使用參數或區塊。

如果沒有給定區塊且沒有參數,則如果 self 有任何真值元素,則傳回 true,否則傳回 false

[nil, 0, false].any? # => true
[nil, false].any? # => false
[].any? # => false

如果給定區塊且沒有參數,則使用 self 中的每個元素呼叫區塊;如果區塊傳回任何真值,則傳回 true,否則傳回 false

[0, 1, 2].any? {|element| element > 1 } # => true
[0, 1, 2].any? {|element| element > 2 } # => false

如果給定參數 obj,則如果 obj.=== 任何元素,則傳回 true,否則傳回 false

['food', 'drink'].any?(/foo/) # => true
['food', 'drink'].any?(/bar/) # => false
[].any?(/foo/) # => false
[0, 1, 2].any?(1) # => true
[0, 1, 2].any?(3) # => false

相關:Enumerable#any?

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
別名:push
assoc(obj) → 找到的陣列或 nil 按一下以切換來源

傳回 self 中第一個元素,該元素是一個陣列,其第一個元素 == obj

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

如果找不到此類元素,則傳回 nil

相關:rassoc

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) → 物件 按一下以切換來源

傳回 Integer 偏移量 index 的元素;不修改 self

a = [:foo, 'bar', 2]
a.at(0) # => :foo
a.at(2) # => 2
VALUE
rb_ary_at(VALUE ary, VALUE pos)
{
    return rb_ary_entry(ary, NUM2LONG(pos));
}
bsearch {|element| ... } → object 按一下以切換來源
bsearch → new_enumerator

傳回由二元搜尋從 self 中選取的元素。

請參閱 二元搜尋

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 按一下以切換來源
bsearch_index → new_enumerator

在方法 bsearch 中所述的 self 中搜尋,但傳回找到元素的索引,而非元素本身。

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 按一下以切換來源

self 中移除所有元素

a = [:foo, 'bar', 2]
a.clear # => []
VALUE
rb_ary_clear(VALUE ary)
{
    rb_ary_modify_check(ary);
    if (ARY_SHARED_P(ary)) {
        if (!ARY_EMBED_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
別名為:map
collect!
別名為:map!
combination(n) {|element| ... } → self 按一下以切換來源
combination(n) → new_enumerator

呼叫區塊(如果提供),並提供 self 元素的組合;傳回 self。組合的順序是不確定的。

當給定區塊和範圍內的正數 Integer 參數 n0 < n <= self.size)時,呼叫區塊並提供 self 的所有 n 元組組合。

範例

a = [0, 1, 2]
a.combination(2) {|combination| p combination }

輸出

[0, 1]
[0, 2]
[1, 2]

另一個範例

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

輸出

[0, 1, 2]

n 為零時,呼叫區塊一次,並提供一個新的空陣列

a = [0, 1, 2]
a1 = a.combination(0) {|combination| p combination }

輸出

[]

n 超出範圍(為負數或大於 self.size)時,不呼叫區塊

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

如果未提供區塊,則傳回新的 Enumerator

a = [0, 1, 2]
a.combination(2) # => #<Enumerator: [0, 1, 2]:combination(2)>
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 按一下以切換來源

傳回一個新的陣列,其中包含 self 中的所有非 nil 元素

a = [nil, 0, nil, 1, nil, 2, nil]
a.compact # => [0, 1, 2]
static VALUE
rb_ary_compact(VALUE ary)
{
    ary = rb_ary_dup(ary);
    rb_ary_compact_bang(ary);
    return ary;
}
compact! → self or nil 按一下以切換來源

self 中移除所有 nil 元素。

如果移除任何元素,則傳回 self;否則傳回 nil

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 按一下以切換來源

other_arrays 中每個陣列的所有元素新增至 array;傳回 self

a = [0, 1]
a.concat([2, 3], [4, 5]) # => [0, 1, 2, 3, 4, 5]
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 → an_integer 按一下以切換來源
count(obj) → 整數
count {|元素| ... } → 整數

傳回指定元素的計數。

若無參數且無區塊,傳回所有元素的計數

[0, 1, 2].count # => 3
[].count # => 0

若有參數 obj,傳回元素 == obj 的計數

[0, 1, 2, 0.0].count(0) # => 2
[0, 1, 2].count(3) # => 0

若無參數且有區塊,對每個元素呼叫區塊;傳回區塊傳回真值元素的計數

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

若有參數 obj 且有區塊,會發出警告,忽略區塊,並傳回元素 == obj 的計數。

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 {|元素| ... } → nil 按一下以切換來源
cycle(計數) {|元素| ... } → nil
cycle → 新列舉器
cycle(計數) → 新列舉器

若呼叫時有正整數 整數 參數 計數 和區塊,會對每個元素呼叫區塊,然後再做一次,直到做完 計數 次;傳回 nil

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

計數 為零或負數,不會呼叫區塊

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

若有區塊,且參數省略或為 nil,會永遠循環

# Prints 0 and 1 forever.
[0, 1].cycle {|element| puts element }
[0, 1].cycle(nil) {|element| puts element }

若沒有區塊,會傳回新的列舉器

[0, 1].cycle(2) # => #<Enumerator: [0, 1]:cycle(2)>
[0, 1].cycle # => # => #<Enumerator: [0, 1]:cycle>
[0, 1].cycle.first(5) # => [0, 1, 0, 1, 0]
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(obj) → 已刪除物件 按一下以切換來源
delete(obj) {|不存在| ... } → 已刪除物件或區塊傳回值

self 中移除零個或多個元素。

若沒有區塊,會從 self 中移除每個元素 ele,其符合 ele == obj;傳回最後一個已刪除元素

s1 = 'bar'; s2 = 'bar'
a = [:foo, s1, 2, s2]
a.delete('bar') # => "bar"
a # => [:foo, 2]

若沒有移除任何元素,會傳回 nil

若有區塊,會從 self 中移除每個元素 ele,其符合 ele == obj

若找到任何此類元素,會忽略區塊並傳回最後一個已刪除元素

s1 = 'bar'; s2 = 'bar'
a = [:foo, s1, 2, s2]
deleted_obj = a.delete('bar') {|obj| fail 'Cannot happen' }
a # => [:foo, 2]

若找不到任何此類元素,會傳回區塊的傳回值

a = [:foo, 'bar', 2]
a.delete(:nosuch) {|obj| "#{obj} not found" } # => "nosuch not found"
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(索引) → 已刪除物件或 nil 按一下以切換來源

根據給定的 整數 索引,從 self 中刪除一個元素。

索引 為非負數,會刪除偏移量為 索引 的元素

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

若索引太大,會傳回 nil

索引 為負數,會從陣列的尾端開始往回算

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

索引 太小(離零太遠),會傳回 nil。

static VALUE
rb_ary_delete_at_m(VALUE ary, VALUE pos)
{
    return rb_ary_delete_at(ary, NUM2LONG(pos));
}
delete_if {|元素| ... } → self 按一下以切換來源
delete_if → 列舉器

移除 self 中每個區塊傳回真值元素;傳回 self

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

如果未提供區塊,則傳回新的 Enumerator

a = [:foo, 'bar', 2]
a.delete_if # => #<Enumerator: [:foo, "bar", 2]:delete_if>
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(*其他陣列) → 新陣列 按一下以切換來源

傳回一個新的陣列,其中只包含 self 中未在任何陣列 其他陣列 中找到的元素;會使用 eql? 比較項目;會保留 self 中的順序

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

若沒有給定參數,會傳回 self 的副本。

相關:Array#-

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(索引, *識別碼) → 物件 按一下以切換來源

尋找並傳回在嵌套物件中由 indexidentifiers 指定的物件。嵌套物件可能是各種類別的實例。請參閱 挖掘方法

範例

a = [:foo, [:bar, :baz, [:bat, :bam]]]
a.dig(1) # => [:bar, :baz, [:bat, :bam]]
a.dig(1, 2) # => [:bat, :bam]
a.dig(1, 2, 0) # => :bat
a.dig(1, 2, 3) # => nil
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(n) → new_array 按一下以切換來源

傳回一個新的陣列,其中包含 self 的所有元素,但第一個 n 個元素除外,其中 n 是非負整數 Integer;不會修改 self

範例

a = [0, 1, 2, 3, 4, 5]
a.drop(0) # => [0, 1, 2, 3, 4, 5]
a.drop(1) # => [1, 2, 3, 4, 5]
a.drop(2) # => [2, 3, 4, 5]
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 按一下以切換來源
drop_while → new_enumerator

傳回一個新的陣列,其中包含 self 的零個或多個尾端元素;不會修改 self

如果給定一個區塊,則會呼叫區塊並傳入 self 的每個後續元素;如果區塊傳回 falsenil,則停止;傳回一個新的陣列,省略區塊傳回真值元素。

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

如果未給定區塊,則傳回一個新的列舉器。

[0, 1].drop_while # => # => #<Enumerator: [0, 1]:drop_while>
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 按一下以切換來源
each → Enumerator

反覆處理陣列元素。

如果給定一個區塊,則會將每個後續陣列元素傳遞給區塊;傳回 self

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

輸出

Symbol foo
String bar
Integer 2

允許在反覆處理期間修改陣列。

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

輸出

foo
bar

如果未給定區塊,則傳回一個新的列舉器。

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

e = a.each
e # => #<Enumerator: [:foo, "bar", 2]:each>
a1 = e.each {|element|  puts "#{element.class} #{element}" }

輸出

Symbol foo
String bar
Integer 2

相關:each_indexreverse_each

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 按一下以切換來源
each_index → Enumerator

反覆處理陣列索引。

如果給定一個區塊,則會將每個後續陣列索引傳遞給區塊;傳回 self

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

輸出

0 foo
1 bar
2 2

允許在反覆處理期間修改陣列。

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

輸出

0
1

如果未給定區塊,則傳回一個新的列舉器。

a = [:foo, 'bar', 2]
e = a.each_index
e # => #<Enumerator: [:foo, "bar", 2]:each_index>
a1 = e.each {|index|  puts "#{index} #{a[index]}"}

輸出

0 foo
1 bar
2 2

相關:eachreverse_each

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 或 false 按一下以切換來源

如果 self 中的元素計數為零,則傳回 true,否則傳回 false

static VALUE
rb_ary_empty_p(VALUE ary)
{
    return RBOOL(RARRAY_LEN(ary) == 0);
}
eql? other_array → true 或 false 按一下以切換來源

如果 selfother_array 大小相同,並且對於 self 中的每個索引 iself[i].eql? other_array[i],則傳回 true

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

否則,傳回 false

此方法與方法 Array#== 不同,後者使用 Object#== 方法進行比較。

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 按一下以切換來源
fetch(index, default_value) → element
fetch(index) {|index| ... } → element

傳回偏移量 index 處的元素。

使用單一 Integer 參數 index,傳回偏移量 index 處的元素

a = [:foo, 'bar', 2]
a.fetch(1) # => "bar"

如果 index 為負數,則從陣列末端開始計算

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

使用參數 indexdefault_value,如果 index 在範圍內,則傳回偏移量 index 處的元素,否則傳回 default_value

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

使用參數 index 和區塊,如果 index 在範圍內,則傳回偏移量 index 處的元素(且不會呼叫區塊);否則,使用 index 呼叫區塊,並傳回其傳回值

a = [:foo, 'bar', 2]
a.fetch(1) {|index| raise 'Cannot happen' } # => "bar"
a.fetch(50) {|index| "Value for #{index}" } # => "Value for 50"
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);
}
fill(obj) → self 按一下以切換來源
fill(obj, start) → self
fill(obj, start, length) → self
fill(obj, range) → self
fill {|index| ... } → self
fill(start) {|index| ... } → self
fill(start, length) {|index| ... } → self
fill(range) {|index| ... } → self

使用指定的物件取代 self 中指定的元素;傳回 self

使用參數 obj 且未提供區塊,則使用該物件取代所有元素

a = ['a', 'b', 'c', 'd']
a # => ["a", "b", "c", "d"]
a.fill(:X) # => [:X, :X, :X, :X]

使用參數 objInteger start,且未提供區塊,則根據提供的 start 取代元素。

如果 start 在範圍內(0 <= start < array.size),則從偏移量 start 到最後取代所有元素

a = ['a', 'b', 'c', 'd']
a.fill(:X, 2) # => ["a", "b", :X, :X]

如果 start 太大(start >= array.size),則不執行任何動作

a = ['a', 'b', 'c', 'd']
a.fill(:X, 4) # => ["a", "b", "c", "d"]
a = ['a', 'b', 'c', 'd']
a.fill(:X, 5) # => ["a", "b", "c", "d"]

如果 start 為負數,則從末端開始計算(起始索引為 start + array.size

a = ['a', 'b', 'c', 'd']
a.fill(:X, -2) # => ["a", "b", :X, :X]

如果 start 太小(小於且遠低於零),則取代所有元素

a = ['a', 'b', 'c', 'd']
a.fill(:X, -6) # => [:X, :X, :X, :X]
a = ['a', 'b', 'c', 'd']
a.fill(:X, -50) # => [:X, :X, :X, :X]

使用參數 objInteger startInteger length,且未提供區塊,則根據提供的 startlength 取代元素。

如果 start 在範圍內,則從偏移量 start 開始取代 length 個元素

a = ['a', 'b', 'c', 'd']
a.fill(:X, 1, 1) # => ["a", :X, "c", "d"]

如果 start 為負數,則從末端開始計算

a = ['a', 'b', 'c', 'd']
a.fill(:X, -2, 1) # => ["a", "b", :X, "d"]

如果 start 太大(start >= array.size),則使用 nil 延伸 self

a = ['a', 'b', 'c', 'd']
a.fill(:X, 5, 0) # => ["a", "b", "c", "d", nil]
a = ['a', 'b', 'c', 'd']
a.fill(:X, 5, 2) # => ["a", "b", "c", "d", nil, :X, :X]

如果 length 為零或負數,則不取代任何元素

a = ['a', 'b', 'c', 'd']
a.fill(:X, 1, 0) # => ["a", "b", "c", "d"]
a.fill(:X, 1, -1) # => ["a", "b", "c", "d"]

使用參數 objRange range,且未提供區塊,則根據提供的範圍取代元素。

如果範圍為正數且遞增(0 < range.begin <= range.end),則從 range.beginrange.end 取代元素

a = ['a', 'b', 'c', 'd']
a.fill(:X, (1..1)) # => ["a", :X, "c", "d"]

如果 range.first 為負數,則不取代任何元素

a = ['a', 'b', 'c', 'd']
a.fill(:X, (-1..1)) # => ["a", "b", "c", "d"]

如果 range.last 為負值,則從尾端開始計算

a = ['a', 'b', 'c', 'd']
a.fill(:X, (0..-2)) # => [:X, :X, :X, "d"]
a = ['a', 'b', 'c', 'd']
a.fill(:X, (1..-2)) # => ["a", :X, :X, "d"]

如果 range.lastrange.last 皆為負值,則從陣列的尾端開始計算

a = ['a', 'b', 'c', 'd']
a.fill(:X, (-1..-1)) # => ["a", "b", "c", :X]
a = ['a', 'b', 'c', 'd']
a.fill(:X, (-2..-2)) # => ["a", "b", :X, "d"]

如果沒有參數且有提供區塊,則呼叫區塊並傳入每個索引;並以區塊的回傳值取代對應的元素

a = ['a', 'b', 'c', 'd']
a.fill { |index| "new_#{index}" } # => ["new_0", "new_1", "new_2", "new_3"]

如果提供參數 start 且有提供區塊,則呼叫區塊並傳入從偏移量 start 到尾端的每個索引;並以區塊的回傳值取代對應的元素。

如果 start 在範圍內 (0 <= start < array.size),則從偏移量 start 到尾端進行取代

a = ['a', 'b', 'c', 'd']
a.fill(1) { |index| "new_#{index}" } # => ["a", "new_1", "new_2", "new_3"]

如果 start 太大(start >= array.size),則不執行任何動作

a = ['a', 'b', 'c', 'd']
a.fill(4) { |index| fail 'Cannot happen' } # => ["a", "b", "c", "d"]
a = ['a', 'b', 'c', 'd']
a.fill(4) { |index| fail 'Cannot happen' } # => ["a", "b", "c", "d"]

如果 start 為負數,則從末端開始計算

a = ['a', 'b', 'c', 'd']
a.fill(-2) { |index| "new_#{index}" } # => ["a", "b", "new_2", "new_3"]

如果 start 太小 (start <= -array.size,則取代所有元素

a = ['a', 'b', 'c', 'd']
a.fill(-6) { |index| "new_#{index}" } # => ["new_0", "new_1", "new_2", "new_3"]
a = ['a', 'b', 'c', 'd']
a.fill(-50) { |index| "new_#{index}" } # => ["new_0", "new_1", "new_2", "new_3"]

如果提供參數 startlength,且有提供區塊,則呼叫區塊並傳入由 start length 指定的每個索引;並以區塊的回傳值取代對應的元素。

如果 start 在範圍內,則從偏移量 start 開始取代 length 個元素

a = ['a', 'b', 'c', 'd']
a.fill(1, 1) { |index| "new_#{index}" } # => ["a", "new_1", "c", "d"]

如果 start 為負值,則從尾端開始計算

a = ['a', 'b', 'c', 'd']
a.fill(-2, 1) { |index| "new_#{index}" } # => ["a", "b", "new_2", "d"]

如果 start 太大(start >= array.size),則使用 nil 延伸 self

a = ['a', 'b', 'c', 'd']
a.fill(5, 0) { |index| "new_#{index}" } # => ["a", "b", "c", "d", nil]
a = ['a', 'b', 'c', 'd']
a.fill(5, 2) { |index| "new_#{index}" } # => ["a", "b", "c", "d", nil, "new_5", "new_6"]

如果 length 為零或負值,則不取代任何元素

a = ['a', 'b', 'c', 'd']
a.fill(1, 0) { |index| "new_#{index}" } # => ["a", "b", "c", "d"]
a.fill(1, -1) { |index| "new_#{index}" } # => ["a", "b", "c", "d"]

如果提供參數 objrange,且有提供區塊,則呼叫區塊並傳入指定範圍內的每個索引;並以區塊的回傳值取代對應的元素。

如果範圍為正值且遞增 (range 0 < range.begin <= range.end,則取代從 range.beginrange.end 的元素

a = ['a', 'b', 'c', 'd']
a.fill(1..1) { |index| "new_#{index}" } # => ["a", "new_1", "c", "d"]

如果 range.first 為負值,則不執行任何動作

a = ['a', 'b', 'c', 'd']
a.fill(-1..1) { |index| fail 'Cannot happen' } # => ["a", "b", "c", "d"]

如果 range.last 為負值,則從尾端開始計算

a = ['a', 'b', 'c', 'd']
a.fill(0..-2) { |index| "new_#{index}" } # => ["new_0", "new_1", "new_2", "d"]
a = ['a', 'b', 'c', 'd']
a.fill(1..-2) { |index| "new_#{index}" } # => ["a", "new_1", "new_2", "d"]

如果 range.firstrange.last 皆為負值,則從尾端開始計算

a = ['a', 'b', 'c', 'd']
a.fill(-1..-1) { |index| "new_#{index}" } # => ["a", "b", "c", "new_3"]
a = ['a', 'b', 'c', 'd']
a.fill(-2..-2) { |index| "new_#{index}" } # => ["a", "b", "new_2", "d"]
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
別名:select
filter!
別名:select!
find_index
別名:index
first → object or nil 按一下以切換來源
first(n) → new_array

self 傳回元素;不會修改 self

如果沒有提供參數,則回傳第一個元素

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

如果 self 為空,則回傳 nil

如果提供非負 Integer 參數 n,則回傳一個新陣列中的前 n 個元素

a = [:foo, 'bar', 2]
a.first(2) # => [:foo, "bar"]

如果 n >= array.size,則回傳所有元素

a = [:foo, 'bar', 2]
a.first(50) # => [:foo, "bar", 2]

如果 n == 0,則回傳一個新的空陣列

a = [:foo, 'bar', 2]
a.first(0) # []

相關:last

# File array.rb, line 101
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 → new_array 按一下以切換來源
flatten(level) → new_array

回傳一個新的陣列,為 self 的遞迴扁平化

  • 每個非陣列元素不變。

  • 每個陣列會被其個別元素取代。

如果提供非負 Integer 參數 level,則遞迴扁平化到 level 層級

a = [ 0, [ 1, [2, 3], 4 ], 5 ]
a.flatten(0) # => [0, [1, [2, 3], 4], 5]
a = [ 0, [ 1, [2, 3], 4 ], 5 ]
a.flatten(1) # => [0, 1, [2, 3], 4, 5]
a = [ 0, [ 1, [2, 3], 4 ], 5 ]
a.flatten(2) # => [0, 1, 2, 3, 4, 5]
a = [ 0, [ 1, [2, 3], 4 ], 5 ]
a.flatten(3) # => [0, 1, 2, 3, 4, 5]

如果沒有提供參數、提供 nil 參數,或提供負參數 level,則扁平化所有層級

a = [ 0, [ 1, [2, 3], 4 ], 5 ]
a.flatten # => [0, 1, 2, 3, 4, 5]
[0, 1, 2].flatten # => [0, 1, 2]
a = [ 0, [ 1, [2, 3], 4 ], 5 ]
a.flatten(-1) # => [0, 1, 2, 3, 4, 5]
a = [ 0, [ 1, [2, 3], 4 ], 5 ]
a.flatten(-2) # => [0, 1, 2, 3, 4, 5]
[0, 1, 2].flatten(-1) # => [0, 1, 2]
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! → self or nil 按一下以切換來源
flatten!(level) → self or nil

self 中每個巢狀陣列的元素取代該陣列;如果進行任何變更,則回傳 self,否則回傳 nil

如果提供非負 Integer 參數 level,則遞迴扁平化到 level 層級

a = [ 0, [ 1, [2, 3], 4 ], 5 ]
a.flatten!(1) # => [0, 1, [2, 3], 4, 5]
a = [ 0, [ 1, [2, 3], 4 ], 5 ]
a.flatten!(2) # => [0, 1, 2, 3, 4, 5]
a = [ 0, [ 1, [2, 3], 4 ], 5 ]
a.flatten!(3) # => [0, 1, 2, 3, 4, 5]
[0, 1, 2].flatten!(1) # => nil

如果沒有提供參數、提供 nil 參數,或提供負參數 level,則扁平化所有層級

a = [ 0, [ 1, [2, 3], 4 ], 5 ]
a.flatten! # => [0, 1, 2, 3, 4, 5]
[0, 1, 2].flatten! # => nil
a = [ 0, [ 1, [2, 3], 4 ], 5 ]
a.flatten!(-1) # => [0, 1, 2, 3, 4, 5]
a = [ 0, [ 1, [2, 3], 4 ], 5 ]
a.flatten!(-2) # => [0, 1, 2, 3, 4, 5]
[0, 1, 2].flatten!(-1) # => nil
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_obj_freeze(result);
    rb_ary_replace(ary, result);
    if (mod) ARY_SET_EMBED_LEN(result, 0);

    return ary;
}
hash → 整數 按一下以切換原始碼

傳回 self 的整數 hash 值。

具有相同內容的兩個陣列將具有相同的 hash 碼(且會使用 eql? 進行比較)

[0, 1, 2].hash == [0, 1, 2].hash # => true
[0, 1, 2].hash == [0, 1, 3].hash # => false
static VALUE
rb_ary_hash(VALUE ary)
{
    return rb_ary_hash_values(RARRAY_LEN(ary), RARRAY_CONST_PTR(ary));
}
include?(obj) → true 或 false 按一下以切換原始碼

如果 self 中的某個索引 i 符合 obj == self[i],則傳回 true;否則傳回 false

[0, 1, 2].include?(2) # => true
[0, 1, 2].include?(3) # => false
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) → 整數或 nil
index {|element| ... } → 整數或 nil
index → new_enumerator

傳回指定元素的索引。

當給定參數 object 但沒有區塊時,傳回第一個符合 object == element 元素的索引

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

如果找不到此類元素,則傳回 nil

當給定參數 object 和區塊時,呼叫區塊並傳入每個連續元素;傳回區塊傳回真值的第一個元素的索引

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

如果區塊從未傳回真值,則傳回 nil

當沒有給定參數或區塊時,傳回新的 Enumerator

a = [:foo, 'bar', 2]
e = a.index
e # => #<Enumerator: [:foo, "bar", 2]:index>
e.each {|element| element == 'bar' } # => 1

相關:rindex

別名:find_index
initialize_copy
別名:replace
insert(index, *objects) → self 按一下以切換原始碼

Integer 索引 offset 處的元素之前或之後插入給定的 objects;傳回 self

index 為非負數時,在偏移量 index 處的元素之前插入所有給定的 objects

a = [:foo, 'bar', 2]
a.insert(1, :bat, :bam) # => [:foo, :bat, :bam, "bar", 2]

如果 index 超出陣列範圍(index >= self.size),則延伸陣列

a = [:foo, 'bar', 2]
a.insert(5, :bat, :bam)
a # => [:foo, "bar", 2, nil, nil, :bat, :bam]

如果沒有給定物件,則不執行任何動作

a = [:foo, 'bar', 2]
a.insert(1)
a.insert(50)
a.insert(-50)
a # => [:foo, "bar", 2]

index 為負數時,在偏移量 index+self.size 處的元素之後插入所有給定的 objects

a = [:foo, 'bar', 2]
a.insert(-2, :bat, :bam)
a # => [:foo, "bar", :bat, :bam, 2]
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 按一下以切換原始碼

呼叫每個陣列元素的 #inspect 方法後,傳回形成的新 String

a = [:foo, 'bar', 2]
a.inspect # => "[:foo, \"bar\", 2]"
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);
}
別名:to_s
intersect?(other_ary) → true 或 false 按一下以切換原始碼

如果陣列和 other_ary 至少有一個共同元素,則傳回 true;否則傳回 false

a = [ 1, 2, 3 ]
b = [ 3, 4, 5 ]
c = [ 5, 6, 7 ]
a.intersect?(b)   #=> true
a.intersect?(c)   #=> false

Array 元素使用 eql? 進行比較(項目也必須正確實作 hash)。

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 按一下以切換原始碼

傳回一個新的陣列,其中包含在 self 和所有給定的陣列 other_arrays 中找到的每個元素;重複的元素會被省略;項目使用 eql? 進行比較(項目還必須正確實作 hash

[0, 1, 2, 3].intersection([0, 1, 2], [0, 1, 3]) # => [0, 1]
[0, 0, 1, 1, 2, 3].intersection([0, 1, 2], [0, 1, 3]) # => [0, 1]

保留來自 self 的順序

[0, 1, 2].intersection([2, 1, 0]) # => [0, 1, 2]

若沒有給定參數,會傳回 self 的副本。

相關:Array#&

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 →new_string 按一下以切換來源
join(separator = $,) → new_string

傳回在轉換後,由陣列元素結合而成的新的 字串。對於每個元素 element

  • 如果 element 不是 kind_of?(Array),則使用 element.to_s

  • 如果 elementkind_of?(Array),則使用遞迴的 element.join(separator)

如果沒有引數,則使用輸出欄位分隔符號 $, 進行結合

a = [:foo, 'bar', 2]
$, # => nil
a.join # => "foobar2"

如果使用字串引數 separator,則使用該分隔符號進行結合

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

對於巢狀陣列,遞迴地進行結合

a = [:foo, [:bar, [:baz, :bat]]]
a.join # => "foobarbazbat"
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 按一下以切換來源
keep_if → new_enumeration

保留區塊傳回真值的那些元素;刪除所有其他元素;傳回 self

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

如果未提供區塊,則傳回新的 Enumerator

a = [:foo, 'bar', 2, :bam]
a.keep_if # => #<Enumerator: [:foo, "bar", 2, :bam]:keep_if>
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 → object or nil 按一下以切換來源
last(n) → new_array

傳回來自 self 的元素;self 沒有被修改。

如果沒有給定引數,則傳回最後一個元素

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

如果 self 為空,則回傳 nil

如果給定非負的 整數 引數 n,則傳回一個新的陣列中最後 n 個元素

a = [:foo, 'bar', 2]
a.last(2) # => ["bar", 2]

如果 n >= array.size,則回傳所有元素

a = [:foo, 'bar', 2]
a.last(50) # => [:foo, "bar", 2]

如果 n == 0,則傳回一個新的空陣列

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

相關:first

# File array.rb, line 145
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 → an_integer 按一下以切換來源

傳回 self 中的元素數量。

static VALUE
rb_ary_length(VALUE ary)
{
    long len = RARRAY_LEN(ary);
    return LONG2NUM(len);
}
別名為:size
map {|element| ... } → new_array
map → new_enumerator

如果給定,則使用 self 的每個元素呼叫區塊;傳回一個新的陣列,其元素是區塊的傳回值

a = [:foo, 'bar', 2]
a1 = a.map {|element| element.class }
a1 # => [Symbol, String, Integer]

如果未提供區塊,則傳回新的 Enumerator

a = [:foo, 'bar', 2]
a1 = a.map
a1 # => #<Enumerator: [:foo, "bar", 2]:map>
別名為:collect
map! {|element| ... } → self
map! → new_enumerator

如果給定,呼叫區塊,並使用每個元素;用區塊的回傳值取代元素

a = [:foo, 'bar', 2]
a.map! { |element| element.class } # => [Symbol, String, Integer]

如果未提供區塊,則傳回新的 Enumerator

a = [:foo, 'bar', 2]
a1 = a.map!
a1 # => #<Enumerator: [:foo, "bar", 2]:map!>
別名為:collect!
max → element 按一下以切換來源
max {|a, b| ... } → element
max(n) → new_array
max(n) {|a, b| ... } → new_array

傳回下列其中一項

  • self 中最大值的元素。

  • self 選取的最大值元素的新陣列。

如果未給定區塊,self 中的每個元素都必須使用 Integer 方法 <=> 回應。

如果沒有引數和區塊,傳回 self 中使用 <=> 方法具有最大值的元素

[0, 1, 2].max # => 2

如果有一個引數 Integer n 且沒有區塊,傳回一個新陣列,其中最多有 n 個元素,依照 <=> 方法遞減排列

[0, 1, 2, 3].max(3) # => [3, 2, 1]
[0, 1, 2, 3].max(6) # => [3, 2, 1, 0]

如果給定區塊,區塊必須傳回 Integer

如果有一個區塊且沒有引數,呼叫區塊 self.size-1 次以比較元素;傳回使用區塊具有最大值的元素

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

如果有一個引數 n 和一個區塊,傳回一個新陣列,其中最多有 n 個元素,依照區塊遞減排列

['0', '00', '000'].max(2) {|a, b| a.size <=> b.size } # => ["000", "00"]
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 按一下以切換來源
min { |a, b| ... } → element
min(n) → new_array
min(n) { |a, b| ... } → new_array

傳回下列其中一項

  • self 中最小值的元素。

  • self 選取的最小值元素的新陣列。

如果未給定區塊,self 中的每個元素都必須使用 Integer 方法 <=> 回應。

如果沒有引數和區塊,傳回 self 中使用 <=> 方法具有最小值的元素

[0, 1, 2].min # => 0

如果有一個 Integer 引數 n 且沒有區塊,傳回一個新陣列,其中最多有 n 個元素,依照 <=> 方法遞增排列

[0, 1, 2, 3].min(3) # => [0, 1, 2]
[0, 1, 2, 3].min(6) # => [0, 1, 2, 3]

如果給定區塊,區塊必須傳回 Integer

如果有一個區塊且沒有引數,呼叫區塊 self.size-1 次以比較元素;傳回使用區塊具有最小值的元素

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

如果有一個引數 n 和一個區塊,傳回一個新陣列,其中最多有 n 個元素,依照區塊遞增排列

['0', '00', '000'].min(2) {|a, b| a.size <=> b.size } # => ["0", "00"]
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 → [min_val, max_val] 按一下以切換來源
minmax {|a, b| ... } → [min_val, max_val]

傳回一個新的 2 元素陣列,其中包含來自 self 的最小值和最大值,每個方法 <=> 或每個指定區塊:.

當未指定區塊時,self 中的每個元素都必須回應方法 <=>,並傳回 Integer;傳回一個新的 2 元素陣列,其中包含來自 self 的最小值和最大值,每個方法 <=>

[0, 1, 2].minmax # => [0, 2]

當指定區塊時,區塊必須傳回 Integer;呼叫區塊 self.size-1 次以比較元素;傳回一個新的 2 元素陣列,其中包含來自 self 的最小值和最大值,每個區塊

['0', '00', '000'].minmax {|a, b| a.size <=> b.size } # => ["0", "000"]
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 或 false 按一下以切換來源
none? {|element| ... } → true 或 false
none?(obj) → true 或 false

如果 self 的元素沒有符合指定條件,則傳回 true

如果未指定區塊且未傳入引數,則傳回 true(如果 self 沒有真值元素),否則傳回 false

[nil, false].none? # => true
[nil, 0, false].none? # => false
[].none? # => true

如果指定區塊且未傳入引數,則使用 self 中的每個元素呼叫區塊;如果區塊傳回真值,則傳回 true,否則傳回 false

[0, 1, 2].none? {|element| element > 3 } # => true
[0, 1, 2].none? {|element| element > 1 } # => false

如果傳入引數 obj,則傳回 true(如果 obj.=== 沒有元素),否則傳回 false

['food', 'drink'].none?(/bar/) # => true
['food', 'drink'].none?(/foo/) # => false
[].none?(/foo/) # => true
[0, 1, 2].none?(3) # => true
[0, 1, 2].none?(1) # => false

相關:Enumerable#none?

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 或 false 按一下以切換來源
one? {|element| ... } → true 或 false
one?(obj) → true 或 false

如果 self 的元素恰好有一個符合指定條件,則傳回 true

如果未指定區塊且未傳入引數,則傳回 true(如果 self 恰好有一個真值元素),否則傳回 false

[nil, 0].one? # => true
[0, 0].one? # => false
[nil, nil].one? # => false
[].one? # => false

如果指定區塊且未傳入引數,則使用 self 中的每個元素呼叫區塊;如果區塊傳回真值,則傳回 true,否則傳回 false

[0, 1, 2].one? {|element| element > 0 } # => false
[0, 1, 2].one? {|element| element > 1 } # => true
[0, 1, 2].one? {|element| element > 2 } # => false

如果傳入引數 obj,則傳回 true(如果 obj.=== 恰好有一個元素),否則傳回 false

[0, 1, 2].one?(0) # => true
[0, 0, 1].one?(0) # => false
[1, 1, 2].one?(0) # => false
['food', 'drink'].one?(/bar/) # => false
['food', 'drink'].one?(/foo/) # => true
[].one?(/foo/) # => false

相關:Enumerable#one?

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) → 字串 按一下以切換來源

self 中的每個元素格式化為二進制字串;傳回該字串。請參閱 封裝資料

# File pack.rb, line 7
def pack(fmt, buffer: nil)
  Primitive.pack_pack(fmt, buffer)
end
permutation {|element| ... } → self 按一下以切換來源
permutation(n) {|element| ... } → self
permutation → new_enumerator
permutation(n) → new_enumerator

當使用區塊呼叫時,會產生 `self` 元素的所有排列組合;傳回 `self`。排列組合的順序是不確定的。

當給定一個區塊和一個範圍內的正整數 Integer 參數 `n` (0 < n <= self.size) 時,會使用 `self` 的所有 `n` 元組排列組合呼叫區塊。

範例

a = [0, 1, 2]
a.permutation(2) {|permutation| p permutation }

輸出

[0, 1]
[0, 2]
[1, 0]
[1, 2]
[2, 0]
[2, 1]

另一個範例

a = [0, 1, 2]
a.permutation(3) {|permutation| p permutation }

輸出

[0, 1, 2]
[0, 2, 1]
[1, 0, 2]
[1, 2, 0]
[2, 0, 1]
[2, 1, 0]

n 為零時,呼叫區塊一次,並提供一個新的空陣列

a = [0, 1, 2]
a.permutation(0) {|permutation| p permutation }

輸出

[]

n 超出範圍(為負數或大於 self.size)時,不呼叫區塊

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

當給定一個區塊但沒有參數時,行為與 `a.permutation(a.size)` 相同

a = [0, 1, 2]
a.permutation {|permutation| p permutation }

輸出

[0, 1, 2]
[0, 2, 1]
[1, 0, 2]
[1, 2, 0]
[2, 0, 1]
[2, 1, 0]

如果未提供區塊,則傳回新的 Enumerator

a = [0, 1, 2]
a.permutation # => #<Enumerator: [0, 1, 2]:permutation>
a.permutation(2) # => #<Enumerator: [0, 1, 2]:permutation(2)>
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 → 物件或 nil 按一下切換來源
pop(n) → 新陣列

移除並傳回尾端元素。

當沒有給定參數且 `self` 不為空時,會移除並傳回最後一個元素

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

如果陣列為空,會傳回 `nil`。

當給定一個非負整數 Integer 參數 `n` 且在範圍內時,

會移除並傳回最後 `n` 個元素至一個新陣列

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

如果 `n` 為正數且超出範圍,會移除並傳回所有元素

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

相關:pushshiftunshift

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;
}
prepend
別名:unshift
product(*other_arrays) → 新陣列 按一下切換來源
product(*other_arrays) {|組合| ... } → self

計算並傳回或產生 `self` 和 `other_arrays` 中所有陣列元素的所有組合

  • 組合的數量是所有陣列(包含 `self` 和 `other_arrays`)大小的乘積。

  • 傳回組合的順序是不確定的。

當沒有給定區塊時,會傳回組合為陣列的陣列

a = [0, 1, 2]
a1 = [3, 4]
a2 = [5, 6]
p = a.product(a1)
p.size # => 6 # a.size * a1.size
p # => [[0, 3], [0, 4], [1, 3], [1, 4], [2, 3], [2, 4]]
p = a.product(a1, a2)
p.size # => 12 # a.size * a1.size * a2.size
p # => [[0, 3, 5], [0, 3, 6], [0, 4, 5], [0, 4, 6], [1, 3, 5], [1, 3, 6], [1, 4, 5], [1, 4, 6], [2, 3, 5], [2, 3, 6], [2, 4, 5], [2, 4, 6]]

如果任何參數為空陣列,會傳回空陣列。

如果沒有給定參數,會傳回 1 個元素陣列的陣列,每個元素包含 `self` 的一個元素

a.product # => [[0], [1], [2]]

當給定區塊時,會產生每個組合為陣列;傳回 `self`

a.product(a1) {|combination| p combination }

輸出

[0, 3]
[0, 4]
[1, 3]
[1, 4]
[2, 3]
[2, 4]

如果任何參數為空陣列,不會呼叫區塊

a.product(a1, a2, []) {|combination| fail 'Cannot happen' }

如果沒有給定參數,會產生 `self` 的每個元素為 1 個元素陣列

a.product {|combination| p combination }

輸出

[0]
[1]
[2]
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 按一下切換來源

附加尾端元素。

將 `objects` 中的每個參數附加至 `self`;傳回 `self`

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

將每個參數附加為一個元素,即使它是另一個陣列

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

相關:popshiftunshift

static VALUE
rb_ary_push_m(int argc, VALUE *argv, VALUE ary)
{
    return rb_ary_cat(ary, argv, argc);
}
別名為:append
rassoc(obj) → found_array or nil 按一下切換來源

傳回 self 中第一個第二個元素 == obj 的陣列

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

如果找不到此類元素,則傳回 nil

相關:assoc

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 按一下切換來源
reject → new_enumerator

傳回一個新的陣列,其元素全部來自 self,而區塊傳回 falsenil

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

如果未提供區塊,則傳回新的 Enumerator

a = [:foo, 'bar', 2]
a.reject # => #<Enumerator: [:foo, "bar", 2]:reject>
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 按一下切換來源
reject! → new_enumerator

移除區塊傳回真值的所有元素。

如果移除任何元素,傳回 self

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

若沒有移除任何元素,會傳回 nil

如果未提供區塊,則傳回新的 Enumerator

a = [:foo, 'bar', 2]
a.reject! # => #<Enumerator: [:foo, "bar", 2]:reject!>
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(n) {|combination| ... } → self 按一下切換來源
repeated_combination(n) → new_enumerator

使用 self 元素的每個長度為 n 的重複組合呼叫區塊;每個組合都是一個陣列;傳回 self。組合順序是不確定的。

當給定一個區塊和一個正 Integer 參數 n 時,使用 self 元素的每個 n 元組重複組合呼叫區塊。組合數目為 (n+1)(n+2)/2

n = 1:

a = [0, 1, 2]
a.repeated_combination(1) {|combination| p combination }

輸出

[0]
[1]
[2]

n = 2:

a.repeated_combination(2) {|combination| p combination }

輸出

[0, 0]
[0, 1]
[0, 2]
[1, 1]
[1, 2]
[2, 2]

如果 n 為零,使用一個空陣列呼叫區塊一次。

如果 n 為負數,不會呼叫區塊

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

如果未提供區塊,則傳回新的 Enumerator

a = [0, 1, 2]
a.repeated_combination(2) # => #<Enumerator: [0, 1, 2]:combination(2)>

使用列舉器,可以方便地顯示 n 的一些值的組合和計數

e = a.repeated_combination(0)
e.size # => 1
e.to_a # => [[]]
e = a.repeated_combination(1)
e.size # => 3
e.to_a # => [[0], [1], [2]]
e = a.repeated_combination(2)
e.size # => 6
e.to_a # => [[0, 0], [0, 1], [0, 2], [1, 1], [1, 2], [2, 2]]
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(n) {|permutation| ... } → self 按一下切換來源
repeated_permutation(n) → new_enumerator

使用 self 元素的每個長度為 n 的重複排列呼叫區塊;每個排列都是一個陣列;傳回 self。排列順序是不確定的。

當給定一個區塊和一個正 Integer 參數 n 時,使用 self 元素的每個 n 元組重複排列呼叫區塊。排列數目為 self.size**n

n = 1:

a = [0, 1, 2]
a.repeated_permutation(1) {|permutation| p permutation }

輸出

[0]
[1]
[2]

n = 2:

a.repeated_permutation(2) {|permutation| p permutation }

輸出

[0, 0]
[0, 1]
[0, 2]
[1, 0]
[1, 1]
[1, 2]
[2, 0]
[2, 1]
[2, 2]

如果 n 為零,使用一個空陣列呼叫區塊一次。

如果 n 為負數,不會呼叫區塊

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

如果未提供區塊,則傳回新的 Enumerator

a = [0, 1, 2]
a.repeated_permutation(2) # => #<Enumerator: [0, 1, 2]:permutation(2)>

使用列舉器,可以方便地顯示某些 n 值的排列和計數

e = a.repeated_permutation(0)
e.size # => 1
e.to_a # => [[]]
e = a.repeated_permutation(1)
e.size # => 3
e.to_a # => [[0], [1], [2]]
e = a.repeated_permutation(2)
e.size # => 9
e.to_a # => [[0, 0], [0, 1], [0, 2], [1, 0], [1, 1], [1, 2], [2, 0], [2, 1], [2, 2]]
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

使用 other_array 的內容取代 self 的內容;傳回 self

a = [:foo, 'bar', 2]
a.replace(['foo', :bar, 3]) # => ["foo", :bar, 3]
別名為:initialize_copy
reverse → new_array 按一下以切換來源

傳回一個新的陣列,其中包含 self 元素,順序相反

a = ['foo', 'bar', 'two']
a1 = a.reverse
a1 # => ["two", "bar", "foo"]
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 按一下以切換來源

原地反轉 self

a = ['foo', 'bar', 'two']
a.reverse! # => ["two", "bar", "foo"]
static VALUE
rb_ary_reverse_bang(VALUE ary)
{
    return rb_ary_reverse(ary);
}
reverse_each {|element| ... } → self 按一下以切換來源
reverse_each → Enumerator

反向迭代陣列元素。

當給定區塊時,將每個元素反向傳遞給區塊;傳回 self

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

輸出

Integer 2
String bar
Symbol foo

允許在反覆處理期間修改陣列。

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

輸出

2
bar

如果未給定區塊,則傳回一個新的列舉器。

a = [:foo, 'bar', 2]
e = a.reverse_each
e # => #<Enumerator: [:foo, "bar", 2]:reverse_each>
a1 = e.each {|element|  puts "#{element.class} #{element}" }

輸出

Integer 2
String bar
Symbol foo

相關:eacheach_index

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 按一下以切換來源
rindex {|element| ... } → integer or nil
rindex → new_enumerator

傳回最後一個元素的索引,其中 object == element

當給定引數 object 但沒有區塊時,傳回找到的最後一個此類元素的索引

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

如果找不到此類物件,則傳回 nil

當給定區塊但沒有引數時,使用每個後續元素呼叫區塊;傳回區塊傳回真值之最後一個元素的索引

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

如果區塊從未傳回真值,則傳回 nil

當沒有給定參數或區塊時,傳回新的 Enumerator

a = [:foo, 'bar', 2, 'bar']
e = a.rindex
e # => #<Enumerator: [:foo, "bar", 2, "bar"]:rindex>
e.each {|element| element == 'bar' } # => 3

相關:index

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 → new_array 按一下以切換來源
rotate(count) → new_array

傳回一個新的陣列,由 self 形成,其中元素從一端旋轉到另一端。

當沒有給定引數時,傳回一個新的陣列,類似於 self,但第一個元素已旋轉到最後一個位置

a = [:foo, 'bar', 2, 'bar']
a1 = a.rotate
a1 # => ["bar", 2, "bar", :foo]

當給定一個非負 Integer count,回傳一個新的陣列,其中包含從頭到尾旋轉 count 個元素

a = [:foo, 'bar', 2]
a1 = a.rotate(2)
a1 # => [2, :foo, "bar"]

如果 count 很大的話,使用 count % array.size 作為計數

a = [:foo, 'bar', 2]
a1 = a.rotate(20)
a1 # => [2, :foo, "bar"]

如果 count 為零,回傳 self 的副本,不修改

a = [:foo, 'bar', 2]
a1 = a.rotate(0)
a1 # => [:foo, "bar", 2]

當給定一個負 Integer count,從相反方向旋轉,從尾到頭

a = [:foo, 'bar', 2]
a1 = a.rotate(-2)
a1 # => ["bar", 2, :foo]

如果 count 很小(遠離零),使用 count % array.size 作為計數

a = [:foo, 'bar', 2]
a1 = a.rotate(-5)
a1 # => ["bar", 2, :foo]
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! → self 按一下以切換來源
rotate!(count) → self

原地旋轉 self,將元素從一端移到另一端;回傳 self

當沒有給定參數時,將第一個元素旋轉到最後一個位置

a = [:foo, 'bar', 2, 'bar']
a.rotate! # => ["bar", 2, "bar", :foo]

當給定一個非負 Integer count,從頭到尾旋轉 count 個元素

a = [:foo, 'bar', 2]
a.rotate!(2)
a # => [2, :foo, "bar"]

如果 count 很大的話,使用 count % array.size 作為計數

a = [:foo, 'bar', 2]
a.rotate!(20)
a # => [2, :foo, "bar"]

如果 count 為零,回傳未修改的 self

a = [:foo, 'bar', 2]
a.rotate!(0)
a # => [:foo, "bar", 2]

當給定一個負 Integer count,從相反方向旋轉,從尾到頭

a = [:foo, 'bar', 2]
a.rotate!(-2)
a # => ["bar", 2, :foo]

如果 count 很小(遠離零),使用 count % array.size 作為計數

a = [:foo, 'bar', 2]
a.rotate!(-5)
a # => ["bar", 2, :foo]
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 按一下以切換來源
sample(n, random: Random) → new_ary

self 回傳隨機元素。

當沒有給定參數時,從 self 回傳一個隨機元素

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

如果 self 為空,則回傳 nil

當給定參數 n 時,回傳一個新的陣列,其中包含從 self 取出的 n 個隨機元素

a.sample(3) # => [8, 9, 2]
a.sample(6) # => [9, 6, 10, 3, 1, 4]

回傳的元素數量不會超過 a.size(因為不會引入新的重複元素)

a.sample(a.size * 2) # => [6, 4, 1, 8, 5, 9, 10, 2, 3, 7]

但是 self 可能包含重複元素

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

參數 n 必須是非負數字值。結果陣列的順序與 self 的順序無關。如果 self 為空,則回傳一個新的空陣列。

可選參數 random 將用作亂數產生器

a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
a.sample(random: Random.new(1))     #=> 6
a.sample(4, random: Random.new(1))  #=> [6, 10, 9, 2]
# File array.rb, line 60
def sample(n = (ary = false), random: Random)
  if Primitive.mandatory_only?
    # Primitive.cexpr! %{ rb_ary_sample(self, rb_cRandom, Qfalse, Qfalse) }
    Primitive.ary_sample0
  else
    # Primitive.cexpr! %{ rb_ary_sample(self, random, n, ary) }
    Primitive.ary_sample(random, n, ary)
  end
end
select {|element| ... } → new_array 按一下以切換來源
select → new_enumerator

如果給定區塊,則使用 self 的每個元素呼叫該區塊;回傳一個新的陣列,其中包含 self 的那些元素,而區塊對這些元素回傳真值

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

如果未提供區塊,則傳回新的 Enumerator

a = [:foo, 'bar', 2, :bam]
a.select # => #<Enumerator: [:foo, "bar", 2, :bam]:select>
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;
}
別名為:filter
select! {|element| ... } → self or nil 按一下以切換來源
select! → new_enumerator

如果給定區塊,則使用 self 的每個元素呼叫該區塊;從 self 中移除區塊回傳 falsenil 的那些元素。

如果移除任何元素,則回傳 self

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

如果沒有移除任何元素,則回傳 nil

如果未提供區塊,則傳回新的 Enumerator

a = [:foo, 'bar', 2, :bam]
a.select! # => #<Enumerator: [:foo, "bar", 2, :bam]:select!>
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);
}
別名:filter!
shelljoin → 字串 按一下以切換來源

從引數清單 array 建立命令列字串,將所有元素以 Bourne shell 轉譯並以空白分隔。

有關詳細資料,請參閱 Shellwords.shelljoin

# File lib/shellwords.rb, line 239
def shelljoin
  Shellwords.join(self)
end
shift → 物件或 nil 按一下以切換來源
shift(n) → new_array

移除並傳回開頭的元素。

如果未提供引數,則移除並傳回第一個元素

a = [:foo, 'bar', 2]
a.shift # => :foo
a # => ['bar', 2]

如果 self 為空,則傳回 nil

如果給定正整數 Integer 引數 n,則移除開頭的 n 個元素;在新的陣列中傳回這些元素

a = [:foo, 'bar', 2]
a.shift(2) # => [:foo, 'bar']
a # => [2]

如果 n 大於或等於 self.length,則移除所有元素;在新的陣列中傳回這些元素

a = [:foo, 'bar', 2]
a.shift(3) # => [:foo, 'bar', 2]

如果 n 為零,則傳回新的空陣列;self 保持不變。

相關:pushpopunshift

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_ary 按一下以切換來源

傳回新的陣列,其中 self 的元素已洗牌。

a = [1, 2, 3] #=> [1, 2, 3]
a.shuffle     #=> [2, 3, 1]
a             #=> [1, 2, 3]

可選參數 random 將用作亂數產生器

a.shuffle(random: Random.new(1))  #=> [1, 3, 2]
# File array.rb, line 26
def shuffle(random: Random)
  Primitive.rb_ary_shuffle(random)
end
shuffle!(random: Random) → 陣列 按一下以切換來源

self 的元素原地洗牌。

a = [1, 2, 3] #=> [1, 2, 3]
a.shuffle!    #=> [2, 3, 1]
a             #=> [2, 3, 1]

可選參數 random 將用作亂數產生器

a.shuffle!(random: Random.new(1))  #=> [1, 3, 2]
# File array.rb, line 12
def shuffle!(random: Random)
  Primitive.rb_ary_shuffle_bang(random)
end
size
別名:length
slice(index) → 物件或 nil
slice(start, length) → 物件或 nil
slice(range) → 物件或 nil
slice(aseq) → 物件或 nil

self 傳回元素;不會修改 self

當提供單一 整數 參數 index 時,傳回偏移量 index 處的元素

a = [:foo, 'bar', 2]
a[0] # => :foo
a[2] # => 2
a # => [:foo, "bar", 2]

如果 index 為負數,則從 self 的尾端開始計算

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

如果 index 超出範圍,則傳回 nil

當提供兩個 整數 參數 startlength 時,傳回一個大小為 length 的新陣列,其中包含從偏移量 start 開始的連續元素

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

如果 start + length 大於 self.length,則從偏移量 start 傳回所有元素至尾端

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

如果 start == self.sizelength >= 0,則傳回一個新的空陣列。

如果 length 為負數,則傳回 nil

當提供單一 範圍 參數 range 時,將 range.min 視為上述的 start,將 range.size 視為上述的 length

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

特殊情況:如果 range.start == a.size,則傳回一個新的空陣列。

如果 range.end 為負數,則從尾端計算結束索引

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

如果 range.start 為負數,則從尾端計算開始索引

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

如果 range.start 大於陣列大小,則傳回 nil

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

當提供單一 列舉器/算術序列 參數 aseq 時,傳回一個陣列,其中包含對應於序列所產生索引的元素。

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

與範圍切片不同,如果算術序列的開始或結束大於陣列大小,則會擲回 範圍錯誤

a = ['--', 'data1', '--', 'data2', '--', 'data3']
a[(1..11).step(2)]
# RangeError (((1..11).step(2)) out of range)
a[(7..).step(2)]
# RangeError (((7..).step(2)) out of range)

如果提供單一參數,且其類型不在所列類型中,則會嘗試將其轉換為 整數,如果無法轉換,則會引發錯誤

a = [:foo, 'bar', 2]
# Raises TypeError (no implicit conversion of Symbol into Integer):
a[:foo]
別名:[]
slice!(n) → 物件或 nil 按一下以切換來源
slice!(start, length) → new_array 或 nil
slice!(range) → new_array 或 nil

self 中移除並傳回元素。

當唯一的引數是 Integer n 時,移除並傳回 self 中的第 n 個元素

a = [:foo, 'bar', 2]
a.slice!(1) # => "bar"
a # => [:foo, 2]

如果 n 為負數,則從 self 的結尾開始倒數

a = [:foo, 'bar', 2]
a.slice!(-1) # => 2
a # => [:foo, "bar"]

如果 n 超出範圍,則傳回 nil

當唯一的引數是整數 startlength 時,從偏移量 start 開始從 self 中移除 length 個元素;在新的陣列中傳回已刪除的物件

a = [:foo, 'bar', 2]
a.slice!(0, 2) # => [:foo, "bar"]
a # => [2]

如果 start + length 超過陣列大小,則從偏移量 start 到結尾移除並傳回所有元素

a = [:foo, 'bar', 2]
a.slice!(1, 50) # => ["bar", 2]
a # => [:foo]

如果 start == a.sizelength 為非負值,則傳回一個新的空陣列。

如果 length 為負數,則傳回 nil

當唯一引數為 Range 物件 range 時,將 range.min 視為上述的 start,將 range.size 視為上述的 length

a = [:foo, 'bar', 2]
a.slice!(1..2) # => ["bar", 2]
a # => [:foo]

如果 range.start == a.size,則傳回一個新的空陣列。

如果 range.start 大於陣列大小,則傳回 nil

如果 range.end 為負值,則從陣列的最後一個元素開始往回算

a = [:foo, 'bar', 2]
a.slice!(0..-2) # => [:foo, "bar"]
a # => [2]

如果 range.start 為負值,則從陣列的最後一個元素開始往回算開始索引

a = [:foo, 'bar', 2]
a.slice!(-2..2) # => ["bar", 2]
a # => [:foo]
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 按一下以切換來源
sort {|a, b| ... } → new_array

傳回一個新的陣列,其元素來自 self,已排序。

如果沒有區塊,則使用運算子 <=> 比較元素(請參閱 Comparable

a = 'abcde'.split('').shuffle
a # => ["e", "b", "d", "a", "c"]
a1 = a.sort
a1 # => ["a", "b", "c", "d", "e"]

如果有一個區塊,則使用每個元素對呼叫區塊;對於每個元素對 ab,區塊應傳回一個整數

  • b 要接在 a 之後時為負值。

  • ab 相等時為零。

  • a 要接在 b 之後時為正值。

範例

a = 'abcde'.split('').shuffle
a # => ["e", "b", "d", "a", "c"]
a1 = a.sort {|a, b| a <=> b }
a1 # => ["a", "b", "c", "d", "e"]
a2 = a.sort {|a, b| b <=> a }
a2 # => ["e", "d", "c", "b", "a"]

當區塊傳回零時,ab 的順序不確定,且可能不穩定

a = 'abcde'.split('').shuffle
a # => ["e", "b", "d", "a", "c"]
a1 = a.sort {|a, b| 0 }
a1 # =>  ["c", "e", "b", "d", "a"]

相關:Enumerable#sort_by

VALUE
rb_ary_sort(VALUE ary)
{
    ary = rb_ary_dup(ary);
    rb_ary_sort_bang(ary);
    return ary;
}
sort! → self 按一下以切換來源
sort! {|a, b| ... } → self

傳回 self,其元素已就地排序。

如果沒有區塊,則使用運算子 <=> 比較元素(請參閱 Comparable

a = 'abcde'.split('').shuffle
a # => ["e", "b", "d", "a", "c"]
a.sort!
a # => ["a", "b", "c", "d", "e"]

如果有一個區塊,則使用每個元素對呼叫區塊;對於每個元素對 ab,區塊應傳回一個整數

  • b 要接在 a 之後時為負值。

  • ab 相等時為零。

  • a 要接在 b 之後時為正值。

範例

a = 'abcde'.split('').shuffle
a # => ["e", "b", "d", "a", "c"]
a.sort! {|a, b| a <=> b }
a # => ["a", "b", "c", "d", "e"]
a.sort! {|a, b| b <=> a }
a # => ["e", "d", "c", "b", "a"]

當區塊傳回零時,ab 的順序不確定,且可能不穩定

a = 'abcde'.split('').shuffle
a # => ["e", "b", "d", "a", "c"]
a.sort! {|a, b| 0 }
a # => ["d", "e", "c", "a", "b"]
VALUE
rb_ary_sort_bang(VALUE ary)
{
    rb_ary_modify(ary);
    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);
            }
            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 {
                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 按一下以切換來源
sort_by! → new_enumerator

使用區塊所決定的順序,就地排序 self 的元素;傳回 self。

使用每個連續元素呼叫區塊;根據區塊傳回的值排序元素。

對於區塊傳回的重複值,順序不確定,且可能不穩定。

此範例根據字串大小排序字串

a = ['aaaa', 'bbb', 'cc', 'd']
a.sort_by! {|element| element.size }
a # => ["d", "cc", "bbb", "aaaa"]

如果未提供區塊,則傳回新的 Enumerator

a = ['aaaa', 'bbb', 'cc', 'd']
a.sort_by! # => #<Enumerator: ["aaaa", "bbb", "cc", "d"]:sort_by!>
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 按一下以切換來源
sum(init = 0) {|element| ... } → object

如果未提供區塊,則傳回等同於

sum = init
array.each {|element| sum += element }
sum

例如,[e1, e2, e3].sum 傳回 init + e1 + e2 + e3

範例

a = [0, 1, 2, 3]
a.sum # => 6
a.sum(100) # => 106

元素不必是數字,但必須彼此相容,且與 init 相容

a = ['abc', 'def', 'ghi']
a.sum('jkl') # => "jklabcdefghi"

如果提供區塊,則使用每個元素呼叫區塊,且使用區塊的傳回值(而非元素本身)作為加數

a = ['zero', 1, :two]
s = a.sum('Coerced and concatenated: ') {|element| element.to_s }
s # => "Coerced and concatenated: zero1two"

備註

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(n) → new_array 按一下以切換來源

傳回一個新的陣列,其中包含 self 的前 n 個元素,其中 n 是非負數 Integer;不會修改 self

範例

a = [0, 1, 2, 3, 4, 5]
a.take(1) # => [0]
a.take(2) # => [0, 1]
a.take(50) # => [0, 1, 2, 3, 4, 5]
a # => [0, 1, 2, 3, 4, 5]
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 按一下以切換來源
take_while → new_enumerator

傳回一個新的陣列,其中包含 self 的零個或多個前導元素;不會修改 self

如果給定區塊,則會對 self 的每個後續元素呼叫區塊;如果區塊傳回 falsenil,則會停止;傳回一個新的陣列,其中包含區塊傳回真值元素

a = [0, 1, 2, 3, 4, 5]
a.take_while {|element| element < 3 } # => [0, 1, 2]
a.take_while {|element| true } # => [0, 1, 2, 3, 4, 5]
a # => [0, 1, 2, 3, 4, 5]

如果未給定區塊,則傳回一個新的列舉器。

[0, 1].take_while # => #<Enumerator: [0, 1]:take_while>
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 按一下以切換來源

self 是陣列的執行個體時,傳回 self

a = [:foo, 'bar', 2]
a.to_a # => [:foo, "bar", 2]

否則,傳回一個新的陣列,其中包含 self 的元素

class MyArray < Array; end
a = MyArray.new(['foo', 'bar', 'two'])
a.instance_of?(Array) # => false
a.kind_of?(Array) # => true
a1 = a.to_a
a1 # => ["foo", "bar", "two"]
a1.class # => Array # Not MyArray
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 按一下以切換來源

傳回 self

static VALUE
rb_ary_to_ary_m(VALUE ary)
{
    return ary;
}
to_h → new_hash 按一下以切換來源
to_h {|item| ... } → new_hash

傳回一個新的 Hash,由 self 形成。

當給定區塊時,會對每個陣列元素呼叫區塊;區塊必須傳回一個 2 元素陣列,其 2 個元素在傳回的 Hash 中形成一個鍵值對

a = ['foo', :bar, 1, [2, 3], {baz: 4}]
h = a.to_h {|item| [item, item] }
h # => {"foo"=>"foo", :bar=>:bar, 1=>1, [2, 3]=>[2, 3], {:baz=>4}=>{:baz=>4}}

當未給定區塊時,self 必須是 2 元素子陣列的陣列,每個子陣列在新的 Hash 中形成一個鍵值對

[].to_h # => {}
a = [['foo', 'zero'], ['bar', 'one'], ['baz', 'two']]
h = a.to_h
h # => {"foo"=>"zero", "bar"=>"one", "baz"=>"two"}
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
別名:inspect
transpose → new_array 按一下以切換來源

轉置陣列陣列中的列和行;巢狀陣列必須全部相同大小

a = [[:a0, :a1], [:b0, :b1], [:c0, :c1]]
a.transpose # => [[:a0, :b0, :c0], [:a1, :b1, :c1]]
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 按一下以切換來源

傳回一個新的陣列,它是 self 和所有給定陣列 other_arrays 的聯集;會移除重複項;會保留順序;會使用 eql? 比較項目

[0, 1, 2, 3].union([4, 5], [6, 7]) # => [0, 1, 2, 3, 4, 5, 6, 7]
[0, 1, 1].union([2, 1], [3, 1]) # => [0, 1, 2, 3]
[0, 1, 2, 3].union([3, 2], [1, 0]) # => [0, 1, 2, 3]

若沒有給定參數,會傳回 self 的副本。

相關:Array#|

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 按一下以切換來源
uniq {|element| ... } → new_array

傳回一個新的陣列,其中包含來自 `self` 的元素,且這些元素不是重複的,而第一個出現的元素始終會保留。

如果沒有給定區塊,則使用 `eql?` 方法來比較,並找出並省略重複的元素。

a = [0, 0, 1, 1, 2, 2]
a.uniq # => [0, 1, 2]

如果給定區塊,則會對每個元素呼叫區塊;找出(使用 `eql?` 方法)並省略重複的值,亦即區塊傳回相同值的那些元素。

a = ['a', 'aa', 'aaa', 'b', 'bb', 'bbb']
a.uniq {|element| element.size } # => ["a", "aa", "aaa"]
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 按一下以切換來源
uniq! {|element| ... } → self or nil

從 `self` 中移除重複的元素,而第一個出現的元素始終會保留;如果移除任何元素,則傳回 `self`,否則傳回 `nil`。

如果沒有給定區塊,則使用 `eql?` 方法來比較,並找出並移除元素。

如果移除任何元素,傳回 self

a = [0, 0, 1, 1, 2, 2]
a.uniq! # => [0, 1, 2]

若沒有移除任何元素,會傳回 nil

如果給定區塊,則會對每個元素呼叫區塊;找出(使用 `eql?` 方法)並移除區塊傳回重複值的元素。

如果移除任何元素,傳回 self

a = ['a', 'aa', 'aaa', 'b', 'bb', 'bbb']
a.uniq! {|element| element.size } # => ['a', 'aa', 'aaa']

若沒有移除任何元素,會傳回 nil

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) && !ARY_EMBED_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 按一下以切換來源

將給定的 `objects` 加到 `self` 的前面。

a = [:foo, 'bar', 2]
a.unshift(:bam, :bat) # => [:bam, :bat, :foo, "bar", 2]

相關:pushpopshift

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;
}
別名:prepend
values_at(*indexes) → new_array 按一下以切換來源

傳回一個新的陣列,其元素為 `self` 中在給定的 IntegerRange `indexes` 中的元素。

對於每個正向的 `index`,傳回在偏移量 `index` 處的元素。

a = [:foo, 'bar', 2]
a.values_at(0, 2) # => [:foo, 2]
a.values_at(0..1) # => [:foo, "bar"]

給定的 `indexes` 可以是任何順序,且可以重複。

a = [:foo, 'bar', 2]
a.values_at(2, 0, 1, 0, 2) # => [2, :foo, "bar", :foo, 2]
a.values_at(1, 0..2) # => ["bar", :foo, "bar", 2]

對於過大的 `index`,指定為 `nil`。

a = [:foo, 'bar', 2]
a.values_at(0, 3, 1, 3) # => [:foo, nil, "bar", nil]

如果沒有給定任何參數,則傳回一個新的空陣列。

對於每個負向的 `index`,從陣列的尾端開始往回算。

a = [:foo, 'bar', 2]
a.values_at(-1, -3) # => [2, :foo]

對於過小的 `index`,指定為 `nil`。

a = [:foo, 'bar', 2]
a.values_at(0, -5, 1, -6, 2) # => [:foo, nil, "bar", nil, 2]

給定的 `indexes` 可以包含正負號混合。

a = [:foo, 'bar', 2]
a.values_at(0, -2, 1, -1) # => [:foo, "bar", "bar", 2]
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 按一下以切換來源
zip(*other_arrays) {|other_array| ... } → nil

如果沒有給定區塊,則傳回一個新的陣列 `new_array`,其大小為 `self.size`,且其元素為陣列。

每個巢狀陣列 `new_array[n]` 的大小為 `other_arrays.size+1`,且包含:

  • `self` 的第 n 個元素。

  • 每個 `other_arrays` 的第 n 個元素。

如果所有 `other_arrays` 和 `self` 的大小相同

a = [:a0, :a1, :a2, :a3]
b = [:b0, :b1, :b2, :b3]
c = [:c0, :c1, :c2, :c3]
d = a.zip(b, c)
d # => [[:a0, :b0, :c0], [:a1, :b1, :c1], [:a2, :b2, :c2], [:a3, :b3, :c3]]

如果 `other_arrays` 中的任何陣列小於 `self`,則使用 `nil` 填滿至 `self.size`。

a = [:a0, :a1, :a2, :a3]
b = [:b0, :b1, :b2]
c = [:c0, :c1]
d = a.zip(b, c)
d # => [[:a0, :b0, :c0], [:a1, :b1, :c1], [:a2, :b2, nil], [:a3, nil, nil]]

如果 `other_arrays` 中的任何陣列大於 `self`,則忽略其尾端的元素。

a = [:a0, :a1, :a2, :a3]
b = [:b0, :b1, :b2, :b3, :b4]
c = [:c0, :c1, :c2, :c3, :c4, :c5]
d = a.zip(b, c)
d # => [[:a0, :b0, :c0], [:a1, :b1, :c1], [:a2, :b2, :c2], [:a3, :b3, :c3]]

如果給定區塊,則使用每個子陣列(如上所述)呼叫區塊;傳回 `nil`。

a = [:a0, :a1, :a2, :a3]
b = [:b0, :b1, :b2, :b3]
c = [:c0, :c1, :c2, :c3]
a.zip(b, c) {|sub_array| p sub_array} # => nil

輸出

[:a0, :b0, :c0]
[:a1, :b1, :c1]
[:a2, :b2, :c2]
[:a3, :b3, :c3]
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;
}
array | other_array → new_array 按一下以切換來源

傳回 array 和陣列 other_array 的聯集;重複項目會移除;順序會保留;項目會使用 eql? 進行比較

[0, 1] | [2, 3] # => [0, 1, 2, 3]
[0, 1, 1] | [2, 2, 3] # => [0, 1, 2, 3]
[0, 1, 2] | [3, 2, 1, 0] # => [0, 1, 2, 3]

相關:Array#union

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);
}