12 - Estructura de programación repetitiva for (sin argumentos)

El for es la única estructura repetitiva que nos provee el lenguaje Go, pero ya hemos visto dos variantes en los conceptos anteriores.

Ahora veremos una tercer variante del for en la que dejamos vacía la sección de inicio del contador, la condición y la de incremento o decremento del contador.

for {
    [instrucciones]
}

Cuando no disponemos condición en un for siempre se verifica verdadero, esto significa que el bloque de instrucciones se ejecutaría en forma infinita, pero disponemos de un comando llamado break que finaliza el for.

Mediante ejemplos veremos como utilizar un for sin argumentos.

Problema 1:

Confeccionar un programa que permita ingresar valores enteros por teclado y los sume. Se finaliza la carga de valores al ingresar el cero.

Programa: ejercicio055.go

package main

import "fmt"

func main() {
    var valor int
    suma := 0
    for {
        fmt.Print("Ingrese un valor (0 para finalizar):")
        fmt.Scan(&valor)
        if valor == 0 {
            break;
        }
        suma = suma + valor
    }
    fmt.Print("La suma de todos los valores ingresados es:", suma)
}

Hemos dispuesto un for sin argumentos:

    for {

Dentro del for se ingresa un valor entero y mediante un if verificamos si es el cero para romper la ejecución del for mediante la palabra clave break (el break continua con la ejecución de la línea siguiente a la llave de finalización del for):

        fmt.Print("Ingrese un valor (0 para finalizar):")
        fmt.Scan(&valor)
        if valor == 0 {
            break;
        }

Todas las veces dentro del for acumulamos el valor ingresado:

        suma = suma + valor

Fuera del for recién mostramos la suma de todos los valores ingresados:

    fmt.Print("La suma de todos los valores ingresados es:", suma)

Problema 2:

Realizar la carga de los sueldos de operarios de una empresa. Mostrar el promedio de los mismos.
No se sabe de antemano cuantos sueldos se procesarán. Cuando se ingrese un sueldo con el valor cero se debe mostrar recién el promedio.

Programa: ejercicio056.go

package main

import "fmt"

func main() {
    var sueldo float64
    cantidad := 0
    suma := 0.0
    for {
        fmt.Print("Ingrese el sueldo del operario(0 para finalizar la carga):")
        fmt.Scan(&sueldo)
        if sueldo == 0 {
            break;
        }
        cantidad++
        suma = suma + sueldo
    }
    promedio := suma / float64(cantidad)
    fmt.Print("El promedio de sueldos es:", promedio)
}

Introducimos otro tipo de dato primitivo para almacenar valores con coma: float64. Variables de este tipo pueden almacenar un valor con coma con mayor precisión.

Los dos tipos de datos para almacenar valores con coma son:

float32
float64

Definimos por inferencia un contador para contar la cantidad de empleados que se cargan:

    cantidad := 0

También definimos un acumulador llamado suma y si queremos definir por inferencia para permitir almacenar valores reales lo hacemos asignando el valor 0.0 (con esto se define una variable de tipo float64):

    suma := 0.0

Recordemos que esta línea la podemos sustituir por la sintaxis:

    var suma float64

Automáticamente se almacena un cero en la variable suma.

El for no tiene argumentos por lo que se cortará al ingresar en la variable sueldo un valor cero:

    for {
        fmt.Print("Ingrese el sueldo del operario(0 para finalizar la carga):")
        fmt.Scan(&sueldo)
        if sueldo == 0 {
            break;
        }
        cantidad++
        suma = suma + sueldo
    }

Es importante notar que cuando se ingresa un valor cero en la variable sueldo no se ejecutan las líneas:

        cantidad++
        suma = suma + sueldo

Fuera de la estructura repetitiva calculamos el promedio de los sueldos y lo mostramos:

    promedio := suma / float64(cantidad)
    fmt.Print("El promedio de sueldos es:", promedio)

Problemas propuestos

• Realizar un programa que acumule (sume) valores ingresados por teclado hasta ingresar el 9999 (no sumar dicho valor, indica que ha finalizado la carga). Imprimir el valor acumulado e informar si dicho valor es cero, mayor a cero o menor a cero.
• En un banco se procesan datos de las cuentas corrientes de sus clientes. De cada cuenta corriente se conoce: número de cuenta y saldo actual. El ingreso de datos debe finalizar al ingresar un valor negativo en el número de cuenta.
  Se pide confeccionar un programa que lea los datos de las cuentas corrientes e informe:
  a)De cada cuenta: número de cuenta y estado de la cuenta según su saldo, sabiendo que:
  

  Estado de la cuenta	'Acreedor' si el saldo es >0.
  			'Deudor' si el saldo es <0.
  			'Nulo' si el saldo es =0.
  

  b) La suma total de los saldos acreedores.

Solución

ejercicio057.go

package main

import "fmt"

func main() {
    var valor int
    suma := 0
    for {
        fmt.Print("Ingrese un valor (9999 para finalizar):")
        fmt.Scan(&valor)
        if valor == 9999 {
            break
        }
        suma = suma + valor        
    }
    fmt.Println("El valor acumulado es ", suma)
    if suma == 0 {
        fmt.Print("El valor acumulado es cero.")
    } else {
        if suma > 0 {
            fmt.Print("El valor acumulado es positivo.")
        } else {
            fmt.Print("El valor acumulado es negativo")
        }
    }    
}



ejercicio058.go

package main

import "fmt"

func main() {
    var cuenta int
    var saldo float64
    var suma float64
    for {
        fmt.Print("Ingrese numero de cuenta:")
        fmt.Scan(&cuenta)
        if cuenta < 0 {
            break
        }
        fmt.Print("Ingrese saldo:")
        fmt.Scan(&saldo)
        if saldo > 0 {
            fmt.Println("Saldo Acreedor.")
            suma = suma + saldo
        } else {
            if saldo < 0 {
                fmt.Println("Saldo Deudor.")
            } else {
                fmt.Println("Saldo Nulo.")
            }
        }
    }
    fmt.Println("Total de saldos Acreedores:", suma)
}