Technical Article: Implementing a Simple Command-Line Calculator in Go

Introduction

In this article, we will explore a simple command-line calculator program written in the Go programming language. This program demonstrates basic Go concepts such as command-line arguments, string manipulation, and simple arithmetic operations. We will walk through the code, explaining each part and its functionality from the basics to the complete implementation.

Prerequisites

To follow along with this article, you should have:

1. Basic understanding of Go programming language.
2. Go installed on your machine.
3. A code editor or IDE of your choice.

Code Overview

The program takes three command-line arguments: two integers and an arithmetic operator. It performs the specified arithmetic operation on the integers and prints the result. The supported operators are +, -, *, /, and %.

Let's start by looking at the overall structure of a Go program.

Package Declaration

package main

Every Go program starts with a package declaration. The main package is a special package in Go, which is used to define an executable program. The main function within this package serves as the entry point of the program.

Importing Packages

import (
    "fmt"
    "os"
    "strconv"
)

Next, we import the necessary packages:

• fmt: Provides formatted I/O functions.
• os: Enables access to command-line arguments.
• strconv: Contains functions for converting strings to other data types, such as integers.

Validating the Operator

func validateOperator(test string) bool {
    op := []string{"+", "-", "*", "/", "%"}
    for _, res := range op {
        if res == test {
            return true
        }
    }
    return false
}

We define a function called validateOperator to check if the provided operator is valid. This function takes a string test as input and compares it against a list of supported operators (+, -, *, /, %). If the operator is valid, the function returns true; otherwise, it returns false.

Main Function

The main function is the entry point of our program. Let's break it down step-by-step.

Reading Command-Line Arguments

func main() {
    args := os.Args[1:]
    if len(args) > 3 || len(args) < 3 {
        fmt.Print("The len of args should be three")
    } else {
        // further code here...
    }
}

We start by reading the command-line arguments using os.Args[1:]. This skips the first argument, which is the program's name, and stores the remaining arguments in the args slice.

Next, we check if the number of arguments is exactly three. If not, the program does nothing and exits.

Operator Validation

if !validateOperator(args[1]) {
    fmt.Println(0)
} else {
    // further code here...
}

We validate the operator using the validateOperator function. If the operator is invalid, the program prints 0 and exits.

Converting Strings to Integers

premier, _ := strconv.Atoi(args[0])
second, _ := strconv.Atoi(args[2])

We convert the first and third arguments to integers using strconv.Atoi. This function returns two values: the converted integer and an error (if any). For simplicity, we ignore the error.

Arithmetic Operations

if args[1] == "%" && second == 0 {
    fmt.Print("No Modulo by 0\n")
} else if args[1] == "/" && second == 0 {
    fmt.Print("No division by 0\n")
} else if args[1] == "+" {
    fmt.Println(premier + second)
} else if args[1] == "-" {
    fmt.Println(premier - second)
} else if args[1] == "*" {
    fmt.Println(premier * second)
} else if args[1] == "/" {
    fmt.Println(premier / second)
} else {
    fmt.Println(premier % second)
}

The program performs the specified arithmetic operation based on the operator:

• For % and /, it checks if the second integer is 0 to avoid division or modulo by zero errors.
• For each operator, it performs the corresponding arithmetic operation and prints the result.

Complete Code

Here is the complete code for our command-line calculator program:

package main

import (
    "fmt"
    "os"
    "strconv"
)

func validateOperator(test string) bool {
    op := []string{"+", "-", "*", "/", "%"}
    for _, res := range op {
        if res == test {
            return true
        }
    }
    return false
}

func main() {
    args := os.Args[1:]
    if len(args) > 3 || len(args) < 3 {
        fmt.Print("The len of args should be three")
    } else {
        if !validateOperator(args[1]) {
            fmt.Println(0)
        } else {
            premier, _ := strconv.Atoi(args[0])
            second, _ := strconv.Atoi(args[2])

            if args[1] == "%" && second == 0 {
                fmt.Print("No Modulo by 0\n")
            } else if args[1] == "/" && second == 0 {
                fmt.Print("No division by 0\n")
            } else if args[1] == "+" {
                fmt.Println(premier + second)
            } else if args[1] == "-" {
                fmt.Println(premier - second)
            } else if args[1] == "*" {
                fmt.Println(premier * second)
            } else if args[1] == "/" {
                fmt.Println(premier / second)
            } else {
                fmt.Println(premier % second)
            }
        }
    }
}

Running the Program

To run the program, save the code to a file (e.g., calculator.go) and execute it from the command line with three arguments:

go run calculator.go 5 + 3

This should output:

8

Conclusion

In this article, we created a simple command-line calculator in Go. We covered basic concepts such as reading command-line arguments, validating input, converting strings to integers, and performing arithmetic operations. This program serves as a good starting point for understanding Go's standard library and its capabilities.