Mira cualquier código orientado a objetos y todo sigue más o menos el mismo patrón. Cree un objeto, llame a algunos métodos en ese objeto y acceda a los atributos de ese objeto. No hay mucho más que pueda hacer con un objeto, excepto pasarlo como parámetro al método de otro objeto. Pero lo que nos preocupa aquí son los atributos.
Los atributos son como variables de instancia puede acceder a través de la notación de puntos del objeto. Por ejemplo, persona.nombre accedería al nombre de una persona. Del mismo modo, a menudo puede asignar atributos como person.name = "Alice". Esta es una característica similar a las variables miembro (como en C ++), pero no es lo mismo. No pasa nada especial aquí, los atributos se implementan en la mayoría de los idiomas usando "captadores" y "definidores", o métodos que recuperan y establecen los atributos de las variables de instancia.
Ruby no distingue entre captadores y establecedores de atributos y métodos normales. Debido al método flexible de Ruby que llama a la sintaxis, no es necesario hacer ninguna distinción. Por ejemplo,
persona.nombre y person.name () son lo mismo, estás llamando al nombre Método con cero parámetros. Uno parece una llamada de método y el otro parece un atributo, pero en realidad ambos son lo mismo. Ambos están llamando al nombre método. Del mismo modo, cualquier nombre de método que termine en un signo igual (=) se puede usar en una asignación. La declaración person.name = "Alice" es realmente lo mismo que person.name = (alice), a pesar de que hay un espacio entre el nombre del atributo y el signo igual, sigue llamando al nombre = método.Puede implementar fácilmente atributos usted mismo. Al definir los métodos setter y getter, puede implementar cualquier atributo que desee. Aquí hay un código de ejemplo que implementa el nombre atributo para una clase de persona. Almacena el nombre en un @nombre variable de instancia, pero el nombre no tiene que ser el mismo. Recuerde, estos métodos no tienen nada de especial.
Una cosa que notará de inmediato es que esto es mucho trabajo. Es mucho escribir solo para decir que quieres un atributo llamado nombre que accede al @nombre Instancia variable. Afortunadamente, Ruby proporciona algunos métodos convenientes que definirán estos métodos para usted.
Hay tres métodos en el Módulo clase que puede usar dentro de sus declaraciones de clase. Recuerde que Ruby no hace distinción entre tiempo de ejecución y "tiempo de compilación", y cualquier código dentro de las declaraciones de clase no solo puede definir métodos sino también métodos de llamada. Llamando al attr_reader, attr_writer y attr_accessor Los métodos, a su vez, definirán los establecedores y captadores que estábamos definiendo en la sección anterior.
los attr_reader El método hace exactamente lo que parece que hará. Toma cualquier número de parámetros de símbolos y, para cada parámetro, define un método "getter" que devuelve la variable de instancia del mismo nombre. Entonces, podemos reemplazar nuestro nombre método en el ejemplo anterior con attr_reader: nombre.
Del mismo modo, el attr_writer El método define un método "setter" para cada símbolo que se le pasa. Tenga en cuenta que el signo igual no necesita ser parte del símbolo, solo el nombre del atributo. Podemos reemplazar el nombre = método del ejemplo anterior con una llamada a attr_writier: nombre.
Y, como se esperaba, attr_accessor hace el trabajo de ambos attr_writer y attr_reader. Si necesita un setter y getter para un atributo, es una práctica común no llamar a los dos métodos por separado, y en su lugar llamar attr_accessor. Podríamos reemplazar ambos el nombre y nombre = métodos del ejemplo anterior con una sola llamada a attr_accessor: nombre.
¿Por qué deberías definir setters manualmente? ¿Por qué no usar el attr_ * métodos cada vez? Porque rompen la encapsulación. La encapsulación es el principal que establece que ninguna entidad externa debe tener acceso irrestricto al estado interno de su objetos. Se debe acceder a todo utilizando una interfaz que evite que el usuario corrompa el estado interno del objeto. Usando los métodos anteriores, hemos perforado un gran agujero en nuestro muro de encapsulación y permitido que se establezca absolutamente cualquier cosa para un nombre, incluso nombres obviamente inválidos.
Una cosa que verás a menudo es que attr_reader se utilizará para definir rápidamente un captador, pero se definirá un configurador personalizado ya que el estado interno del objeto a menudo quiere ser leer directamente desde el estado interno. El definidor se define manualmente y realiza comprobaciones para garantizar que el valor que se establece tenga sentido. O, quizás más comúnmente, no se define ningún setter. Los otros métodos en la función de clase establecen la variable de instancia detrás del getter de alguna otra manera.
Ahora podemos agregar un años e implementar adecuadamente un nombre atributo. los años El atributo se puede establecer en el método constructor, leer usando años getter pero solo manipulado usando el cumpleaños método, que aumentará la edad. los nombre El atributo tiene un getter normal, pero el setter se asegura de que el nombre esté en mayúscula y tenga la forma de Nombre Apellido.