如何在 Ruby 中返回数组的一部分？

Posted 2023-02-23

【中文标题】如何在 Ruby 中返回数组的一部分？

【英文标题】：How to return a part of an array in Ruby?

【发布时间】：2010-10-16 06:26:27

【问题描述】：

使用 Python 中的列表，我可以使用以下代码返回其中的一部分：

foo = [1,2,3,4,5,6]
bar = [10,20,30,40,50,60]
half = len(foo) / 2
foobar = foo[:half] + bar[half:]

由于 Ruby 在数组中做所有事情，我想知道是否有类似的东西。

【参考方案1】：

是的，Ruby 的数组切片语法与 Python 非常相似。这是数组索引方法的ri 文档：

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

        a = [ "a", "b", "c", "d", "e" ]
        a[2] +  a[0] + a[1]    #=> "cab"
        a[6]                   #=> nil
        a[1, 2]                #=> [ "b", "c" ]
        a[1..3]                #=> [ "b", "c", "d" ]
        a[4..7]                #=> [ "e" ]
        a[6..10]               #=> nil
        a[-3, 3]               #=> [ "c", "d", "e" ]
        # special cases
        a[5]                   #=> nil
        a[6, 1]                #=> nil
        a[5, 1]                #=> []
        a[5..10]               #=> []

【讨论】：

为什么 a[5, 1] 与 a[6, 1] 不同？

@dertoni: ***.com/questions/3219229/…

a[2..-1] 从第三个元素到最后一个元素。 a[2...-1] 从第三个元素到倒数第二个元素。

@Rafeh 欢呼，一直想知道这个垃圾是如何工作的，-1 成功了

@CleverProgrammer 语法比公认的答案更接近 Python。我喜欢 Ruby，但我必须说 Python 的语法更短更清晰。作为奖励，可以指定步骤：range(10)[:5:-1]

【参考方案2】：

如果要在索引 i 上拆分/剪切数组，

arr = arr.drop(i)

> arr = [1,2,3,4,5]
 => [1, 2, 3, 4, 5] 
> arr.drop(2)
 => [3, 4, 5] 

【参考方案3】：

您可以为此使用slice()：

>> foo = [1,2,3,4,5,6]
=> [1, 2, 3, 4, 5, 6]
>> bar = [10,20,30,40,50,60]
=> [10, 20, 30, 40, 50, 60]
>> half = foo.length / 2
=> 3
>> foobar = foo.slice(0, half) + bar.slice(half, foo.length)
=> [1, 2, 3, 40, 50, 60]

顺便说一句，据我所知，Python“列表”只是有效地实现了动态增长的数组。开头插入是O(n)，最后插入是摊销O(1)，随机访问是O(1)。

【讨论】：

你的意思是在第二个切片中使用条形数组吗？

仅供参考：slice!() 不会就地修改数组，而是“删除由索引（可选长度为元素）或范围指定的元素。”每ruby-doc.org/core-2.2.3/Array.html#method-i-slice-21

@joshuapinter 谢谢你自己！我只是被这个（再次，显然）咬住了。

【参考方案4】：

Ruby 2.6 Beginless/Endless Ranges

(..1)
# or
(...1)

(1..)
# or
(1...)

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

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

ROLES = %w[superadmin manager admin contact user]
ROLES[ROLES.index('admin')..]
=> ["admin", "contact", "user"]

【参考方案5】：

另一种方法是使用范围方法

foo = [1,2,3,4,5,6]
bar = [10,20,30,40,50,60]
a = foo[0...3]
b = bar[3...6]

print a + b 
=> [1, 2, 3, 40, 50 , 60]

【参考方案6】：

我喜欢这个范围：

def first_half(list)
  list[0...(list.length / 2)]
end

def last_half(list)
  list[(list.length / 2)..list.length]
end

但是，要非常小心端点是否包含在您的范围内。这在一个奇数长度的列表中变得至关重要，您需要选择在哪里打破中间。否则你最终会重复计算中间元素。

上面的示例将始终将中间元素放在后半部分。

【讨论】：

如果需要，您可以使用(list.length / 2.0).ceil 将中间元素始终放在前半部分。