Getx 2 - variables reactivas - Lista, Mapas, Objetos

En la entrega anterior hablaba de las variables primitivas reactivas obs, de los observadores y de cómo las variables obs envuelve el tipo especificado, estas son primitivas:

• final var = 0.obs; // Será un entero
• final var = ' '.obs; //String
• final var = 0.0.obs; //double
• final var = false.obs; //boolean
  
  

Ahora bien, List, Map y los objetos propietarios son algo diferentes.

List y Map

Dart sí permite sobrecargar los métodos de List y Map, es por ello que no se utiliza value para acceder al valor contenido internamente en el observable.

Las List y Maps se definen:

• final lista = <String>[].obs;
• final mapa = <String, String>{}.obs;

Y se acceden igual que se hace siempre con estos objetos:

• lista.add("cadena");  //añadimos una cadena
• lista[3]; //obtenemos el elemento 3 de la lista
• mapa["dato1"]="cadena"; // agregamos o modificamos el elemento "dato1"
• mapa["dato1"] ; //obtenemos el valor de "dato1"

A diferencia de las variables primitivas no necesitamos agregar value ni para cambiar ni para obtener el valor del observador.

Y sí, cada vez que modifiquemos la lista o el mapa nos comunicará el evento de cambio haciendo que nuestro Obx() que lo observa repinte el contenido.

Objetos

Cuando definimos un objeto y queremos hacerlo observable, tenemos dos opciones, por un lado hacer observable el objeto entero y por otro hacer observable aquellas propiedades que queramos.

Esto es quizás la parte un poco más compleja en los observables de Getx.

Pongamos por ejemplo un objeto Persona:

class Persona {

    String nombre = "";
    String apellido = "";
}

Vamos a ver que pasa en cada uno de los casos.

Hacer observable el objeto en sí

Por ejemplo haciendo final persona = Persona().obs; lo que hace Getx, cómo ya vimos, es envolver al objeto persona en una variable observable:

Ahora bien, cómo un observable (obs) sólo reacciona cuando se modifica su valor, si cambiamos el nombre del objeto interno NO se disparará el evento de cambio. Si queremos que se notifique, en este caso, hay dos opciones:

• Crear un nuevo objeto,
  persona.value = Persona(); ó persona(Persona()); 
• O indicar a GetX que queremos que notifique que hemos modificado el valor interno,
  persona.update((p) {p.nombre = "pepe"});

La otra opción, que yo no uso prácticamente en los objetos propietarios, seria hacer observables los atributos, o todos o los que nos interesen.

Hacer observable los atributos del objeto

En este caso seria al definir la clase, no el objeto (variable):

Como vemos la diferencia es que el atributo nombre en la segunda es observable. Por supuesto no es necesario que todos los atributos sean observables.

En este caso NO podremos observar los cambios de Persona, sino sólo del atributo nombre.

Para cambiarlo seria:

final persona = Persona();

[...]
persona.nombre.value = "pepe";

Y con esto se notifica el cambio del atributo nombre al asignarle un valor.

Estos atributos se comportan igual que las primitivas que vimos en la entrega anterior, simplemente que se encuentran dentro de un objeto.

Resumen

Ya casi es el final de la parte Getx reactiva. Getx define un tipo de objeto StateMixin que se usa sobre todo en Futures y es una mezcla entre reactivo y no, casi no sabría catalogarlo. Lo veremos cuando se vean los controladores.

Es muy importante no confundir la implementación reactiva de Getx con la que no lo es (cómo GetBuilder). Si hay interés puedo hablar de ella.