02. Go to go: sintaxis, tipo de datos y palabras reservadas

Publicado por

¡Buenas! Continuamos los capítulos de programación en Go. Recordemos que en el capítulo anterior revisábamos algunos aspectos básicos del lenguaje, así como también aprendimos a instalar el compilador en nuestros equipos. En este capítulo continuaremos con algunos aspectos de carácter general de la sintaxis de Go antes de saltar a los temas de estructura de bloques.

Estructura de un archivo .go

Retomando el código de ejemplo del capítulo anterior con el cual verificamos la correcta instalación de Go desde símbolos de sistema o terminal, en dicho ejemplo podemos identificar las siguientes secciones en el código:


1 – Declaración de paquetes.
2 – Paquetes importados.
3 – Funciones.
4 – Variables.
5 – Declaraciones y expresiones.
6 – Comentarios (no abordados en dicho ejemplo).

Antes de continuar es necesario conocer la sintaxis de los comentarios en Go la cual es:

/* este es un comentario */

Todo comentario es ignorado por el compilador independientemente de su contenido. Solamente es de ayuda para el programador.

Los espacios en blanco son un caso similar a los comentarios. Tal y como en C y C++ puedes poner espacios en blanco u otros caracteres similares (tabulares por ejemplo) en cualquier parte del código sólo tomando unas pequeñas consideraciones (no puede haber caracteres en blanco en el nombre de un identificador, etc.), en Go también se pueden tomar la mayoría de esas libertades. La libertad más importante de la que se carece en Go es la posibilidad de separar la llave de apertura de una sentencia por medio de un caracter de nueva línea, es decir:

package main
import "fmt"

func main()
{    /* unexpected semicolon or newline before { */
  fmt.Println("Hello, World!")
}

Ahora continuemos con el tema principal, la estructura de los programas. Recordando el ejemplo del capítulo anterior, ahora se ha añadido un comentario previo que identifica cada parte del programa:


/*Paquete al que corresponde este archivo.
Todo archivo de Go debe localizarse en un paquete*/
package main

/*Línea de preprocesador. Incluye el paquete fmt
que tiene definidas las funciones y métodos de
entrada y salida */
import "fmt"

/*Función principal con la que se comienza a
ejecutar el programa */
func main(){
/*Del paquete fmt importa el método Println el
cual muestra el texto en pantalla */
  fmt.Println("¡Has instalado Go correctamente!")
}

Cabe señalar que no existe algún caracter especial que se deba añadir para terminar una línea de código mas que el caracter de fin de línea. Internamente el compilador agrega el punto y coma “;” al final de cada sentencia.

fmt.Println("Ésta es una línea de código")
fmt.Println("Ésta también")
fmt.Println("Ésta es la tercer línea de código")

Identificadores y palabras reservadas

Al igual que en muchos otros lenguajes de programación, en Go puedes declarar variables, funciones y elementos con un identificador único que tú desees. Un identificador inicia con una letra de la “A”-“Z” (mayúscula o minúscula) o bien con un guión bajo (“_”) seguido de una combinación de 0 o N letras, guiones y dígitos decimales.

identificador = [a-zA-Z_]+[a-zA-Z0-9_]*

Se debe de tener cuidado que los identificadores nunca sean iguales a las palabras reservadas. La siguiente es la lista de palabras reservadas de Go:

break default funct interface select
case defer go map struct
chan else goto package switch
const fallthrough if range type
continue for import return var

Tipos de datos

Como se mencionaba desde el capítulo anterior, Go es un lenguaje de programación con tipado estático y por tanto es necesario declarar las variables antes de usarlas. La razón por la que esto es necesario es porque el compilador necesita conocer cuánto espacio en memoria necesita reservar para variables y cómo interpretar la información guardada en ese espacio de memoria.

Las variables en Go se clasifican como:

Booleanas Variables lógicas con valor true o false.
Numéricas Representan números enteros o de punto flotante.
Cadenas Secuencia de bytes que representan cadenas de texto inmutable, no es posible cambiar el contenido de una cadena.
Derivadas Punteros, arreglos, estructuras, uniones, funciones, slices, interfaces, Maps, Channels.

Rangos de valores de enteros y flotantes

Los números enteros que maneja Go son independientes de la arquitectura del procesador, es decir, no cambian los rangos de valores entre arquitecturas de procesadores como ocurre con C. Los tipos de enteros son:

Tipo Descripción Rango
uint8 Unsigned 8-bits (0 a 255)
uint16 Unsigned 16-bits (0 a 65535)
uint32 Unsigned 32-bits (0 a 4294967295)
uint64 Unsigned 64-bits (0 a 18446744073709551615)
int8 Signed 8-bits (-128 a 127)
int16 Signed 16-bits (-32768 a 32767)
int32 Signed 32-bits (-2147483648 a 2147483647)
int64 Signed 64-bits (-9223372036854775808 a 9223372036854775807)

Por su parte los tipos numéricos con punto flotante son:

Tipo Descripción
float32 IEEE-754 32-bit floating-point numbers
float64 IEEE-754 64-bit floating-point numbers
complex64 Números complejos con float32 partes reales e imaginarias
complex128 Números complejos con float64 partes reales e imaginarias

Además de números decimales enteros y de punto flotante, Go cuenta con otras implementaciones con sus tamaños específicos:

Tipo Descripción
byte 8-bits (0 a 255)
rune 32-bits (-2147483648 a 2147483647)
uint 32 o 64 bits
int 32 o 64 bits
uintptr Entero guarda los bits no interpretados de un puntero

Finalizando…

Eso ha sido todo por ahora. Ya conocemos un poco más sobre la estructura de un programa de Go, sus palabras reservadas y rangos de datos; principalmente el rango de datos es muy útil ya que es bastante común ingresar a una variable el valor que sea cuando estás acostumbrado a lenguajes de tipado dinámico.

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *