Założyć element z przodu tablicy w Ruby

Question

Nawet pochodzących z javascript wygląda to okropne dla mnie:

irb 
>> a = ['a', 'b', 'c'] 
=> ["a", "b", "c"] 
>> a.unshift(a.delete('c')) 
=> ["c", "a", "b"] 

Czy jest bardziej czytelny sposób umieszczenie elementu do przedniej tablicy?

Edit mój rzeczywisty kod:

if @admin_users.include?(current_user) 
    @admin_users.unshift(@admin_users.delete(current_user)) 
end 

Answer 1

To jest trudniejsze problemem niż to wydaje się. I zdefiniowano następujące testy:

describe Array do 
    describe '.promote' do 
    subject(:array) { [1, 2, 3] } 

    it { expect(array.promote(2)).to eq [2, 1, 3] } 
    it { expect(array.promote(3)).to eq [3, 1, 2] } 
    it { expect(array.promote(4)).to eq [1, 2, 3] } 
    it { expect((array + array).promote(2)).to eq [2, 1, 3, 1, 2, 3] } 
    end 
end 

sort_by proponowany przez @Duopixel jest elegancki, ale produkuje [3, 2, 1] dla drugiego testu.

class Array 
    def promote(promoted_element) 
    sort_by { |element| element == promoted_element ? 0 : 1 } 
    end 
end 

@tadman wykorzystuje delete, ale ta usuwa wszystkie elementy pasujące, więc wyjście czwartego testu jest [2, 1, 3, 1, 3].

class Array 
    def promote(promoted_element) 
    if (found = delete(promoted_element)) 
     unshift(found) 
    end 

    self 
    end 
end 

Próbowałem za pomocą:

class Array 
    def promote(promoted_element) 
    return self unless (found = delete_at(find_index(promoted_element))) 
    unshift(found) 
    end 
end 

Ale udało trzecią próbę ponieważ delete_at nie może obsłużyć nil. Wreszcie zdecydowałem się na:

class Array 
    def promote(promoted_element) 
    return self unless (found_index = find_index(promoted_element)) 
    unshift(delete_at(found_index)) 
    end 
end 

Kto wiedział prosty pomysł jak promote może być tak skomplikowane?

Answer 2

Może Array#rotate będzie pracować dla Ciebie:

['a', 'b', 'c'].rotate(-1) 
#=> ["c", "a", "b"] 

Answer 3

Jeśli przez „elegancki” znaczy bardziej czytelny nawet kosztem będącego nietypowych , zawsze możesz napisać własną metodę, która zwiększa Array:

class Array 
    def promote(value) 
    if (found = delete(value)) 
     unshift(found) 
    end 

    self 
    end 
end 

a = %w[ a b c ] 
a.promote('c') 
# => ["c", "a", "b"] 
a.promote('x') 
# => ["c", "a", "b"] 

Należy pamiętać, że będzie to tylko zmiana położenia pojedynczego wystąpienia wartości. Jeśli w tablicy jest kilka, kolejne prawdopodobnie nie zostaną przeniesione, dopóki pierwsza nie zostanie usunięta.

Answer 4

Może wygląda to lepiej dla Ciebie:

a.insert(0, a.delete('c')) 

Answer 5

W końcu uznałem to najbardziej czytelny alternatywą dla ruchu elementu do przodu:

if @admin_users.include?(current_user) 
    @admin_users.sort_by{|admin| admin == current_user ? 0 : 1} 
end 

Answer 6

Jeśli wszystkie elementy w tablicy są unikalne można użyć tablicy arytmetyki:

> a = ['a', 'b', 'c'] 
=> ["a", "b", "c"] 
> a -= "c" 
=> ["a", "b"] 
> a = ["c"] + a 
=> ["c", "a", "b"] 

Answer 7

Dodawanie moje dwa centy:

array.select{ |item| <condition> } | array 

Plusy:

• można przenieść kilka pozycji z przodu tablicy

Minusy:

• Spowoduje to usunięcie wszystkich duplikatów, chyba że jest to pożądany wynik.

przykład - przenieść wszystkie nieparzystych numery do przodu (i jednocześnie macierz unikalne):

data = [1, 2, 3, 4, 3, 5, 1] 
data.select{ |item| item.odd? } | data 
# Short version: 
data.select(&:odd?) | data 

Wynik:

[1, 3, 5, 2, 4] 

Answer 8

inny sposób:

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

[b] + (a - [b]) 
=> [3, 1, 2, 4]