Ruby中的数组切片:解释不合逻辑的行为(摘自Rubykoans.com)

我正在进行红宝石以心传心的练习，我被以下Ruby的怪癖所震惊，我发现它真的无法解释:

array = [:peanut, :butter, :and, :jelly]


array[0]     #=> :peanut    #OK!
array[0,1]   #=> [:peanut]  #OK!
array[0,2]   #=> [:peanut, :butter]  #OK!
array[0,0]   #=> []    #OK!
array[2]     #=> :and  #OK!
array[2,2]   #=> [:and, :jelly]  #OK!
array[2,20]  #=> [:and, :jelly]  #OK!
array[4]     #=> nil  #OK!
array[4,0]   #=> []   #HUH??  Why's that?
array[4,100] #=> []   #Still HUH, but consistent with previous one
array[5]     #=> nil  #consistent with array[4] #=> nil
array[5,0]   #=> nil  #WOW.  Now I don't understand anything anymore...

那么为什么array[5,0]不等于array[4,0]呢?当你从(length+1)th位置开始时，有什么原因导致数组切片表现得如此奇怪吗??

27356 次浏览
小开

切片和索引是两种不同的操作，从其中一个推断另一个的行为是您的问题所在。

slice中的第一个参数不是标识元素，而是标识元素之间的位置，定义span(而不是元素本身):

  :peanut   :butter   :and   :jelly
0         1         2      3        4

4仍然在数组中，只是勉强;如果你请求0个元素，你会得到数组的空末端。但是没有索引5，所以你不能从这里开始切片。

当你做索引(如array[4])时，你指向的是元素本身，所以索引只从0到3。

小开

我同意这看起来像是奇怪的行为，但即使是Array#slice的官方文档在下面的“特殊情况”中演示了与你的例子中相同的行为:

   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[5, 1]                #=> []
a[5..10]               #=> []

不幸的是，即使他们对Array#slice的描述似乎也没有提供任何关于为什么的见解，它是这样工作的:

元素引用——返回位于指数的元素，或返回从开始开始并继续为长度元素的子数组，或返回由范围指定的子数组。负索引从数组的末尾开始计数(-1是最后一个元素)。如果索引(或起始索引)超出范围，则返回nil。

小开

至少要注意行为是一致的。从5开始，一切都是一样的;奇怪的只发生在[4,N]。

也许这种模式有帮助，或者我只是累了，根本没用。

array[0,4] => [:peanut, :butter, :and, :jelly]
array[1,3] => [:butter, :and, :jelly]
array[2,2] => [:and, :jelly]
array[3,1] => [:jelly]
array[4,0] => []

在[4,0]处，我们捕获数组的末尾。如果最后一个返回nil，我实际上会发现它相当奇怪，就模式的美而言。由于这样的上下文，4是第一个参数的可接受选项，以便可以返回空数组。但是，一旦我们达到5或5以上，方法可能会立即退出，因为它完全超出了边界。

小开

这与slice返回一个数组有关，相关的源文档来自array# slice:

 *  call-seq:
*     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

这向我表明，如果你给出的开始是越界的，它将返回nil，因此在你的例子中array[4,0]要求存在的第4个元素，但要求返回一个零元素的数组。而array[5,0]请求一个越界索引，因此返回nil。如果你记得slice方法返回的是一个新数组，而不是改变原始的数据结构，这可能更有意义。

编辑:

在看过评论后，我决定编辑这个答案。当arg值为2时，Slice调用以下代码片段:

if (argc == 2) {
if (SYMBOL_P(argv[0])) {
rb_raise(rb_eTypeError, "Symbol as array index");
}
beg = NUM2LONG(argv[0]);
len = NUM2LONG(argv[1]);
if (beg < 0) {
beg += RARRAY(ary)->len;
}
return rb_ary_subseq(ary, beg, len);
}

如果你查看定义了rb_ary_subseq方法的array.c类，你会看到如果长度超出边界，它将返回nil，而不是索引:

if (beg > RARRAY_LEN(ary)) return Qnil;

