Codificación del diagrama de flujo en el lenguaje Go

Ahora debemos codificar el diagrama de flujo utilizando las instrucciones del lenguaje Go.
A medida que avancemos en el curso veremos que significan las palabras claves package, import, func etc. por el momento nos centraremos donde codificaremos nuestros diagramas de flujo.
La codificación del diagrama de flujo la haremos dentro de la función main (la función main es la primera que se ejecuta al iniciarse un programa en el lejguaje Go)

El programa completo para el calculo del sueldo de un operario conociendo la cantidad de horas trabajadas y el costo por hora es (copiemos estas líneas en el editor Visual Studio Code y lo grabamos en la carpeta c:\programasgo con el nombre ejercicio002.go:

package main

import "fmt"

func main() {
    var horasTrabajadas int
    var costoHora float32
    var sueldo float32

    fmt.Print("Ingrese las horas trabajadas por el empleado:")
    fmt.Scan(&horasTrabajadas)
    fmt.Print("Ingrese el pago por hora:")
    fmt.Scan(&costoHora)
    sueldo=float32(horasTrabajadas) * costoHora
    fmt.Print("El sueldo total del operario es ",sueldo)
}

Recordemos del concepto 1 que para probar el programa debemos ir a "Símbolo del sistema":

Cambiarnos al directorio donde guardamos nuestro programa en Go mediante el comando cd c:\programasgo:

Ahora desde nuestra consola podemos compilar y ejecutar el programa en Go. Para esto escribimos en la consola:

go run ejercicio002.go

Se compila el programa y comienza su ejecución, problemas de cargar la cantidad de horas trabajadas por el operario y el pago por hora:

Tener en cuenta que debemos ingresar el caracter "." en lugar del caracter "," si ingresamos un costo por hora con decimales.

Conceptos que deben quedar claros:

Debe quedar claro que los programas los codificamos con nuestro editor de texto Microsoft Code (o el editor que a usted le guste)
Debemos tener siempre abierta una ventana del "Símbolo del sistema" donde compilamos y ejecutamos el programa codificado.
No olvidar grabar cada vez que hace una modificación en el archivo para que cuando lo ejecutemos tome los cambios.
Por el momento haremos todo el algoritmo dentro de la función main.
Si observamos el diagrama de flujos vemos que debemos definir tres variables: (horasTrabajadas, costoHora, sueldo), aquí es donde debemos definir que tipos de datos se almacenarán en las mismas. La cantidad de horas normalmente será un valor entero (ej. 100 - 150 - 230 etc.) definimos variables int, pero el costo de la hora es muy común que sea un valor real (ej. 5.35 - 7.50 etc.) y como el sueldo resulta de multiplicar las horas trabajadas por el costo por hora el mismo deberá ser real (debemos definir variables de tipo float32)

La definición de las variables la hacemos en la función main:
```
    var horasTrabajadas int
    var costoHora float32
    var sueldo float32
```
Utilizamos la palabra clave var para definir una variable, luego de var se dispone el nombre de la variable propiamente dicha y finalmente indicamos el tipo de dato que guarda la variable. La palabra clave int se usa para definir variables enteras (en Go las palabras claves deben ir obligatoriamente en minúsculas, sino se produce un error sintáctico)

Se propone que el nombre de la variable comience con minúscula y en caso de estar constituida por dos palabras o más deben ir en mayúsculas el primer caracter (un nombre de variable no puede tener espacios en blanco, empezar con un número, ni tampoco utilizar caracteres especiales)
Debemos buscar siempre nombres de variables que nos indiquen que almacenan (no es conveniente llamar a nombres de variables con letras individuales salvo en casos puntuales que veremos más adelante)
Para mostrar mensajes en la pantalla utilizamos la función "Print" que se encuentra en el paquete "fmt" (Un paquete veremos más adelante almacena entre otras cosas un conjunto de funciones relacionadas):
```
    fmt.Print("Ingrese las horas trabajadas por el empleado:")
```
Con esta sintaxis todo lo que se encuentra contenido entre comillas aparecerá exactamente en la pantalla.
Si necesitamos mostrar el contenido de una variable no debemos disponerla entre comillas, y separar por coma los mensajes y la variable:
```
    fmt.Print("El sueldo total del operario es ",sueldo)
```
Para hacer la entrada de datos por teclado en Go debemos utilizar la función "Scan" que se encuentra contenido en el paquete "fmt"
```
    fmt.Scan(&horasTrabajadas)
```
Debemos indicar el nombre de la variable a cargar antecedida por el caracter & (más adelante veremos que el caracter & indica la dirección de la variable)
Las operaciones que indicamos en el diagrama de flujo mediante la figura rectángulo la codificamos casi en forma idéntica (como costoHora es de tipo float32 luego debemos convertir horasTrabajadas a tipo float32):
```
    sueldo=float32(horasTrabajadas) * costoHora
```

Como hemos visto hasta ahora hay varias partes de nuestro código que no entendemos:

package main

import "fmt"

pero son indispensables para la implementación de nuestros programas, a medida que avancemos con el curso muchos de estos conceptos se irán aclarando.

Retornar

3 - Codificación del diagrama de flujo en el lenguaje Go