Volver a colocar un elemento en la parte delantera de una matriz en Ruby

Question

Incluso viniendo de Javascript esto parece atroz a mí:

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

¿Existe una manera más legible la colocación de un elemento a la parte delantera de una matriz?

Editar mi código real:

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

Answer 1

Este es un problema más complicado de lo parece. He definido las siguientes pruebas:

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 propuesto por @Duopixel es elegante pero produce [3, 2, 1] para la segunda prueba.

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

@tadman utiliza delete, pero esto elimina todos los elementos coincidentes, por lo que la salida de la cuarta prueba es [2, 1, 3, 1, 3].

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

    self 
    end 
end 

He intentado utilizar:

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

Pero esto falló la tercera prueba, ya que no puede manejar delete_at nula. Por último, que se establecieron en:

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

¿Quién sabía que una idea tan simple como promote podría ser tan complicado?

Answer 2

Tal Array#rotate iba a funcionar para usted:

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

Answer 3

Si por "elegante" que quiere decir más fácil de leer, incluso a expensas de ser no estándar , siempre puedes escribir tu propio método que mejore 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"] 

Tenga en cuenta que esto solo cambiaría la posición de una sola instancia de un valor. Si hay varios en el conjunto, los siguientes probablemente no se moverán hasta que se elimine el primero.

Answer 4

Tal vez esto se ve mejor a usted:

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

Answer 5

Al final he considerado esta la alternativa más legible para mover un elemento a la parte delantera:

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

Answer 6

Si todos los elementos de la matriz son únicos puede utilizar matriz aritmética:

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

Answer 7

Adición de mis dos centavos:

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

Pros:

• puede mover varios elementos al frente de la matriz

Contras:

• Esto eliminará todos los duplicados a menos que sea el resultado deseado.

Ejemplo - Mover todos impares los números en la parte delantera (y hacer gama única):

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

Resultado:

[1, 3, 5, 2, 4] 

Answer 8

Otra forma:

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

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