Array slicing in Ruby: Erklärung für das unlogische Verhalten (entnommen aus Rubykoans.com)

dies hat mit der Tatsache zu tun, dass die Scheibe ein array zurückgibt, relevante Quelle Dokumentation von 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

das lässt mich vermuten, dass, wenn Sie geben die start -, das ist außerhalb der Grenzen, wird es wieder null, also in deinem Beispiel array[4,0] bittet für das 4. element, das vorhanden ist, aber bittet um Rückgabe ein array mit null Elementen. Während array[5,0] aufgefordert, einen index out of bounds, also es wird nil zurückgegeben. Dies macht das vielleicht mehr Sinn, wenn Sie sich daran erinnern, dass die slice-Methode ist wieder eine neue array, nicht änderung der ursprünglichen Datenstruktur.

EDIT:

Nach der überprüfung der Kommentare, die ich beschlossen, zu Bearbeiten, zu beantworten. Scheibe ruft die folgende code-snippet, wenn die arg-Wert zwei:

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);
}

wenn man sich in der array.c Klasse, wo die rb_ary_subseq Methode definiert ist, sehen Sie, dass es ist die Rückgabe nil, wenn die Länge ist außerhalb der Grenzen, nicht der index:

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

In diesem Fall das ist, was passiert, wenn 4 übergeben wird, prüft es, dass es 4 Elemente sind und daher löst keine der null-Rendite. Es geht dann auf und ein leeres array zurück, wenn das zweite argument auf null gesetzt ist. während, wenn 5 übergeben wird, es gibt nicht die 5 Elemente im array, so wird nil zurückgegeben, bevor der null-arg ausgewertet wird. code hier an der Linie 944.

Ich glaube, dass dies ein Fehler zu sein, oder zumindest unberechenbar und nicht das 'Prinzip der Geringsten Überraschung'. Wenn ich ein paar Minuten werde ich mindestens das Einreichen einer fehlerhaften test-patch auf ruby-core.

InformationsquelleAutor Jed Schneider

Dies macht Sinn, wenn man bedenkt, als ein array-slice kann ein Gültiger lvalue, nicht nur ein rvalue:

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]

Dies wäre nicht möglich, wenn array[4,0] zurückgegeben nil statt []. Allerdings array[5,0] zurück nil weil es out of bounds (einfügen nach dem 4. element der 4-element-array sinnvoll ist, aber das einfügen nach dem 5. element der 4-element-array nicht).

Lesen Sie die slice-syntax array[x,y] wie "ab nach x Elemente in array wählen Sie bis zu y Elemente". Dies ist nur sinnvoll, wenn array hat mindestens x Elemente.

InformationsquelleAutor Frank Szczerba

Ich bin damit einverstanden, dass dies scheint wie ein seltsames Verhalten, aber auch die offizielle Dokumentation auf Array#slice zeigt das gleiche Verhalten, wie in Ihrem Beispiel, in "besonderen Fällen" unter:

   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]               #=> []

Leider, auch Ihre Beschreibung von Array#slice scheint nicht zu bieten jede Einsicht zu warum es funktioniert auf diese Weise:

Element Referenz—Liefert das element an der index, oder gibt einen subarray ab start - und Weiterbildung für Länge Elemente, oder gibt einen subarray angegeben Bereich. Negative Indizes zählen rückwärts vom Ende des Arrays (-1 ist das Letzte element). Wird nil zurückgegeben, wenn der index (oder ab-index) sind außerhalb der Reichweite.

InformationsquelleAutor Mark Rushakoff

Einer Erklärung zur Verfügung gestellt von Jim Weirich

Eine Art, nachzudenken ist es, die index-position 4 ist an der Kante
der array. Wenn gefragt wird, für ein Stück, kehren Sie so viel von der
array Links. So betrachten Sie das array[2,10], array[3,10] und
array[4,10] ... jeder gibt die restlichen bits der Ende der
array: 2 Elemente, 1 element und 0 Elemente jeweils. Allerdings
position 5 ist deutlich außerhalb das array und nicht am Rand, so
array[5,10], wird nil zurückgegeben.

InformationsquelleAutor suvankar

tl;dr: in den source-code in array.c, unterschiedliche Funktionen aufgerufen werden, je nachdem, ob Sie pass 1 oder 2 Argumente in Array#slice was in der unerwartete Werte zurückgeben.

(First off, würde ich mag darauf hinweisen, dass ich keinen code in C, aber habe mit Ruby seit Jahren. Also, wenn Sie nicht vertraut sind mit C, aber nehmen Sie ein paar Minuten, um sich vertraut mit den Grundlagen von Funktionen und Variablen es ist wirklich nicht schwer, Folgen Sie den Ruby-source-code, wie unten gezeigt. Diese Antwort basiert auf Ruby v2.3, aber ist mehr oder weniger das gleiche zurück zu v1.9.)

Szenario #1

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

Wenn du dir den source-code für Array#slice (rb_ary_aref), sehen Sie, dass, wenn nur ein argument übergeben wird (Linien 1277-1289), rb_ary_entry genannt wird, vorbei an der index-Wert (das kann positiv oder negativ sein).

rb_ary_entry berechnet dann die position des gewünschten element aus dem Anfang des Arrays (in anderen Worten, wenn ein negativer Wert übergeben wird, wird er berechnet das positive äquivalent) und ruft dann rb_ary_elt, um das angeforderte element.

Als erwartet, rb_ary_elt zurück nil wenn die Länge des array len ist weniger als oder gleich der index (hier genannt offset).

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

Szenario #2

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

Allerdings, wenn 2 Argumente übergeben werden (d.h. die Indexposition beg, und die Länge der Scheibe len), rb_ary_subseq genannt wird.

In rb_ary_subseq, wenn der Start-index beg ist größer als die array-Länge alen, nil zurückgegeben:

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

Sonst die Länge des slice len berechnet wird, und wenn es bestimmt zu null, wird ein leeres array zurückgegeben:

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);

So, da die Start-index von 4 ist nicht größer als array.length, wird ein leeres array zurückgegeben wird, anstatt des nil Wert, dass man annehmen könnte.

Frage beantwortet?

Wenn die eigentliche Frage hier ist nicht "Was code bewirkt, dass dies geschehen kann?", sondern vielmehr, "Warum hat Matz es so machen?", nun müssen Sie nur kaufen Sie ihm eine Tasse Kaffee an der nächsten RubyConf und ihn Fragen.

InformationsquelleAutor Scott Schupbach