Почему ruby ​​array.delete_at внутри array.each не удается?

Question

Я новичок в Ruby, и ясно увидеть и найти в Интернете, что следующий сбой:

arr = [10, 20, 30, 40]  
arr.each.with_index do |elmt, i| 
    print "#{elmt}, #{i}, " 
    arr.delete_at(i) if elmt == 20 
    puts arr.length 
end 

Очевидно, что delete_at взаимодействует с итератора, но я не могу найти четкое описание того, как итератор и delete_at работы так что это так. (BTW, я понимаю решения, которые работают - я не ищу правильный способ сделать это, я пытаюсь понять семантику, чтобы я знал, почему это не делает то, что ожидается.) Для полноты здесь выход

10, 0, 4 
20, 1, 3 
40, 2, 3 
=> [10, 30, 40] 

Answer 1

лампочка !!

Кажется, что delete_at сразу корректирует базовую структуру данных, перемещая все элементы справа от удаленного элемента. Массив больше похож на связанный список, чем на массив. Таким образом, «следующий» элемент (здесь «30») теперь arr [1] (который уже обработан итератором), и когда итератор увеличивается до arr [2], он видит «40». arr [3] возвращает nil, и puts, кажется, ничего не делает с nil.

Answer 2

посмотреть на: https://github.com/ruby/ruby/blob/ca6b174078fa15f33655be704d9409fdbc4f9929/include/ruby/intern.h

https://github.com/ruby/ruby/blob/ca6b174078fa15f33655be704d9409fdbc4f9929/enumerator.c

https://github.com/ruby/ruby/blob/ca6b174078fa15f33655be704d9409fdbc4f9929/array.c

каждый дает нумератор и with_index работает с интервьюером.

Когда вы достигаете элемента 20, вы его распечатываете, а после этого вы удаляете его, и в этот момент Ruby эффективно сдвигает все элементы массива. Теперь переписчик, который опирается на массив подхватывает следующий элемент, который 40, потому что все получили сдвинуты вниз (30 был скопирован 20, 40 был скопирован 30 и массив был изменен)

взглянуть на: https://github.com/ruby/ruby/blob/ca6b174078fa15f33655be704d9409fdbc4f9929/array.c#L3023 Здесь происходит волшебство перемещения элементов через memmove.

Answer 3

Давайте шаг через него:

arr = [10, 20, 30, 40] 
enum0 = arr.each 
    #=> #<Enumerator: [10, 20, 30, 40]:each> 
enum1 = enum0.with_index 
    #=> #<Enumerator: #<Enumerator: [10, 20, 30, 40]:each>:with_index> 

Мы можем увидеть содержимое enum1 путем преобразования его в массив:

enum1.to_a 
    #=> [[10, 0], [20, 1], [30, 2], [40, 3]] 

Это говорит нам о том, что Enumerator#each (который будет вызывать Array#each) будет проходить четыре элемента перечислителя enum1 в блок, присваивая их по очереди блочным переменным. Первый:

elmt, i = enum1.next 
    #=> [10, 0] 
puts elmt, i 
    # 10 
    # 0 
elmt == 20 
    #=> false 

так arr.delete_at(i) не выполняется.

Ни arr, ни enum1 были изменены:

arr 
    #=> [10, 20, 30, 40] 
enum1.to_a 
    #=> [[10, 0], [20, 1], [30, 2], [40, 3]] 

each Сейчас проходит следующий элемент enum1 в блок:

elmt, i = enum1.next 
    #=> [20, 1] 
elmt == 20 
    #=> true 

так мы выполняем:

arr.delete_at(i) 
    #=> [10, 20, 30, 40].delete_at(1) 
    #=> 20 
arr 
    #=> [10, 30, 40] 
enum1.to_a 
    #=> [[10, 0], [30, 1], [40, 2]] 

Ач ! Таким образом, счетчик был изменен, а также arr. Это имеет смысл, потому что, когда создается счетчик, устанавливается ссылка на исходный приемник вместе с правилами для того, что с ним нужно делать. Поэтому изменения в ресивере будут влиять на счетчик.

Мы можем использовать Enumerator#peek, чтобы посмотреть, что будет следующий элемент enum1, что each будет проходить в блок:

enum1.peek 
    #=> [40, 2] 

Таким образом, вы видите, что each переходит к следующему индексированной позиции, не обращая внимания на то, что предыдущий элемент удален, что приводит к тому, что более поздние элементы сдвигаются на одну позицию, в результате чего each пропускает [30,1].

elmt, i = enum1.next 
    #=> [40, 2] 
elmt == 20 
    #=> false 
arr 
    #=> [10, 30, 40] 
enum1.to_a 
    #=> [[10, 0], [30, 1], [40, 2]] 

На данный момент each достигает конца счетчику, так что работа закончена. Поэтому возвращает оригинальный приемник, arr, но который был изменен, так что мы получаем:

[10, 30, 40] 

Лучший пример может быть:

arr = [10, 20, 20, 40] 

где:

[10, 20, 40] 

будет вернулся.