Building a CLI Dictionary App in Go

Table of Contents

  1. Introduction
  2. Prerequisites
  3. Setup
  4. Building the CLI Dictionary App
  5. Conclusion

Introduction

In this tutorial, we will learn how to build a Command-line Interface (CLI) Dictionary App using the Go programming language. By the end of this tutorial, you will have a functional CLI dictionary application that allows users to look up the definitions of words directly from the command line.

Prerequisites

To follow along with this tutorial, you should have a basic understanding of Go programming and how to work with packages. You will also need Go installed on your machine.

Setup

Before we start building the CLI dictionary app, let’s set up the project structure and install any necessary dependencies.

  1. Create a new directory for your project: mkdir cli-dictionary-app

  2. Change into the project directory: cd cli-dictionary-app

  3. Initialize a new Go module: go mod init github.com/your-username/cli-dictionary-app

  4. Install the necessary Go packages:

     go get github.com/spf13/cobra
 go get github.com/PuerkitoBio/goquery

Building the CLI Dictionary App

Now that we have set up the project, let’s start building the CLI dictionary app.

  1. Create a new file named main.go in the project root directory.

  2. Open main.go in your favorite text editor and import the necessary packages:

     package main
    
 import (
 	"fmt"
    
 	"github.com/spf13/cobra"
 )

  3. Define the root command using the cobra package:

     var rootCmd = &cobra.Command{
 	Use:   "dictionary",
 	Short: "Command-line Dictionary App",
 	Long:  "A simple command-line dictionary app built with Go.",
 	Run: func(cmd *cobra.Command, args []string) {
 		fmt.Println("Welcome to the CLI Dictionary App!")
 	},
 }

  4. Create a init function to set up the root command and any subcommands:

     func init() {
 	rootCmd.AddCommand(lookupCmd)
 }
    
 func main() {
 	if err := rootCmd.Execute(); err != nil {
 		fmt.Println(err)
 		os.Exit(1)
 	}
 }

  5. Now, let’s define the lookup subcommand to handle word lookups:

     var lookupCmd = &cobra.Command{
 	Use:   "lookup [word]",
 	Short: "Look up the definition of a word",
 	Args:  cobra.ExactArgs(1),
 	Run: func(cmd *cobra.Command, args []string) {
 		word := args[0]
 		definition := lookupWord(word)
 		fmt.Println(definition)
 	},
 }

  6. Implement the lookupWord function to fetch the definition of a word:

     func lookupWord(word string) string {
 	// Implement the word lookup logic here
 }

  7. Now that the basic structure of our CLI app is ready, let’s implement the word lookup logic using the goquery package:

     import (
 	// ...
 	"github.com/PuerkitoBio/goquery"
 )
    
 // ...
    
 func lookupWord(word string) string {
 	resp, err := goquery.NewDocument("https://www.dictionary.com/browse/" + word)
 	if err != nil {
 		return fmt.Sprintf("Failed to look up word: %s", err)
 	}
    
 	definition := resp.Find(".css-pnw38j")
 	if definition.Length() == 0 {
 		return "No definition found"
 	}
    
 	return definition.Text()
 }

  8. Save the main.go file and build the CLI dictionary app:

     go build -o dictionary

  9. Test the app by running:

     ./dictionary lookup hello

    You should see the definition of the word “hello” printed to the console.

    Congratulations! You have successfully built a CLI Dictionary App in Go.

Conclusion

In this tutorial, we learned how to build a CLI Dictionary App using Go. We covered the setup process, basic CLI structure using the cobra package, and how to fetch word definitions using the goquery package. You can further enhance this app by adding features like synonyms, antonyms, usage examples, or more extensive error handling.

Feel free to explore more about Go and experiment with different functionalities to improve your CLI app. Happy coding!

Published:

Related Articles