Programación Orientada a Objetos en Ruby Comenzando la creación de nuestra clase

Reduciendo la definición de una clase:
Forma 1:

class Persona  
  def initialize(name) #Constructor
    @name = name #Variable de instancia se inicializa con el parametro en el constructor
  end

  def name #Getter
    @name
  end

  def name=(name) #Setter
     @name = name
     self
  end
end

Forma 2:

class Persona
  attr_accessor(:name)  # Genera getter y setter

  def initialize(name)
    @name = name
  end
end

Forma 3:

class Persona < Struct.new(:name) #Struct declara el constructor, getters y setters
end

Forma 4 en una linea:

Persona = Struct.new(:name)

POO en Ruby

• Un objeto es un a colección de propiedades y métodos.
• Las propiedades de un objeto son valores que están asociados a un objeto
• En ruby generalmente las propiedades son llamadas variables de instancia,
  en código estas variables se distinguen por llevar un “@” al inicializar
  el nombre de la variable ej: @mi_nombre
• Variables de instancia son identificadores que le pertenecen al objeto,
  no a la clase por eso se llaman de “instancia”
• Estas variables no están disponibles para (leer / modificar) fuera de la definición de la clase, para ello se deben utilizar métodos accesores
• Los métodos accesores son de dos tipos, para leer y para escribir; aunque en ruby
  no se identifican de la forma que se hace en otros programas con "SET/GET"
  sino que y en ruby (geters/seters) se ven iguales al nombre de la propiedad y la
  forma como se distinguen el uno del otro es que el método accesor “set” tiene el
  operador igual “=”.
• Hay métodos específicos para acceder a estas funcionalidades como (attr_accessor, attr_reader y attr_writer) y el método attr_accesor que realiza simultáneamente las funciones de escritura y lectura.

Conceptos extraídos de:

• http://rubytutorial.wikidot.com/clases-objetos
• https://es.wikibooks.org/wiki/Programación_en_Ruby/Programación_orientada_a_objetos
• http://rubysur.org/aprende.a.programar/capitulos/clases.html
• https://www.ruby-lang.org/es/documentation/quickstart/3/

La verdad el profesor explica como si estuviera contrarreloj, todo rápido y por encima, apenas aborda detalles de los conceptos, pero no puedo negar que si se aprende, he aprendido varias cosas, aunque la verdad, no como quisiera 😥
Nada es perfecto 😒

Creando clases

• class → para declarar una clase.
• def → es para definir los métodos.
• initialize → es un método especial en Ruby para programación orientada a objeto que hace del constructor. Aquí se define se recibe o no recibe parámetros.
• @variable → Para declarar variables de instancia se utiliza el arroba
• self → esta hace referencia a la misma instancia, para que está forma podamos encadenar varios llamados.

class ClassName
    def initialize(parametros)
        @name = parametros
    end
end

En Ruby todas las instrucciones de código retornan algo, por eso no hay que utilizar la palabra return. Así que si dentro de los métodos no se específica el return, Ruby entiende que se va returnar el valor de la última instrucción dentro de ese bloque de código.

class Persona
    # Para declarar Métodos de clases
    def self.suggested_names
        ["Pepe","Pepito","Sutano"]
    end

    # constructor
    def initialize(name, age)
        @name = name
        @age = age
    end

    #métodos de instancia
    def name
        @name
    end

    def age
        @age
    end

    # persona.name = "pepe"
    def name=(name)
        @name = name
        self
    end

    def age=(age)
        @age = age
        self
    end
end

persona = Persona.new("pepe", 14)
puts "#{persona.name} tiene #{persona.age} años."

# si queremos llamar al método que creamos, llamamos a la clase
puts "Nombre sugeridos: \n#{Persona.suggested_names}"

Ruby gracias a la metaprogramación nos ofrece varios macros y varias utilidades para que no tengamos que escribir tanto código.

• attr_accessor → es un macro que utilizamos para declarar propiedades de una clase.

#Class reducido primera forma
class Persona_2
    attr_accessor :name, :age

    # Para declarar Métodos de clases
    def self.suggested_names
        ["Pepe","Pepito","Sutano"]
    end

    # constructor
    def initialize(name, age)
        @name = name
        @age = age
    end
end

persona_2 = Persona_2.new("Carlos", 19)
puts "#{persona_2.name} tiene #{persona_2.age} años."

#Class reducido segunda forma
class Persona_3 < Struct.new(:name, :age)
    # Para declarar Métodos de clases
    def self.suggested_names
        ["Pepe","Pepito","Sutano"]
    end
end

persona_3 = Persona_3.new("Julian", 33)
puts "#{persona_3.name} tiene #{persona_3.age} años."

**POO clases y objetos **