在这个例子中，这就是传入4时发生的情况，它检查是否有4个元素，因此不会触发nil返回。然后，如果第二个参数被设置为0，它将返回一个空数组。而如果传入5，则数组中没有5个元素，因此在zero参数被求值之前返回nil。代码在这里在第944行。

我认为这是一个错误，或者至少是不可预测的，而不是“最小意外原则”。当我有几分钟的时间，我至少会提交一个失败的测试补丁给ruby core。

小开

这个做是有意义的

你需要能够给这些切片赋值，所以它们被定义为这样一种方式，即字符串的开头和结尾有工作的零长度表达式。

array[4, 0] = :sandwich
array[0, 0] = :crunchy
=> [:crunchy, :peanut, :butter, :and, :jelly, :sandwich]
小开

由Jim Weirich提供的解释

一种思考方法是索引位置4在最边缘 数组的。当你要一片的时候，你要回同样多的 剩下的数组。所以考虑数组[2,10]，数组[3,10]和 array[4、10]…类结尾的剩余位 数组:2个元素，1个元素和0个元素。然而, 位置5显然是外数组，而不是在边缘，因此

.数组[5,10]返回nil
小开

当你考虑数组slice可以是一个有效的左值，而不仅仅是一个右值时，这是有意义的:

array = [:peanut, :butter, :and, :jelly]
# replace 0 elements starting at index 5 (insert at end or array):
array[4,0] = [:sandwich]
# replace 0 elements starting at index 0 (insert at head of array):
array[0,0] = [:make, :me, :a]
# array is [:make, :me, :a, :peanut, :butter, :and, :jelly, :sandwich]


# this is just like replacing existing elements:
array[3, 4] = [:grilled, :cheese]
# array is [:make, :me, :a, :grilled, :cheese, :sandwich]

如果array[4,0]返回nil而不是[]，这是不可能的。然而，array[5,0]返回nil，因为它是越界的(在4元素数组的第4个元素之后插入是有意义的，但在4元素数组的第5个元素之后插入是没有意义的)。

将切片语法array[x,y]读为“从array中的x元素开始，最多选择y元素”。只有在array至少有x元素时才有意义。

小开

考虑以下数组:

>> array=["a","b","c"]
=> ["a", "b", "c"]

通过将数组赋值给a[0,0]，可以将一个元素插入数组的开头(头部)。要将元素放在"a"和"b"之间，使用a[1,0]。基本上，在a[i,n]符号中，i表示一个索引，n表示一些元素。当n=0时，它定义数组元素之间的位置。

现在，如果您考虑数组的末尾，您如何使用上面描述的符号将一个项附加到它的末尾?很简单，将值赋给a[3,0]。这是数组的尾部。

因此，如果你试图访问位于a[3,0]的元素，你将得到[]。在这种情况下，您仍然在数组的范围内。但是如果你尝试访问a[4,0]，你会得到nil作为返回值，因为你不再在数组的范围内了。

在http://mybrainstormings.wordpress.com/2012/09/10/arrays-in-ruby/上阅读更多信息。

小开
我发现Gary Wright的解释也很有帮助。 http://www.ruby-forum.com/topic/1393096#990065 < / p >

Gary Wright给出的答案是-

http://www.ruby-doc.org/core/classes/Array.html

文档当然可以更清楚，但实际的行为是 自我一致和有用。 注意:我假设1.9。

. X版本

按照以下方式考虑编号会有所帮助:

  -4  -3  -2  -1    <-- numbering for single argument indexing
0   1   2   3
+---+---+---+---+
| a | b | c | d |
+---+---+---+---+
0   1   2   3   4  <-- numbering for two argument indexing or start of range
-4  -3  -2  -1
常见的(也是可以理解的)错误是过于假定语义 的单参数索引的语义是相同的 第一个参数在两个参数场景(或范围)。他们不是 在实践中也是一样的，但是文档并没有反映这一点。 错误肯定是在文档中，而不是在 实现:< / p >

单个参数:索引表示单个字符位置 在字符串中。结果是单个字符串 在索引处或nil处找到，因为在给定位置没有字符 指数。< / p > 

  s = ""
