Все, кроме последнего элемента массива Ruby

Скажем, у меня есть массив Ruby

a = [1, 2, 3, 4]

Если мне нужно все, кроме первого, я могу написать a.drop(1), и это здорово. Если я хочу все, кроме последнего , я могу думать только об этом

a[0..-2]   # or
a[0...-1]

но ни один из них не кажется таким чистым, как использование drop. Какие-либо другие встроенные способы мне не хватает?

Возможно ...

a = t               # => [1, 2, 3, 4]
a.first a.size - 1  # => [1, 2, 3]

или

a.take 3

или

a.first 3

или

a.pop

который вернет последнее и оставит массив со всем до него

или заставьте компьютер работать на обед:

a.reverse.drop(1).reverse

или

class Array
  def clip n=1
    take size - n
  end
end
a          # => [1, 2, 3, 4]
a.clip     # => [1, 2, 3]
a = a + a  # => [1, 2, 3, 4, 1, 2, 3, 4]
a.clip 2   # => [1, 2, 3, 4, 1, 2]

Из любопытства, почему тебе не нравится a[0...-1]? Вы хотите получить срез массива, поэтому оператор среза кажется идиоматическим выбором.

Но если вам нужно вызвать это повсюду, у вас всегда есть возможность добавить метод с более понятным именем в класс Array, как предлагал DigitalRoss. Возможно так:

class Array
    def drop_last
        self[0...-1]
    end
end

Еще один крутой трюк

>> *a, b = [1,2,3]
=> [1, 2, 3]
>> a
=> [1, 2]
>> b
=> 3

Если вы хотите выполнить pop()операцию с массивом (что приведет к удалению последнего элемента), но вы заинтересованы в получении массива вместо всплывающего элемента, вы можете использовать tap(&:pop):

> arr = [1, 2, 3, 4, 5]
> arr.pop
=> 5
> arr
=> [1, 2, 3, 4]
> arr.tap(&:pop)
=> [1, 2, 3]

Я так делаю:

my_array[0..-2]

Как насчет расширения самого метода drop, например, вот так?

class Array
  def drop(n)
    n < 0 ? self[0...n] : super
  end
end

Затем вы можете использовать отрицательный размер, чтобы удалить элементы с конца, например:

[1, 2, 3, 4].drop(-1) #=> [1, 2, 3]
[1, 2, 3, 4].drop(-2) #=> [1, 2]

a[0...-1]кажется лучшим способом. Синтаксис нарезки массива был создан именно для этой цели ...

В качестве альтернативы, если вы не возражаете против изменения массива на месте, вы можете просто вызвать a.pop:

>> a = [1, 2, 3, 4]
>> a.pop
>> a
=> [1, 2, 3]

Чтобы избавиться от последнего элемента в одной строке с возвращением остатка

[1, 2, 4, 5, 6].reverse.drop(1).reverse

Если серьезно,

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

Это способ:

[1,2,3,4,5][0..-1-1]

Но давайте объясним, как это работает:

a = [1,2,3,4,5]

Следующий пример вернет все записи, от 0 позиции до последней.

a[0..-1]
=> [1, 2, 3, 4, 5]

В следующем примере будут возвращены записи с 1 позиции до последней.

a[1..-1]
=> [2, 3, 4, 5]

И вот то, что вам нужно. В следующем примере будут возвращены записи с позиции 0 до последней-1.

a[0..-1-1]
=> [1, 2, 3, 4]

Вы пробовали "взять"

a.take(3) 

Ответ: a.τwτ но сначала нужно установить Pyper ...

Пайпер интро: знаете ли вы Lispy carи cdrвозвращение «первого» и «отдых» из массива? Просто для таких же нужд я сделал расширение этого Lispy-механизма. Он называется pyper, и он позволяет вам получить доступ также к 2-му, отдыху со 2-го, 3-го, отдыху из 3-го, а также к последнему, ко всему, кроме последнего и т. Д. Об этом нечего было бы писать, но он также позволяет составлять буквы, как и caar, cadrи cdadarт.д., известные из Lisp:

# First, gem install pyper
require 'pyper'
include Pyper
a = %w/lorem ipsum dolor sit amet/
# To avoid confusion with other methods, and also because it resembles a rain gutter,
# Greek letter τ is used to delimit Pyper methods:
a.τaτ #=> "lorem"
a.τdτ #=> ["ipsum", "dolor", "sit", "amet"]
a.τbτ #=> "ipsum"
a.τeτ #=> ["dolor", "sit", "amet"]
a.τcτ #=> "dolor" (3rd)
a.τzτ #=> "amet" (last)
a.τyτ #=> "sit" (2nd from the end)
a.τxτ #=> "dolor" (3rd from the end)

и, наконец, ответ на ваш вопрос:

a.τwτ #=> ["lorem", "ipsum", "dolor", "sit"] (all except last)

Есть еще:

a.τuτ #=> ["lorem", "ipsum", "dolor"] (all except last 2)
a.τ1τ #=> ["lorem", "ipsum"] (first 2)
a.τ8τ #=> (last 2)
a.τ7τ #=> (last 3)

Композиции:

a.τwydτ #=> "olor" (all except 1st letter of the last word of all-except-last array)

Также есть больше командных символов, чем просто a..f, u..zи 0..9, что особенно важно m, означает карту:

a.τwmbτ #=> ["o", "p", "o", "i"] (second letters of all-except-last array)

Но другие командные символы слишком популярны и не очень просты в использовании на данный момент.

Это создает новый массив со всеми элементами оригинала, кроме последних:

ary2 = ary.dup
ary2.pop

Обратите внимание, что некоторые другие предложили использовать #pop. Если вы можете изменить массив на месте, ничего страшного. Если вас это не устраивает, сначала скопируйте массив, как в этом примере.

Я часто обнаруживаю, что мне нужны все, кроме последних n элементов массива. Я настроил свою собственную функцию, чтобы сделать это более читаемым, чем другие решения:

class Array
  def all_but_the_last(n)
    self.first(self.size - n)
  end
end

Теперь вы можете сделать следующее:

arr = ["One", "Two", "Three", "Four", "Five"]
# => ["One", "Two", "Three", "Four", "Five"]

arr.all_but_the_last(1)
# => ["One", "Two", "Three", "Four"]

arr.all_but_the_last(3)
# => ["One", "Two"]

arr.all_but_the_last(5)
# => []

arr.all_but_the_last(6)
# ArgumentError: negative array size

Я намеренно допустил ошибку ArgumentError, чтобы вызывающая сторона отвечала за использование этого метода. Я хотел бы услышать комментарии / критику этого подхода.

a = [1,2,3,4]

a[0..(a.length - 2)]
=> [1,2,3]