• Las clases y los objetos son los conceptos más importantes de la Programación Orientada por Objetos (POO), y están fuertemente relacionados. Los objetos se crean a partir de clases, y las clases sirven como plantillas para crear objetos. A los objetos también se les llama instancias de clase.
  -En otros lenguajes el comportamiento de Initialize es comúnmente conocido como el “método constructor”, dicho método suele ejecutarse cuando creamos un objeto de una clase y mediante el cual inicializamos los valores que el objeto tendrá. En Ruby, siempre que llamemos al método new en una clase, la clase creará una nueva instancia de sí misma. Entonces, internamente, invocará el método initialize en el nuevo objeto. Esta característica nos permite pasar todos los argumentos mediante “.new” para que la clase disponga de estos.
  • Debemos tener en cuenta que cuando hacemos tests deberemos simular dicho comportamiento.
  • Cuando utilizamos el método “return” al interior del método “Initialize”, “return” es ignorado.

Conceptos extraídos

• http://ruby-for-beginners.rubymonstas.org/writing_classes/initializers.
• https://www.vikingcodeschool.com/professional-development-with-ruby/best-practices-for-working-with-
• https://dev.to/leandrogs/should-i-test-initialize

Hola a todos,por favor alguien me podría explicar el uso de ‘self’ dentro de un metodo de instancia,gracias.

Jugando un poco con el código:

class Persona

#:name y :age permite generar los setter y getters automáticamente

  attr_accessor :name, :age


#Método que entrega nombre sugeridos
  def self.suggested_name
    ["Pepe", " Pedro", "Bodoque"]
  end

#creamos metodo constructor
  def initialize (name, age)
    #variables de instacia
    @name=name
    @age=age
  end
end
#método getter para name
  # def name
  #   return @name
  # end
  #
  # #method get for age
  # def age
  #   return @age
  # end
  #
  # #method for edit the name
  # def name= (name)
  #   @name=name
  #   self
  # end
  #
  # def age =(age)
  #   @age=age
  #   self

#creo una persona
persona1= Persona.new("Pedro",25)

#imprimo el nombre
puts persona1.name

puts "\nahora el nuevo nombre de la persona es: "

#edito el nombre
persona1.name="\ncarlos"

#imprimo nuevamente el nombre
puts persona1.name

persona1.age="32"
puts persona1.age

