Ruby dizisinin son öğesi hariç tümü

Diyelim ki Ruby dizim var

a = [1, 2, 3, 4]

İlk öğe hariç hepsini istiyorum, yazabilirim a.drop(1), bu harika. Son öğe hariç hepsini istiyorsam , sadece bu şekilde düşünebilirim

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

ancak bunların hiçbiri kullanmak kadar temiz görünmüyor drop. Eksik olduğum başka yerleşik yollar var mı?

Belki ...

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

veya

a.take 3

veya

a.first 3

veya

a.pop

Sonuncuyu döndürür ve diziyi ondan önce her şeyle birlikte bırakır

veya bilgisayarın akşam yemeği için çalışmasını sağlayın:

a.reverse.drop(1).reverse

veya

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]

Meraktan, neden sevmiyorsun a[0...-1]? Dizinin bir dilimini almak istiyorsunuz, böylece dilim işleci deyimsel bir seçim gibi görünüyor.

Ancak bunu her yerde çağırmanız gerekiyorsa, Array sınıfına DigitalRoss'un önerdiği gibi her zaman daha kolay bir ada sahip bir yöntem ekleme seçeneğiniz vardır. Belki de şöyle:

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

Başka bir harika hile

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

Bir pop()dizide bir işlem gerçekleştirmek istiyorsanız (son silinen öğenin silinmesine neden olur), ancak açılan bir öğe yerine diziyi elde etmekle ilgileniyorsanız şunları kullanabilirsiniz tap(&:pop):

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

Bunu şöyle yaparım:

my_array[0..-2]

Damla yönteminin kendisini arttırmaya ne dersiniz, örneğin böyle?

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

Ardından, öğeleri sondan kaldırmak için negatif bir boyut kullanabilirsiniz, şöyle:

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

a[0...-1]en iyi yol gibi görünüyor. Dizi dilimleme sözdizimi tam olarak bu amaçla oluşturuldu ...

Alternatif olarak, diziyi yerinde değiştirmenin sakıncası yoksa, sadece şunu arayabilirsiniz a.pop:

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

Son elemandan bir satırda geri kalanı geri dönmek için

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

Cidden olsa da,

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

Bu şekilde:

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

Ancak bunun nasıl çalıştığını açıklayalım:

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

Sonraki örnek, 0 konumdan sonuncuya kadar tüm kayıtları döndürür

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

Sonraki örnek kayıtları 1 konumdan sonuncuya döndürür

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

Ve burada ihtiyacınız olan şey var. Sonraki örnek, kayıtları 0 konumundan son 1'e döndürür

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

"Al" denediniz mi

a.take(3) 

Cevap: a.τwτ ama önce Pyper'ı yüklemelisin ...

Pyper intro: Lispy'ı biliyor carve dizinin cdr"ilk" ve "geri kalanını" döndürüyor musunuz ? Sadece seninki gibi ihtiyaçlar için, bu Lispy mekanizmasının bir uzantısını yaptım. Denir pyperve aynı zamanda 2., 2., 3., dinlenme, 3d ve son olarak, son vb. Hariç her şeye erişmenizi sağlar. caar, cadr, cdadarvb Lisp'te bilinmektedir:

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

ve son olarak, sorunuzun cevabı:

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

Fazlası var:

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

bileşimler:

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

Orada sadece daha komut karakterler de vardır a..f, u..zve 0..9en önemlisi, mharita, yani:

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

Ancak diğer komut karakterleri çok sıcak ve şu anda kullanımı çok kolay değil.

Bu, orijinalin son öğeleri hariç tümü ile yeni bir dizi oluşturur:

ary2 = ary.dup
ary2.pop

Birkaç kişinin #pop kullanılmasını önerdiğini unutmayın. Diziyi yerinde değiştirmeye hazırsanız, sorun değil. Bununla sorun olmazsa, önce bu örnekte olduğu gibi diziyi çoğaltın.

Sık sık kendimi bir dizinin son n öğesi dışında hepsini isterken bulurum. Bunu diğer çözümlerden daha okunabilir bir şekilde bulabilmek için kendi işlevimi geliştirdim:

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

Şimdi aşağıdakileri yapabilirsiniz:

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 için kasıtlı olarak izin verdim, böylece arayan bu yöntemi nasıl kullandıklarından sorumludur. Bu yaklaşımın yorumlarını / eleştirilerini duymak isterim.

a = [1,2,3,4]

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