Ejercicio: Uso de variables para almacenar valores

3 minutos

En este ejercicio, aprenderá a crear programas que generen código en la consola. Compila el inicio de un programa de calculadora y también analiza un programa que tiene errores en él y aprende a corregir los errores.

Crear un proyecto

Comencemos con la creación de un proyecto. Un proyecto se crea desde la línea de comandos mediante el ejecutable dotnet.

Ejecute el comando dotnet new en la consola.
```
dotnet new console --language F# -o Variables
cd Variables
```
Este comando crea un nuevo proyecto de F# en el directorio Variables.
Reemplace el código de Program.fs por el código siguiente:
```
[<EntryPoint>]
let main argv =
    printfn "Welcome to the calculator program"
    // read input from the console and assign to `sum`
    let sum = 0
    printfn "The sum is %i" sum
    0
```
La primera declaración printfn da la bienvenida al usuario del programa. En la segunda línea, hay un comentario que comienza por // que muestra el código que implementará en la siguiente unidad de ejercicio. A continuación, tiene la instrucción let sum = 0. Por último, cree una variable sum que contenga el resultado del cálculo.
Ejecute el programa mediante dotnet run.
```
dotnet run
```
Debería ver los siguientes resultados:
```
Welcome to the calculator program
The sum is 0
```

¡Enhorabuena! Ha logrado aplicar scaffolding a un proyecto, ha iniciado un proyecto más grande y ha hecho que se ejecute.

Corrección del error

Parte del aprendizaje para programar en cualquier lenguaje consiste en aprender a reconocer los errores de compilación y corregirlos. Para este ejercicio, aplica la técnica scaffolding a un nuevo proyecto. Asegúrese de que está en un nivel superior en la estructura de directorios antes de continuar.

Aplique la técnica scaffolding a un nuevo proyecto de F# mediante la ejecución de dotnet new.
```
dotnet new console --language F# -o Errors
cd Errors
```
Reemplace el código de Program.fs por el código siguiente:
```
[<EntryPoint>]
let main argv =
    let aNumber = 0
    printfn "Here's a number %s" aNumber
    0 // return an integer exit code
```
Sugerencia

Deténgase un segundo y lea el código anterior. ¿Cree que el código se compilará? ¿Por qué o por qué no?
Ejecute dotnet run para ejecutar el proyecto.
```
dotnet run
```
Aparece un mensaje de error similar a este texto:
```
/<path>/Errors/Program.fs(8,34): error FS0001: This expression was expected to have type    'string'    but here has type    'int' [/<path>/Errors/Errors.fsproj]

The build failed. Fix the build errors and run again.
```
El mensaje de error indica que "se esperaba una cadena, pero el tipo era número entero". ¿Comprende cuál es el problema? El problema es el uso del formateador %s en lugar de %i, porque se da a la función printfn la variable aNumber de tipo int. Vamos a corregir el código.
Busque la fila con el código "printfn "Here's a number %s" aNumber" y cámbiela a:
```
printfn "Here's a number %i" aNumber
```
Guarde el archivo y vuelva a ejecutarlo con dotnet run. Ahora debería aparecer esta salida:
```
Here's a number 0
```

¡Enhorabuena! Ha depurado un programa leyendo el código, comprendiendo lo que estaba mal y corrigiéndolo. Reconocer los mensajes de error y saber cómo corregir los errores son aptitudes esenciales que debe tener como desarrollador.

Comentarios

¿Le ha resultado útil esta página?