Ok queria decir que el profesor hasta ahora ha sido muy malo, va muy rapido y no se detiene a explicar nada. pues bien me dure casi un dia entero porque al momento de correr el codigo en consola, ocurria “poo.rb:23: syntax error, unexpected `end’, expecting end-of-input” este error me parecio bastante curioso porque si existia el end al final ya que el trabajo era bastante semejante a lo que habia hecho el profesor, lo hice de nuevo y realmente me quede en este punto porque no podia pasar, busque en stackoverflow y nada, realmente no encontre solucion en la web, luego me percate que

def name=(name)
        @name = name
        self

no estaba igual a

 def age = (age)
        @age = age
        self

la diferencia era que el def age(espacio)=(age)
estaba ese espacio y era el que botaba el error. realmente lo que va del curso no se porque ocurre eso y el profesor eso no lo ha explicado, honestamente que mal que uno se encuentre en esa situacion, porque problemas de logica y de pronto cosas que a uno le toquen investigar vaya y venga pero un problema de sintaxis porque al profesor no se le ha dado la gana de explicar eso… creo que en platzi deberian verificar estar cosas porque los hace quedar bastante mal. Y no lo digo por rabia, he hecho mas de 30 cursos y hasta el momento este es el que he sentido con mas vacios. no se si mejore, porque igual lo seguire, pero les dejo la inquietud a ver si depronto lo mejoran.

Cuando vi el struct derrepente pense en ruby con skin de c++😲😲😲

Clases con metodos

Tambien puedes ocupar attr_writters o attr_readers dependiendo del caso.

La vertdad… no se entiende nada. y eso que vengo de hacer el curso basico de JS. Se que es un constructor y demas. pero de repente se usan terminos que ni se explican. Que es un getter o un setter. Porque tengo que usarlos. Lo del self no se explica. que anda pasando por platzi???

usando attributte accessor:

require "pry"

# como hacer programacion orientada a objetos

class Persona
    
    # La implementación de un macro permite no usar getters y setters
    # se declaran las propiedades de esa clae, se le envían simbolos de como usar los atributos
    # este genera los getters y setters de forma automática
    attr_accessor :name, :age
    
    # metodos de clase: 
    def self.suggested_names
        # retorna un arreglo con sugerencias para nombres en la clase
        ["Pepe", "Pepito", "Sutano"]
    end
    
    # ----------------------------------
    # metodos de instancia: 
    # al ser una clase, se requiere un constructor, en ruby es initialize
    # será un metodo y requiere ser creado usando la palabra reservada def
    def initialize(name, age)
        # para declarar variables de instancia se utiliza el arroba
        # la variable instancia de esta clase se va a inicializar con el parametro que nos pasen en el constructor 
        @name = name
        @age = age
    end

=begin
# he comentado los getter y setter ya que no son necesarios al usar un macro llamado attribute accesor (attr_accessor)     
    # crearemos algunos metodos getters para poder acceder a las propiedades de esta clase.
    # para esto se utiliza la palabra reservada def, y se retorna la propiedad de esta clase.
    #getter
    def name
        # retorno implicito, no se usa palabra return
        # en ruby todas las instrucciones de codigo retornan algo, dentro de los metodos si no se usa return, ruby entiende que se retorna el valor de la ultima instruccion
        @name
    end
    
    def age
        @age
    end
    
    #setter
    # persona.name = "pepe"
    def name=(name)   # el igual = debe ir sin espacios
        @name = name
        self  # self hace referencia a la misma instancia
    end
    
    # Al tener self podemos asignar las propiedades a los objetos de la clase de la siguiente forma:
    # (persona.name = "pepe").age = 7
    # de esta forma se crean las dos cosas en una sola linea
    
    def age=(age)   # el igual = debe ir sin espacios
        @age = age
        self # referencia al mismo objeto
    end
=end
# muchos bloques en ruby necesitan esta palabra reservada (end) para determinar hasta donde van
end


# crearemos una variable de esta clase

# persona(nombre de la variable) = Persona(Nombre de la clase) Nótese la diferencia por la mayuscula
# new es la forma de instanciar un objeto de esta clase, va a llamar al codigo dentro del constructor (initialize)
# el constructor pide que se reciban dos parametros (name, age)
persona = Persona.new("pepe", 14)

puts persona.name
puts persona.age

# si se quiere llamar al método se hace de la siguiente forma:
puts Persona.suggested_names
# persona (si, en minuscula) pertenece a una variable de instancia
# por eso se llama desde la clase usando Persona (con 'P' mayúscula)
binding.pry

En ruby, tiene que estar exactamente unido todo el código, ejemplo:

def age=(age)
        @age = age
        self
    end

No es válido:

def age = (age)

        @age = age

        self

    end 

Para los que se guíen con los archivos que dejan en el material de clase, cuidado con las clases cuyo constructor esta siendo declarado como “initializer”, donde debe ser “initialize”, esto les va a generar errores

no entendía muchos de los comentarios así que hice los míos mucho más especificos para que los puedan entender a quién le pasó lo mismo que a mi:

require "pry"

# como hacer programacion orientada a objetos

class Persona
    
    # metodos de clase: 
    def self.suggested_names
        # retorna un arreglo con sugerencias para nombres en la clase
        ["Pepe", "Pepito", "Sutano"]
    end
    
    # ----------------------------------
    # metodos de instancia: 
    # al ser una clase, se requiere un constructor, en ruby es initialize
    # será un metodo y requiere ser creado usando la palabra reservada def
    def initialize(name, age)
        # para declarar variables de instancia se utiliza el arroba
        # la variable instancia de esta clase se va a inicializar con el parametro que nos pasen en el constructor 
        @name = name
        @age = age
    end
    
    # crearemos algunos metodos getters para poder acceder a las propiedades de esta clase.
    # para esto se utiliza la palabra reservada def, y se retorna la propiedad de esta clase.
    #getter
    def name
        # retorno implicito, no se usa palabra return
        # en ruby todas las instrucciones de codigo retornan algo, dentro de los metodos si no se usa return, ruby entiende que se retorna el valor de la ultima instruccion
        @name
    end
    
    def age
        @age
    end
    
    #setter
    # persona.name = "pepe"
    def name=(name)   # el igual = debe ir sin espacios
        @name = name
        self  # self hace referencia a la misma instancia
    end
    
    # Al tener self podemos asignar las propiedades a los objetos de la clase de la siguiente forma:
    # (persona.name = "pepe").age = 7
    # de esta forma se crean las dos cosas en una sola linea
    
    def age=(age)   # el igual = debe ir sin espacios
        @age = age
        self # referencia al mismo objeto
    end

# muchos bloques en ruby necesitan esta palabra reservada (end) para determinar hasta donde van
end


# crearemos una variable de esta clase

# persona(nombre de la variable) = Persona(Nombre de la clase) Nótese la diferencia por la mayuscula
# new es la forma de instanciar un objeto de esta clase, va a llamar al codigo dentro del constructor (initialize)
# el constructor pide que se reciban dos parametros (name, age)
persona = Persona.new("pepe", 14)

puts persona.name
puts persona.age

# si se quiere llamar al método se hace de la siguiente forma:
puts Persona.suggested_names
# persona (si, en minuscula) pertenece a una variable de instancia
# por eso se llama desde la clase usando Persona (con 'P' mayúscula)
binding.pry

Usando Structs:

require "pry"

# como hacer programacion orientada a objetos

class Persona < Struct.new(:name, :age)

=begin    
# he comentado este bloque de codigo po el uso de Struct en la clase, en la cual ya no se requiere el macro para la creació de las propiedades
# ir a línea 22
    # La implementación de un macro permite no usar getters y setters
    # se declaran las propiedades de esa clae, se le envían simbolos de como usar los atributos<code>
    # este genera los getters y setters de forma automática
    attr_accessor :name, :age
=end    
    
    # metodos de clase: 
    def self.suggested_names
        # retorna un arreglo con sugerencias para nombres en la clase
        ["Pepe", "Pepito", "Sutano", "Mengano", "Camilo"]
    end
=begin    
# he comentado este bloque de código por el uso de Struct, el cual ya no requiere un constructor
# sino que las propiedades le son enviadas cómo simbolos y se encarga de la creación de ellas
# y el manejo de los getters y setters para ella.
    # ----------------------------------
    # metodos de instancia: 
    # al ser una clase, se requiere un constructor, en ruby es initialize
    # será un metodo y requiere ser creado usando la palabra reservada def
    def initialize(name, age)
        # para declarar variables de instancia se utiliza el arroba
        # la variable instancia de esta clase se va a inicializar con el parametro que nos pasen en el constructor 
        @name = name
        @age = age
    end
=end
=begin
# he comentado los getter y setter ya que no son necesarios al usar un macro llamado attribute accesor (attr_accessor)     
    # crearemos algunos metodos getters para poder acceder a las propiedades de esta clase.
    # para esto se utiliza la palabra reservada def, y se retorna la propiedad de esta clase.
    #getter
    def name
        # retorno implicito, no se usa palabra return
        # en ruby todas las instrucciones de codigo retornan algo, dentro de los metodos si no se usa return, ruby entiende que se retorna el valor de la ultima instruccion
        @name
    end
    
    def age
        @age
    end
    
    #setter
    # persona.name = "pepe"
    def name=(name)   # el igual = debe ir sin espacios
        @name = name
        self  # self hace referencia a la misma instancia
    end
    
    # Al tener self podemos asignar las propiedades a los objetos de la clase de la siguiente forma:
    # (persona.name = "pepe").age = 7
    # de esta forma se crean las dos cosas en una sola linea
    
    def age=(age)   # el igual = debe ir sin espacios
        @age = age
        self # referencia al mismo objeto
    end
=end
# muchos bloques en ruby necesitan esta palabra reservada (end) para determinar hasta donde van
end


# crearemos una variable de esta clase

# persona(nombre de la variable) = Persona(Nombre de la clase) Nótese la diferencia por la mayuscula
# new es la forma de instanciar un objeto de esta clase, va a llamar al codigo dentro del constructor (initialize)
# el constructor pide que se reciban dos parametros (name, age)
persona = Persona.new("pepe", 14)

puts persona.name
puts persona.age

# si se quiere llamar al método se hace de la siguiente forma:
puts Persona.suggested_names
# persona (si, en minuscula) pertenece a una variable de instancia
# por eso se llama desde la clase usando Persona (con 'P' mayúscula)
binding.pry

Es buena practica declarar metodos en las clases?

Aquí les dejo mis 3 formas de declarar las clases.

class Persona
#metodo de clase
def self.nombres_sugeridos
[“Pepe”,“Jonathan”,“Fernando”,“Sutano”]
end
#constructor
def initialize(nombre, edad)
@nombre = nombre
@edad= edad
end
#getters
def nombre
@nombre
end
def edad
@edad
end
#setters
#persona.nombre ="pepe"
def nombre=(nombre)
@nombre = nombre
self
end
def edad=(edad)
@edad = edad
self
end
end

#otra forma de declarar una clase y acceder a las propiedades de la clase
class Persona
attr_accessor :nombre, :edad #esto genera getteres y setters
#metodo de clase
def self.nombres_sugeridos
[“Pepe”,“Jonathan”,“Fernando”,“Sutano”]
end
#constructor
def initialize(nombre, edad)
@nombre = nombre
@edad= edad
end
end

#otra forma de declarar clase con metodos (con struct no se necesita el contructor)
class Persona < Struct.new( :nombre, :edad)
def self.nombres_sugeridos
[“Pepe”,“Jonathan”,“Fernando”,“Sutano”]
end
end

Estuve practicando este apartado y me di cuenta que o si usamos attr_accessor o Struct.new las propiedades deben de ser como símbolos de lo contrario manda error 😕