In this lesson, we're going to be adding in another improvement to make our project feel more like a real application, by adding in command line arguments. Currently, whenever we want to count the words of a new file, we have to open up our main function and change the name of the file that we're loading inside of our file name variable, followed by then rebuilding our application using the go build command or re-running it using go run. This isn't exactly the best interface, and if we ever want to distribute this application to other users, we need to provide a mechanism for them to be able to count words from files without having to recompile the code.

Instead, it would be much better if we could pass in the name of the file that we wanted our program to open and count the number of words inside, such as follows. Where here I'm passing in the name of the words.txt file into the counter binary. This is known as a command line argument, of which there can be many. These arguments are actually stored inside of our application where we're able to access them. In Go, these are stored in the Args variable inside of the os package, which is a []string that holds the command line arguments starting with the program name.

In order to see what this looks like, let's go ahead and print this variable using the Println function of the fmt package. Then if we go ahead and run it using the following go run command, passing in the words.txt file. This looks a little strange due to the fact that we're using the go run command, which builds our code into a temporary executable and then executes it. If I go ahead and build this code first using the go build command, followed by executing the binary using the following syntax, you can see it's a little easier to read, and the first argument is the command that we used to execute this code. ./counter

The second argument is where it starts to get a little interesting. As you can see, the words.txt argument that we passed into the actual command is being represented here. If I go ahead and change this to be something such as foobar, you can see this is also being represented as well. Additionally, we can also pass in multiple arguments such as follows, and each of these will also be contained within the slice.

Therefore, we can use these command line arguments to get access to the actual file that we want to use, in this case words.txt with this current command. To do so, we could replace the following declaration for our file name with the following syntax, taking the second value of the os.Args[2]. However, this in itself may cause a bit of an issue. For example, if I use the go run command without passing an argument, you can see we get a panic. This is due to the fact that we're trying to index the os.Args slice out of range.

Instead, we should actually perform some validations and log to os.Stderr if we don't get the expected number of arguments. In our case, we're expecting there to always be at least one. Therefore, if we add the following if statement, checking the length of the os.Args, and if it's not equal to two, we can call the log.Fatalln function, passing in our error message, letting the user know that there's not enough arguments. Let's give the log message of "must provide a single file name"

Now if I use the go run command again, you can see this time we get an exit status code telling us that we've produced the wrong file. Let's make this a little easier to read by providing the error prefix as follows. Much better.

This will also work if we happen to provide multiple file names as well, such as follows. With that, if we now run our code using the words.txt file, we can see that it's working correctly. This is because we've already made use of the actual os.File method that we passed in before. Now when I go ahead and run this code as follows, we should see it work as expected. Great.

But what about if we want to count words in multiple files? If we go ahead and take a look at the wc tool, which is a tool on Unix systems that stands for word count, which is actually the tool that we were inspired by in this project, we can see how this works. If we go ahead and use the wc command passing in the -w flag, which we'll actually take a look at later on in this course, followed by specifying the words.txt file, we can see it produces the following output. Providing the count of words in the file, but also the file's name.

If I go ahead and quickly create another file called foo.txt and pass in some other words. Now if I call the wc -w command again with both the words.txt and foo.txt, you can see it prints slightly different outputs. This time it's printing the word count found in both files with their file name respectively, as well as printing the total. This to me looks pretty good. So let's go and modify our own counter in order to have a similar behavior.

In order to do so, let's first create a new function called CountWordsInFile, which takes a file name as a string parameter. Then for the return value, let's go ahead and set this to be an integer. Then for the function implementation, let's go ahead and pull out the file loading logic we already have, followed by returning a call to the function of CountWords, passing in our actual file. Then back in our main function, let's go ahead and replace the call to CountWords with a new call to CountWordsInFile, passing in the file name.

Before we move on, let's go ahead and check that everything is working correctly by using the go run command, passing in the words.txt. Great. As we can see, everything is working as expected. With that, we're now ready to make the changes to support multiple files.

First things first, rather than checking that the length of the command line arguments is two, let's go ahead and change this to instead be if the length of arguments is less than two. In this case, if we only provide one argument, then we'll get an error. Then let's go ahead and change the actual error message that we provide. Let's change this from "must provide a single file name" to "must provide at least one file name," or instead "no file name specified." For me, that seems a lot clearer.

Next, rather than pulling out the first file name on the list, let's replace this with a for loop to iterate over each of the arguments inside of the os.Args slice. We can do this by using the familiar for range that we've seen before. Then for the implementation of this loop body, we can take the word count and fmt.Println that we've used before and just paste it in. Next, in order to have parity with the wc function, we want to print out the name of the file that we're actually counting. We can do this pretty easy in our fmt.Println method by providing the actual file name.

With that, our algorithm should be up and running. Let's go ahead and test this with a single file by again using the go run command, passing in the words.txt. However, this time you'll notice that we've actually got two files being processed. The first is the /tmp/gobuild/exec/counter, which is actually the binary that's being built. Again, if I use the go build command, followed by executing the binary as we did before, passing in the words.txt, you can see that the actual counter binary itself is also being counted, which in this case happens to have 58,000 words.

This is because we're iterating over each of the arguments, and if you'll remember, the first argument is always the command that we used. Therefore, we need to add some code in to remove the first value. The first way we could do this is by tracking the index, and if i is equal to zero, calling the continue keyword. Now if I go ahead and run this code again, you'll see that it works. However, the approach that I like to use is to instead use the following syntax os.Args[1:], which creates a sub-slice from index one onwards.

Now if I go ahead and run this code again, you can see it also works as expected. All that remains is to test that this is working with multiple files, which it is. However, one thing that is missing is we're not capturing the total counts from each file. Therefore, in order to do this, let's go ahead and create a new variable called total, which we'll set to be 0. Then inside each iteration of the loop, let's go ahead and increment the total value by the word count we receive, which we can do using the following code.

total += wordCount

Lastly, we then want to print out the total when we have more than one file in place. We could do this by again calling the if len function on the os.Args variable. However, to make this a little easier to read, let's instead create a new variable called filenames, which we'll set to the same syntax we have here, which is pulling out all of the os.Args apart from the first one. Then we can range over these file names instead, and we can then check the length as follows. if len(filenames) > 1, we can then use the fmt.Println function to print out the total value, as well as the text of "total."

Now if we go ahead and run this code as we did before, we should see a pretty similar output as to what's printed out in the wc command. With that, we've managed to add in the ability to select which file we want to count the words from without having to recompile, making use of a CLI argument. In the next lesson, we're going to build on this even further, adding in yet another improvement, however this time in the case that we don't specify a text file.

As always, before moving on, make sure to commit your code. And once you've done so, I'll see you in the next lesson.