Todo empezó

En una ocasión que tocaba realizar unas modificaciones a la un segmento de código de un proyecto en particular, resulta que el proyecto para ejecutarse debe de comunicarse con un API y para ello hay que crear una instancia de comunicación, que permita hacer uso de ella y demás.

El detalle

Fue que todo estaba bien pero al hacer uso de una de los métodos, en ocaciones no funcionaba bien y en otros sí sin problemas. Y El código hacía lo que se requería.

Pero al comentar la situación con el equipo, y de manera razonable el problema parecía que se centraba más en que el ambiente virtual no era el mismo al momento en que se ejecutaba, Pues virtualmente la versión de la librería era el adecuado, las pruebas salían bien. Incluso al indicarle al IDE al hacerle las pruebas de comunicación marcaba error. Y por eso se consideraba justamente que el problema radicaba en indicar el ambiente virtual tomar.

Entonces se opta por quitar todos los ambientes virtuales y dejar solo uno, el IDE toma ese ambiente y pum aún sigue marcando el mismo error, de no poder conectar con el API, y si llegaba a conectar marcaba que ese atributo no existe dentro de la API. Se toma la iniciativa de ejecutar el código fuente en otro equipo, con otro sistema operativo, creyendo que pudiera ser alguna cuestión de arquitectura o algo así.

El detalle es que al crear el ambiente en otro equipo, con otro sistema operativo, se realiza la prueba de conexión y funcionaba, se verifica la existencia del atributo y existe. Entonces se valida la versión de la librería y era la misma, se comprueba el origen y es el mismo. Y entonces el problema ¿dónde radicaba? era la gran cuestión.

La solución

Llego cuando al comprobar los mismos datos del otro equipo en la maquina donde se estaba trabajando, ver que coincidía y que aún marcaba los mismos detalles, se hace la prueba de ejecutar todo el fuente en el otro equipo resultando que también marcaba el mismo error.

Entonces se empieza a hacer un debug sobre cada línea y se va dando cuenta que las variables usadas para hacer una instancia de la API, estaban mal. Y a simple vista se veía bien las instancia y el llamado a la misma. Pero tenían nombre que no hacía referencia mucho a ellas.

La moraleja

Es que siempre es importante crear las variables que se usen haciendo referencia a lo que contendrá, ya que en la actualidad es fácil declarar una variable que sea solo una letra y que sea reasignada indefinidas veces durante el transcurso del programa perdiendo sus valores originales. Afectando a otras partes del programa. O normalizarlas. para evitar esos detalles.

La entrada Las variables también hacen travesuras se publicó primero en Frexus.

var nombre_variable = valor ; 

Sin embargo al usar nodejs es común que se use la palabra reservada let para una declaración de variable su uso queda como se muestra a continaución:

let NombreVariable = valor;

Recomendaciones para el nombre de variables

• No debe de iniciar con un dígito, o carácter especial.
• Solo se puede separar el nombre de una variable por el carácter guión bajo (_).
• No se debe de usar los espacios en blanco entre nombre de variables.

La entrada Las Variables en NodeJS se publicó primero en Frexus.

• Las variables son estáticas en cuanto a su tipo de datos, lo anterior quiere decir que, en el transcurso del programa la variable no puede cambiar su tipo.
• Si no se inicializan van a estar iniciadas con su valor por defecto zero para las de tipo entero y vacío para las de tipo cadena.

Declaración de variables

La sintaxis para declarar una variable es la siguiente:

var NombreVariable tipoVariable = valor

//declarando una variable entera i
var i int = 10

En la instrucción anterior se observa que se hace de la palabra reservada var la cual denota que se hará una declaración de variable, se debe de tener presente las recomendaciones para la creación de una variable (vea este post).

Declaración corta de variables en uso local

Se puede declarar una variable de una forma corta haciendo uso de la siguiente sintaxis:

nombre := valor

//declarando una variable entera x
var x int = 17

El detalle es que esa sintaxis solo se puede usar dentro de una función, ya que el compilador analiza la línea y le asigna el tipo de dato que debe de llevar. Lo interesante es que se puede asignar diferentes valores a distintas variables en una misma línea por ejemplo:

variable1, variable2, variable3 := 'hola', 18, false

Lo genial es que el compilador detecta si todas las variables que se han declarado son usadas, es decir, si se declaro una variable y no se usa en todo el programa mandará una alerta de que no se hace de uso de la misma.

Declaración grupal de variables

Otro dato curioso de go es que permite la declaración bloques de variables usando una sola palabra reservada, esto se puede realizar de dos maneras la primera se indica un bloque con el nombre de la variable y el tipo de la misma, la segunda forma es indicando el nombre de la variable y su valor. La sintaxis para ambos casos es el siguiente:

Primera Forma:

var (
     NombreVariable tipoVariable
     NombreVariable2 tipoVariable
     NombreVariable3 tipoVariable
)

Segunda Forma:

var (
    NombreVariable = ValorVariable
    NombreVariable2 = ValorVariable
    NombreVariable3 = ValorVariable
)

Recomendaciones para la declaración de variables

a continuación se muestra una seria de recomendaciones que se sugiere se sigan a la hora de declarar una variable:

• Deben de iniciar con una letra.
• No deben de tener espacios en blanco en la declaración de una variable.
• Se permite el uso de guiones bajos.
• No debe de iniciar con caracteres especiales.
• No debe tener números al inicio del nombre de variable.
• El compilador distingue entre mayúsculas y minúsculas, es decir que si se usa el mismo nombre de variable (una en minúsculas y otra en mayúsculas) serán dos tipos de variables.
• En go el símbolo (:=) se utiliza para la declaración corta y asignación de valor de una variable, sin embargo al hacer uso de la variable el operador que debe de usarse para el cambio de valor de la variable es el símbolo de igual (=).

Finales

Por el momento tiene características muy interesante go. Hay que seguir profundizando en su aprendizaje para crear aplicaciones geniales.

La entrada Go | Golang y sus variables. se publicó primero en Frexus.