“Hey, o que é que o ||= significa no seu código de ruby?”

In my first blog post as a programmer, I thought it would be appropriate to explain one of the questions that I was asked during my first day at Flatiron School. Esta é uma pergunta que eu tinha vindo acima cerca de um mês atrás e um que me levou para baixo um buraco de coelho dos fóruns de ruby e posts reddit (eu vou salvar-lhe o problema e ligar algumas das fontes melhores no fundo deste post).

a controvérsia por trás de” Double-pipe equals ” está centrada em torno de como o operador deve ser traduzido, mas eu gostaria de focar este post sobre as aplicações que eu encontrei para ele. Então, o que exatamente faz ||=? Minha própria definição é que: “duplo-tubo é igual a” é um operador que atribui um valor muito parecido com = ou o nosso clássico operador de atribuição, mas só vai concluir a atribuição se o lado esquerdo da nossa operação retorna false ou nil.Deixa-me demonstrar.

a = nil
b = 4
a = b #=> 4
a #=> 4

Com a definido para nil, é fácil ver que a definição de um “igual” para b usando o clássico operador de atribuição de retorno com o valor de 4. Mas e se usássemos “duplo cachimbo igual” em vez disso?

a = nil
b = 4
a ||= b #=> 4
a #=> 4

neste caso, obtemos o mesmo resultado. Quando a está definido para nil (ou qualquer coisa que avalia false||= operador funciona da mesma forma que = seria. Vamos olhar para um exemplo onde a é dado um valor “truthy”.

a = 2
b = 4
a ||= b #=> 2
a #=> 2

No exemplo acima, a retém o seu valor original, apesar de ter sido operado através do nosso”Double-pipe equals”. Isto acontece porque o || age como um “circuito” neste método. Como Peter Cooper explica,

Se o lado esquerdo da comparação for verdadeiro, não há necessidade de verificar o lado direito.

Quando ruby viu que a já foi atribuído o valor de 2, ele parou de executar o nosso código.

Onde eu encontrei este tipo de atribuição condicional mais útil é na iteração. Vamos iterar através de uma variedade de frutos populares, usando o nosso método ||= para atribuir cada uma das cadeias a a.

a = nil
array = 
array.each do |fruit|
a ||= fruit
end #=> a #=> "apple"

podemos ver que, depois de nossa iteração, a é atribuído a primeira seqüência de caracteres em nossa matriz, "apple” . Depois de atorna-se"apple”, o nosso “Double-pipe equals” não permitirá que nada à direita dele reassinate a nossa variável.

embora ruby tenha métodos que podem retornar o primeiro elemento de um array sem iteração, às vezes pode ser útil para controlar se uma variável foi ou não atribuída com um valor “truthy”. Abaixo está um excerto de código de um dos meus laboratórios recentes onde encontrei ||= particularmente útil.

class School attr_reader :roster def initialize(name) 
@name = name 
@roster = {} 
end def add_student(name, grade)
@roster ||= 
@roster << name 
endend

Aqui, eu tenho definido uma classe, School, juntamente com um par de métodos. A coisa chave a entender é que ao chamar roster em uma instância do meu School classe, eu estou olhando para devolver minha lista de alunos como uma hash de notas apontando para uma série de alunos associados a cada grau.

permite instanciar um exemplo de escola e povoar alguns alunos.

metro = School.new("Metro High")
metro.add_student("Jared", 9)
metro.roster #=> {9=>}metro.add_student("Graham", 9)
metro.roster #=> {9=>}

Para adicionar um aluno para o roster minha School exemplo, eu tenho que passar o add_student método name e uma grade. No entanto, podemos ver que quando eu adicionei "Graham” e o seu correspondente grau, 9, o seu nome foi adicionado à matriz existente que foi criado quando eu adicionei "Jared”. Esta é a magia de ||=. Neste caso, o “duplo-tubo é igual a” operador reconhecido que um grau chave já foi adicionado e

Tinha o meu add_student método = em vez de ||= Eu teria substituído o meu aluno, a entrada de "Jared” quando eu adicionei outro aluno na classe 9 .