s[0]    # nil because no character at that position


s = "abcd"
s[0]    # "a"
s[-4]   # "a"
s[-5]   # nil, no characters before the first one

两个整数参数:参数标识字符串的一部分 提取或替换。特别是字符串的零宽度部分 还可以进行标识，以便文本可以在之前或之后插入 现有字符，包括字符串的前端或末尾。在这个 在这种情况下，第一个参数不标识字符位置，但是 而是标识字符之间的空格，如图所示 以上。第二个参数是长度，可以是0 

s = "abcd"   # each example below assumes s is reset to "abcd"


To insert text before 'a':   s[0,0] = "X"           #  "Xabcd"
To insert text after 'd':    s[4,0] = "Z"           #  "abcdZ"
To replace first two characters: s[0,2] = "AB"      #  "ABcd"
To replace last two characters:  s[-2,2] = "CD"     #  "abCD"
To replace middle two characters: s[1..3] = "XX"    #  "aXXd"
range的行为非常有趣。起点是 当提供两个参数时，与第一个参数相同(如所述) 但范围的终点可以是'字符位置'为 与单索引或“边缘位置”作为两个整数 参数。区别是由是否双点范围决定的 或者使用三重点范围:

s = "abcd"
s[1..1]           # "b"
s[1..1] = "X"     # "aXcd"


s[1...1]          # ""
s[1...1] = "X"    # "aXbcd", the range specifies a zero-width portion of
the string


s[1..3]           # "bcd"
s[1..3] = "X"     # "aX",  positions 1, 2, and 3 are replaced.


s[1...3]          # "bc"
s[1...3] = "X"    # "aXd", positions 1, 2, but not quite 3 are replaced.

如果你回顾这些例子并坚持使用单曲 双索引或范围索引示例的索引语义 感到困惑。你必须使用我在

小开

dr:在array.c的源代码中，不同的函数会被调用，这取决于你传递给Array#slice的参数是1个还是2个，导致了意外的返回值。

(首先，我想指出的是，我不会用C编程，但多年来一直在使用Ruby。因此，如果您不熟悉C语言，但您花了几分钟时间来熟悉函数和变量的基础知识，那么遵循Ruby源代码实际上并不难，如下所示。这个答案是基于Ruby v2.3的，但与v1.9差不多。)

场景# 1

array.length == 4; array.slice(4) #=> nil

如果你查看Array#slice (rb_ary_aref)的源代码，你会看到当只传入一个参数(第1289 - 1277行)时，会调用rb_ary_entry，传入索引值(可以是正的或负的)。

rb_ary_entry然后计算请求元素从数组开始的位置(换句话说，如果传入了一个负索引，它会计算正的等价值)，然后调用rb_ary_elt来获取请求的元素。

正如预期的那样，当数组len的长度为索引小于或等于(这里称为offset)时，rb_ary_elt返回nil。

1189:  if (offset < 0 || len <= offset) {
1190:    return Qnil;
1191:  }

场景# 2

array.length == 4; array.slice(4, 0) #=> []

然而，当传入2个参数(即起始索引beg和切片长度len)时，将调用rb_ary_subseq。

在rb_ary_subseq中，如果起始索引beg为大于，数组长度为alen，则返回nil:

1208:  long alen = RARRAY_LEN(ary);
1209:
1210:  if (beg > alen) return Qnil;

否则，计算结果片len的长度，如果它被确定为零，则返回一个空数组:

1213:  if (alen < len || alen < beg + len) {
1214:  len = alen - beg;
1215:  }
1216:  klass = rb_obj_class(ary);
1217:  if (len == 0) return ary_new(klass, 0);

因此，由于4的起始下标不大于array.length，返回的是一个空数组，而不是人们可能期望的nil值。

问题回答吗?

如果这里真正的问题不是“什么代码导致这种情况发生?”，而是“Matz为什么这样做?”，那么你只需要在下一次RubyConf上请他喝杯咖啡，然后问他。


提交答案