Create Command Line Application With Golang

Creating a Command Line Application to Separate Files by Extension in Go

If you have a folder with a large number of files and you want to organize them by file extension, you can create a command line application to do this automatically using Go. Go, also known as Golang, is a programming language developed by Google that is designed to be fast, statically-typed, and easy to learn. In this article, we’ll walk through the steps to create a Go program that separates files in a given folder into subfolders based on their extension.

Install Go

Before you can start writing Go code, you’ll need to install the Go programming language on your machine. Go is available for Windows, macOS, and Linux, and you can download the latest release from the official Go website at https://golang.org/dl/. Once you’ve downloaded the installation package, follow the prompts to install Go on your system.

Set Up Your Go Workspace

Go uses a specific directory structure for organizing code, and it’s important to set this up correctly before you start writing your program. To set up your Go workspace, create a new directory called “go” in your home directory. Inside the “go” directory, create a subdirectory called “src” and another subdirectory called “bin”. Your Go workspace should now look like this:

$HOME/go/
    src/
    bin/

Create a New Go Project

Now that you have Go installed and your workspace set up, you can create a new Go project. To do this, open a terminal window and navigate to the “src” directory inside your Go workspace. From here, create a new directory for your project and navigate into it. For example, if your project is called “separate-files”, you might create a directory like this:

cd $HOME/go/src
mkdir separate-files
cd separate-files

Write the Go Code

With your Go project set up, you can now start writing the code to separate the files by extension. Here’s a basic outline of what your program will do:

Parse the command line arguments to get the name of the folder to process.
Read the list of files in the specified folder.
Iterate over the list of files, creating a subfolder for each unique file extension.
Move each file into the appropriate subfolder based on its extension. To start, create a new file called “main.go” in your project directory and add the following code:

package main

import (
	"fmt"
	"os"
)

func main() {
	// Parse the command line arguments
	args := os.Args[1:]
	if len(args) != 1 {
		fmt.Println("Usage: separate-files <folder>")
		os.Exit(1)
	}
	folder := args[0]
	
	// Read the list of files in the specified folder
	files, err := ioutil.ReadDir(folder)
	if err != nil {
		fmt.Printf("Error reading files in folder %s: %v\n", folder, err)
		os.Exit(1)
	}
	
	// Iterate over the list of files and create a subfolder for each unique extension
		extensions := make(map[string]bool)
	for _, file := range files {
		if file.IsDir() {
			continue
		}
		
		extension := filepath.Ext(file.Name())
		extensions[extension] = true
	}
	
	for extension := range extensions {
		// Create a subfolder for each unique extension
		err := os.Mkdir(filepath.Join(folder, extension), 0700)
		if err != nil {
			fmt.Printf("Error creating subfolder for extension %s: %v\n", extension, err)
			continue
		}
	}
	
	// Move each file into the appropriate subfolder based on its extension
	for _, file := range files {
		if file.IsDir() {
			continue
		}
		
		extension := filepath.Ext(file.Name())
		src := filepath.Join(folder, file.Name())
		dst := filepath.Join(folder, extension, file.Name())
		
		err := os.Rename(src, dst)
		if err != nil {
			fmt.Printf("Error moving file %s to subfolder %s: %v\n", src, extension, err)
			continue
		}
	}
}

This code reads the list of files in the specified folder, creates a subfolder for each unique file extension, and then moves each file into the appropriate subfolder based on its extension.

To use this program, save the file and run it from the command line with the name of the folder you want to process as an argument. For example:

go run main.go /path/to/folder

This will separate the files in the specified folder into subfolders based on their extension.

To package and distribute your Go code, you have a few options:

Compile the code into a standalone executable: You can use the go build command to compile your Go code into a standalone executable that you can distribute to users. For example, to build an executable called “separate-files” from the code above, you can run the following command:

go build -o separate-files main.go

This will create an executable file called “separate-files” in the current directory that you can distribute to users.

Use a package manager: There are several package managers available for Go that you can use to distribute your code, including dep, glide, and godep. These tools allow you to manage the dependencies for your project and build a single package that includes all of the necessary code and libraries.
Use a containerization tool: You can also use a containerization tool like Docker to package your code and its dependencies into a container image that can be easily distributed and run on any machine. This is a good option if you want to ensure that your code runs consistently across different environments.

Once you have packaged your code, you can distribute it to users in a variety of ways, such as uploading it to a package repository, hosting it on a website, or sharing it via email or file sharing services.

Creating a Command Line Application to Separate Files by Extension in Go#

Creating a Command Line Application to Separate Files by Extension in Go