Remove Assignments

La técnica de refactoring remove assignments sirve para que podamos construir un código más fácil de leer y modificar, que no se preste a confusiones cuando estamos haciendo uso de parámetros en algún método. 

Cuando dentro de un método, o en cualquier parte del programa, cambiamos el contenido de una variable o parámetro que hayamos establecido previamente, siempre existe el riesgo de que utilicemos estos elementos sin tomar en cuenta ese cambio e incurramos en errores involuntarios.

Para evitar cualquier situación que ponga en peligro la integridad de nuestros proyectos, utilizar remove assignments es una gran idea. 

¿Cuándo aplicar la técnica remove assignments?

Si en un método, perteneciente a una clase determinada, agregamos un valor nuevo a un parámetro, esto significa que estamos cambiando un objeto por otro. Por lo tanto, habrá confusión y falta de claridad de allí en adelante.

A partir de ese momento no sabremos con exactitud a cuál de los objetos creados (el parámetro antes o después de la asignación dentro del método) estamos haciendo referencia cuando se emplee el nombre de ese parámetro.  

Si esto está sucediendo en nuestro código, es el momento de aplicar la técnica remove assignments.

¿Por qué utilizar la técnica remove assignments?

• Para tener un mejor control de cómo está funcionando el código en cada momento de su ejecución y evitar confusiones.
• Para facilitar el mantenimiento del código en el futuro, con esta técnica, cuando reemplacemos una variable dentro de un método, tendremos la seguridad de no afectar el resto del programa.

Pasos para usar la técnica remove assignments

• Revisar si el código para determinar si en alguno de los métodos hemos cambiado su valor de manera interna.
• Al determinar que esto efectivamente está sucediendo, generar una variable temporal que contendrá el mismo valor del parámetro, mientras el método cumple su función.
• Reemplazar cada una de las referencias al parámetro, por referencias a esa variable local que acabamos de crear.
• Compilar y ejecutar el código para determinar si todo está funcionando de acuerdo a lo esperado.

Ahora pasaremos a revisar un breve ejemplo de código para ver el funcionamiento de esta técnica de refactorización:

package remove;

public class Parametro {

    //creamos un método modificando la variable x  
    private static void triple(int x) {
        x = x * 3;
        System.out.println("Valor de x en el triple: " + x);
    }

    public static void main(String[] args) {
        int x = 3;

        /*invocamos al método creado que nos mostrará el valor
        de x internamente*/
        triple(x);

        //imprimimos el valor de x 
        System.out.println("x despues del triple: " + x);
    }
}

En este código el método usa directamente el valor del parámetro, con el mismo nombre, la falta de claridad en el contenido puede prestarse a confusiones, por esto la recomendación sería hacer algunas modificaciones como sigue:

public class Parametro {

    /*creamos un método con una variable local 
    que va a contener el valor de x*/
    private static void triple(int x) {
        int interna = x;
        interna = interna * 3;
        System.out.println("Valor de x en el triple: " + interna);
    }

    public static void main(String[] args) {
        int x = 3;

        /*invocamos al método creado que nos mostrará el valor
        de la variable local */
        triple(x);

        //imprimimos el valor de x 
        System.out.println("x despues del triple: " + x);
    }
}