📝 Exercise : Creating an Interactive Calculator in Go

Objective :

Create a Go program that :

• 1- Asks the user to enter a first number.
• 2- Asks the user to choose an operation ("+", "-", "*", "/").
• 3- Asks the user to enter a second number.
• 4- Performs the calculation and displays the result.
• 5- Allows the user to perform another calculation or exit the program.

1- Implement a getNumber(prompt string) float64 function to handle number input :

• 1- The function should take a string argument (the prompt message for user input).
• 2- It should return a float64, which will be the validated number.
• 3- Use fmt.Print() to display a message asking the user for input.
• 4- Use fmt.Scan() to capture the user’s input as a string.
• 5- Use strconv.ParseFloat() to convert the string into a float64.
• 6- If the conversion fails (e.g., the user enters non-numeric characters), the function should display an error and prompt again.
• 7- Once a valid number is obtained, return it to the calling function.
• By following these steps, the user will have a function that ensures only valid numbers are accepted before performing any calculations. 🚀

Solution :

// getNumber asks the user to enter a number and returns it
func getNumber(prompt string) float64 {
	var input string

	for {
		fmt.Print(prompt)
		fmt.Scan(&input)

		num, err := strconv.ParseFloat(input, 64)

		if err == nil {
			return num
		}

		fmt.Println("Error: Please enter a valid number.")
	}
}
                

2- Implement the getOperator() string Function :

The getOperator function is responsible for retrieving and validating the arithmetic operator from the user. It ensures that only one of the allowed operations (+, -, *, /) is accepted before proceeding with the calculation.

• 1- Display a message asking the user to enter an arithmetic operator.
• 2- Capture the user's input as a string using fmt.Scan().
• 3- Check if the entered operator is valid (+, -, *, /).
• 4- If it is invalid, display an error message and ask again.
• 5- Once the user enters a correct operator, return it.

Solution :

// getOperator asks the user for an operation and validates it
func getOperator() string {
	var op string

	for {
		fmt.Print("Choose an operation (+, -, *, /): ")
		fmt.Scan(&op)

		switch op {
		case "+", "-", "*", "/":
			return op
		default:
			fmt.Println("Error: Invalid operation. Try again.")
		}
	}
}
                

3- Implement the calculate(num1 float64, op string, num2 float64) (float64, error) Function

The calculatefunction is responsible for performing the mathematical operation based on the operator provided by the user. It takes two numbers (num1 and num2) and an operator (op), then returns the result along with an error if something goes wrong (like division by zero).

• 1- It takes in two float64 numbers and a string representing the operator (+, -, *, /).
• 2- Use a Switch Statement to Determine the Operation, Depending on the operator, it performs addition, subtraction, multiplication, or division.
• 3- If the operator is / and num2 is 0, return an error to prevent a crash.
• 4- If the operation is valid, return the computed result.
• 5- If an invalid operator is received (which should not happen due to prior validation), return an error.

Solution :

// calculate performs the calculation based on the operator
func calculate(num1 float64, op string, num2 float64) (float64, error) {
	switch op {
	case "+":
		return num1 + num2, nil
	case "-":
		return num1 - num2, nil
	case "*":
		return num1 * num2, nil
	case "/":
		if num2 == 0 {
			return 0, fmt.Errorf("Error: Division by zero")
		}
		return num1 / num2, nil
	}

	return 0, fmt.Errorf("Error: Unknown operation")
}
                

4- Implement the main() Function :

The main() function serves as the entry point of the program. Its role is to orchestrate the entire process by calling other functions in a structured way.

• 1- Display a Welcome Message : Inform the user that they are using an interactive calculator.
• 2- Use a Loop for Multiple Calculations : The program should allow the user to perform multiple calculations without restarting.
• 3- Use getNumber() to retrieve the first number.
• 4- Use getOperator() to retrieve the operation.
• 5- Use getNumber() again to retrieve the second number.
• 6- se calculate() to perform the computation.
• 7- Handle Errors from calculate() : If calculate() returns an error (e.g., division by zero), display the error message instead of a result.
• 8- Ask the User if They Want to Continue :
  • After displaying the result, ask if they want to perform another calculation.
  • If they enter "no",exit the program gracefully.

Solution :

// main: main loop of the program
func main() {

	fmt.Println("----- Welcome to the Go Calculator -----")

	for {
		// Read user input
		num1 := getNumber("Enter the first number: ")
		operator := getOperator()
		num2 := getNumber("Enter the second number: ")

		// Perform the calculation
		result, err := calculate(num1, operator, num2)

		if err != nil {
			fmt.Println(err)
		} else {
			fmt.Printf("Result: %.2f %s %.2f = %.2f\n", num1, operator, num2, result)
		}

		// Ask if the user wants to continue
		var response string
		fmt.Print("Do you want to perform another calculation? (yes/no): ")
		fmt.Scan(&response)

		if response != "yes" {
			fmt.Println("Thank you for using the calculator! See you soon.")
			break
		}
	}
}
                

Final Code :

package main

import (
	"fmt"
	"strconv"
)

// getNumber asks the user to enter a number and returns it
func getNumber(prompt string) float64 {
	var input string

	for {
		fmt.Print(prompt)
		fmt.Scan(&input)

		num, err := strconv.ParseFloat(input, 64)

		if err == nil {
			return num
		}

		fmt.Println("Error: Please enter a valid number.")
	}
}

// getOperator asks the user for an operation and validates it
func getOperator() string {
	var op string

	for {
		fmt.Print("Choose an operation (+, -, *, /): ")
		fmt.Scan(&op)

		switch op {
		case "+", "-", "*", "/":
			return op
		default:
			fmt.Println("Error: Invalid operation. Try again.")
		}
	}
}

// calculate performs the calculation based on the operator
func calculate(num1 float64, op string, num2 float64) (float64, error) {
	switch op {
	case "+":
		return num1 + num2, nil
	case "-":
		return num1 - num2, nil
	case "*":
		return num1 * num2, nil
	case "/":
		if num2 == 0 {
			return 0, fmt.Errorf("Error: Division by zero")
		}
		return num1 / num2, nil
	}

	return 0, fmt.Errorf("Error: Unknown operation")
}

// main: main loop of the program
func main() {

	fmt.Println("----- Welcome to the Go Calculator -----")

	for {
		// Read user input
		num1 := getNumber("Enter the first number: ")
		operator := getOperator()
		num2 := getNumber("Enter the second number: ")

		// Perform the calculation
		result, err := calculate(num1, operator, num2)

		if err != nil {
			fmt.Println(err)
		} else {
			fmt.Printf("Result: %.2f %s %.2f = %.2f\n", num1, operator, num2, result)
		}

		// Ask if the user wants to continue
		var response string
		fmt.Print("Do you want to perform another calculation? (yes/no): ")
		fmt.Scan(&response)

		if response != "yes" {
			fmt.Println("Thank you for using the calculator! See you soon.")
			break
		}
	}
}

                

Congratulations! 🎉 By completing this exercise, you have built a fully functional interactive calculator in Go, while applying key programming principles like functions, loops, error handling, and user input validation. This project is a solid foundation for more complex Go applications. 🚀