¿Dónde colocar métodos privados en Ruby?

La mayoría de los blogs, tutoriales o libros tienen métodos privados al final de cualquier clase / módulo. ¿Es esta la mejor práctica?

Me parece más conveniente tener métodos privados cuando sea necesario. Por ejemplo:

public
def my_method
  # do something
  minion_method
end

private
def minion_method
  # do something
end

public
def next_method
end

De esta manera, encuentro el código más legible en lugar de desplazarme hacia arriba y hacia abajo continuamente, lo cual es muy irritante.

¿Hay algo terriblemente mal en este enfoque? ¿Tener métodos privados en la parte inferior no es solo una mejor práctica y algo más?

La mejor práctica desde mi punto de vista es ir secuencialmente y declarar sus métodos sin mantener la privacidad en el punto de vista.

Al final, puede convertir cualquier método en privado simplemente agregando: private :xmethod

Ejemplo:

class Example
 def xmethod
 end

 def ymethod
 end

 def zmethod 
 end

 private :xmethod, :zmethod

end

¿Esto justifica tu pregunta?

También existe la opción de anteponer privatea la definición del método desde Ruby 2.1.

class Example

 def xmethod
 end

 private def ymethod
 end

 private def zmethod 
 end

end

Si observa la definición, sabrá instantáneamente si un método es privado, sin importar en qué parte del archivo esté definido. Es un poco más de escritura (si no se autocompleta) y no todos sus defs estarán bien alineados.

Como otros ya han señalado, la convención es poner los métodos privados al final, bajo una clase privada. Sin embargo, probablemente también debería saber que muchos programadores usan un método de doble sangría (4 espacios en lugar de 2) para esto. La razón es que muchas veces no verá "privado" en su editor de texto y asumirá que podría ser público. Vea a continuación para ver una ilustración:

class FooBar

  def some_public_method
  end

  def another_public_method
  end

private

    def some_private_method
    end

    def another_private method
    end

end

Este método debería evitar que tengas que desplazarte hacia arriba y hacia abajo y hará que otros programadores se sientan más cómodos con tu código.

Creo que los métodos públicos son una especie de interfaz del objeto, y es lógico colocarlos en el lugar más destacado, es decir, en la parte superior del archivo.

No es necesario poner publico por privateencima de cada método. Por lo general, pongo todos mis métodos privados al final de mi clase. Además, no es necesario que lo diga explícitamente publicque los métodos son públicos de forma predeterminada. Por ejemplo:

class FooBar

  def some_public_method
  end

  def another_public_method
  end

private

  def some_private_method
  end

  def another_private method
  end

end

Vengo de Java Background y odio tener que desplazarme para ver el tipo de método. Creo que es una locura que no se pueda especificar la visibilidad del método por método sin fealdad. Así que terminé poniendo un comentario #privateantes de cada método de succión y luego declarando private :....

No me gusta tener que especificar público o privado para cada método. Poner todos los métodos privados en la parte inferior me permite tener una sola instancia de "privado" por archivo. Supongo que es cuestión de gustos.

Un estilo es a métodos de grupo juntos para que utilice sólo privatey protecteduna vez por clase como máximo. Otro estilo es especificar la visibilidad justo después de la definición del método:

class Example
  def my_private_method
  end
  private :my_private_method

  def my_public_method
  end
end

A partir de Ruby 2.1.0 defdevuelve el nombre del método como símbolo, por lo que es posible un estilo más simplificado:

class Example
  private def my_private_method
  end

  def my_public_method
  end

  protected def my_protected_method
  end

  private_class_method def self.my_private_class_method
  end
end

(Tenga en cuenta que usamos private_class_methodpara métodos de clase; de ​​lo contrario, obtendríamos NameError: undefined methodya que privateespera un método de instancia. Incluso cuando se usa como una macro como en el ejemplo original, solo afecta la visibilidad de los métodos de instancia).

Me gusta más este estilo de visibilidad en línea, ya que le permite organizar los métodos como desee. Disminuye el riesgo de agregar un nuevo método en el lugar equivocado y hacerlo privado inadvertidamente.

En cuanto a la sintaxis del método de clase, puede manejarlo de esta manera:

class Example
  private def my_private_method
  end

  class << self
    private def my_private_class_method
    end
  end
end

Dennis tenía la respuesta perfecta, es decir, cuando usa ruby> = 2.1, simplemente prefija la definición con privado (o protegido, público)

Pero creo que ahora también es posible usar privado como un bloque como en:

private begin
   def foo
   end
   def bar
   end
end

def zip
end

Generalmente ordeno mis métodos de la siguiente manera:

1. Constructor
2. Otros métodos públicos, en orden alfabético
3. private, escrito solo una vez
4. Métodos privados, en orden alfabético

Utilizo funciones de "ir a la definición" en mi editor para que esto no implique mucho desplazamiento y, en cualquier caso, si la clase es lo suficientemente grande como para que el desplazamiento se vuelva problemático, probablemente debería dividirse en varias clases.