Now that we understand how standard input works and how we can use it to pass data to our application, in this lesson we're going to take a look at some other approaches we can use when it comes to pulling out data from standard inputs. We're going to do this by taking a quick detour from our word counter application, but we'll be coming back to it in the upcoming lessons.

When it comes to working with standard inputs, whilst being able to pass data in through the methods that we've seen already, specifically when it comes to our word counter application, is a very common approach. There are situations when building command line applications that you'll want to obtain information or data from the user, typically in what's known as a prompt.

This is commonly where you would ask the user to provide some more information. And some typical examples of this prompt is say if you run the npm init command, if you happen to use JavaScript, you'll see here it's prompting us for the package name. In this case we're calling it Scanf, and we can go ahead and type this name to the command, and it will then continue prompting us for more information. In this case, we're still using standard inputs, but it's not like we're passing in the data through the pipe command.

So how can we go about adding in prompts for our own CLI applications? Well, in order to show how this works, here I have another example project. This time we're printing out to the console, please enter your name. Basically, we want to prompt the user to type in their name. If I go ahead and run this, currently it doesn't do anything, it just exits. So we need a way to be able to prompt or read from the standard input stream at the time we're trying to enter in some data.

To achieve this, we have a few different approaches we can take. One way is to just copy all of the data from the standard input stream, using something like the ReadAll function of the io package, which can be used to read all of the data from an io.Reader, which the standard input stream is. This command does return an error, but we'll go ahead and ignore this for the moment. And we can go ahead and say Println, hello, and we'll go ahead and cast our data to a string. Now, if we go ahead and run this code, you can see we're able to type in our name. Let's say we're Goku. However, when I press enter, we're still stuck in the standard input stream. So I have to do a control and D to end the file, and it kind of works. However, this is very different to the npm example we just took a look at, which instead moves on after we press the enter key or add in a new line.

One way that we could solve this would be to make use of, say, the bufio.Scanner. So rather than reading from all of the files, we instead use a scanner. We instead define a scanner, which is bufio.NewScanner, and passing in os.Stdin. Then we could just go ahead and read scanner.Scan, let's say. Then we could go ahead and get the name of scanner.Text. And we'll get rid of the IO package. Also, this only returns one, which is a little bit nicer. Now, if we go ahead and run this, you can see please enter your name. We can say Goku. This time it works, as we've managed to scan a single line.

Whilst using the bufio.Scanner works, there is in fact... Whilst using the bufio to scan lines from standard input does work, there is, however, a better approach we can take. This approach is by making use of some of the functions available in the fmt package, specifically those related to scanning.

Scanning, in Go and also in C as well, is used in order to scan data, or read in data, from an io.Reader. You can think of scanning as being the opposite of printing, especially when it comes to a printer and a scanner.

Scanner will read or take in data from an external source, or whereas printer will write it. Again, this is very similar to scanning a piece of paper or printing a piece of paper. Basically, you're printing the information onto the paper, or you're scanning the information off. This is the same as when it comes to the files such as standard out and standard in. In our case, we want to be able to scan data off of the standard input file, and we want to do so whenever we pass in a new line.

As you can see, there are a number of different methods when it comes to scanning in Go. You have Scan, Fscan, and Sscan, which all treat new lines as the, in the input as spaces. So this would just seem as though we're adding a space in between our name, which we actually don't want. Then we have the Scanln, Fscanln, and Sscanln, which stops scanning at a new line and require that all items be followed by a new line or end of file. This is actually more what we want. We want to stop scanning whenever we press enter in our user input.

So if we take a look at this again, we want to enter in our name and press in a new line by pressing return, and then stop scanning. So these are the methods we actually want to use. However, before we move on, let's take a look at the Scanf, Fscanf, and Sscanf description. In this case, we pass in arguments according to a format string, analogous to that of Printf. In the text that follows, space means any Unicode white space character, except for new line. We'll take a look at the difference between all of these different types of methods, as well as what Fscan and Sscan actually mean.

In our case, however, we're just going to go ahead and use the Scanln function, as this will allow us to scan in data into a variable, but stopping it when we reach a new line character. To do so, let's go ahead and get rid of the two lines we had that are reading in from the os data stream. And we then need to go ahead and define a variable that we want to scan our data or scan the input from our user into. For the moment, let's just go ahead and set this to be a string called name, which we're defining using the var keyword. Although again, you could just use the shorthand syntax if you want to. But in this case, we just want an empty variable. So this makes sense. Let's also go ahead and get rid of these two.

Next, we can then go ahead and use the Scanln function of the fmt package, which if you'll notice, takes a variadic parameter of any. In this case, we want to go ahead and scan the data into our name variable, which we can do by using the following syntax of passing it in as a pointer. If you remember from Go101, passing in a variable as a pointer allows it to be modified by the function. Additionally, if we take a look at the return value of the Scanln function, in this case, you can see it returns an integer and an error. Because we're dealing with user inputs, then we should always consider that errors are possible.

So we're going to go ahead and actually handle this in this case. And we'll just do a simple if err and we could do a log.Fatal. log.Fatal("failed to scan data"). And we'll just go ahead and print out the error. If everything passed, we'll print out the following line of hello, and we'll just pass in the name that we passed in. So when we run this code, we should see a prompt appear asking for us to pass in the name or pass in our name. Then if everything is successful and we passed in a valid string of which most of which is going to be the case when it comes to Go, then we'll go ahead and say hello to that name.

So let's go ahead and run this. As you can see, we receive our prompt. Then if we type in the name, let's say Goku, and we enter a new line character, pressing the return key, you can see it then follows up by printing hello, Goku. Pretty cool. With that, we managed to be able to add in a prompt from the standard input stream. And we've done so in a way that it will allow us to press enter. And we collect the data from the stream.

Additionally, we can also use this approach when it comes to piping in data. So if we want to go ahead. So if we wanted to, we could go ahead and pipe in, say, Vegeta to the go run command or to the command that runs our application. And you can see it instantly says, please enter your name. Hello, Vegeta. In addition to being able to scan for strings, we can also scan for other types as well. Let's say after we say hello, we want to go ahead and ask for the player's power level.

We can do this again by first setting a new variable called powerlevel, which in this case we'll go ahead and define to be an integer. Or maybe we should do a uint actually, because we don't expect this to be a negative value. Then again, if I quickly scroll up, we can go ahead and use the Scaln function, passing in our power level. And we'll go ahead and use a format string this time with some verbs. So we'll do hello and use the %s verb in order to interpolate our user's name. And we can go ahead and say, what is your power level? Again, we'll add in a space and we're using the Printf rather than the Println function here so that we keep it all on the same line, as you may have noticed from our first prompt.

Okay, with that, we have no new variables. So we have to capture this as follows. And we could do our if error check again, because we're taking—oh yeah, we need to actually pass in the name here as well. Let's do that. And as I said, we're doing an error check due to the fact that we're taking user input. So user input is something you always want to validate and be sure is correct. Just because if you distribute it, users will try to try to actually break it. And we'll do failed to scan powerlevel, let's say. And again, we'll do error. I'm also going to go ahead and change this to be a fatal line, so it prints on a new line or prints to a line and we'll go field to scan name just so that we can see the difference between the two.

Lastly, we'll go ahead and do a fmt.Println of, let's do actually a fmt.Printlf. And we'll do name's power level is going to be the output of powerlevel. We need to do a %d here. And we can go ahead and do a simple if check. So if powerlevel > 9,000, we'll do our favorite string of it's over 9,000. Let's do a new line character here as well.

Okay, now if we go ahead and run this code again, this time you can see we get the prompt to enter our name. So we can go ahead and say Goku. Hello, Goku, what is your power level? And if we go ahead and enter 9,001, we get Goku's power level 9,001. And we get our prompt saying it's over 9,000. As you can see, this is a really powerful way to collect input from your user at various different stages. And because you're accepting it in a way that when we press enter, it submits the data, it makes it a really nice interface to collect information from your users, compared to say using standard inputs, which can be a little more technical.

In addition to the Scanln function, which I think is the most simplest function to use, we also have the other scan methods as well. So if we go back to this documentation, you can see we have Scan and we have Scanf as well. Scan, in my opinion, is less used for prompting, but it's able to be used with standard input when you pass data in. So if we passed in a space delimited set of data, we could then use the Scan function in order to pull those into variables, rather than having to perform parsing on the actual data itself.

For example, if we go ahead and get rid of all of this, we can go ahead and set two variables here of our nameA string and nameB string, let's say. Then we can use the fmt.Scan method, passing in nameA, nameB. And in this case, we can actually just go ahead and print them both out. So we can go name A, name B, let's say. Now, if we go ahead and run this, you can see we can pass into names. So hello world, let's say. And when I press enter, because I've added in additional inputs, you can see it's, well, it's actually very hard to see. Let's go ahead and print out some prefix to this.

So we can do nameA and we'll do nameA and we'll do the same thing here as well. And if we go ahead and run this, do foo bar, as you can see, printing them into their own unique values, separated by a string. Of course, because it does not treat new line characters as being any different from spaces, if we did foo bar, you can see here, it's again capturing them each inside of their own variable. This is very useful when you want to capture multiple variables that could be separated by strings or slides. So line A or line B, if you're reading from a file or anything else, which you could then pipe in as the standard input to your application.

One thing to consider with both the fmt.Scan and fmt.Scanln functions is that if we want to go ahead and accept an input string that does have spaces in it, for example, let's go ahead and say we're going to go ahead and set a line of string and we can use the fmt.Scan. Let's use fmt.Scanln for this and we can go ahead and pass this in and we'll do a prompt of enter your favorite line, let's say, and we'll do it on a new line here just to make it a little bit easier. Then we can go ahead and say fmt.Println favorite line and we'll go ahead and actually print the line out.

If I go ahead and run this using the go run command, enter your favorite line, we'll do it's over 9000, which is probably my favorite line. You can see that it's not really worked. All we've done is capture the its value, which is the first value before a space and every other value after the first space has been lost. In fact, it's actually then been printed to the next console, which is what happens when you're running on a terminal. This is because both the Scan and Scanln methods will only parse tokens up to an individual space. So they're not well suited if you want to capture input that has spaces in the middle.

In that situation, the best thing to use would be the bufio.Scanner, similar to what we saw before. So in this case, we would use the scanner is equal to bufio.NewScanner. And then we could go ahead and pass in os.Stdin as follows. Then we would just go ahead and scanner.Scan. So we're scanning a line in because by default, the bufio Scanner will scan for lines. Then we could just go ahead and get the line as scanner.Text.

Also, we can get rid of this declaration on the following line. Now, when we go ahead and enter it, it's over 9,000. You can see this time we're capturing the full line. Therefore, if you do need to capture a line of text or multiple words, it's worthwhile using the bufio.Scanner rather than using the scan methods of the fmt package, as those methods are much better suited to capturing tokens without whitespace. And the scanner is going to be better for capturing tokens with whitespace.

The problem with using the bufio.NewScanner is that you can't easily convert it into a type. So if you want to convert values into integers, it's going to be harder to use the bufio.Scanner for. So there is no silver bullet. Instead, you'll want to use whichever approach best suits your needs. In addition to fmt.Scan and fmt.Scanln, there's also fmt.Scanf, which is very similar to the fmt.Printf methods we've actually seen already.

In this case, let's say we were doing name, which is going to be a string. We'll just define it this way and powerlevel, which is going to be an integer. We would instead of using fmt.Scan or fmt.Scanln, in this case, we would use scanf. But we can set some constraints of what we want this value to be or what we want this string to look like. So in this case, we want the input to be name and say we want to go ahead and say the name is after this.

Then there's a space and we could do powerlevel. And again, we'll set this to be afterwards and it's going to be an integer. Then we pass in the name and we pass in the power level as follows. Then we could go ahead and do, say, scanned values and we'll do a print line of name. And again, we'll just take the name value. And then we could do, say, if powerlevel is greater than 9,000, we'll go ahead and format print line. It's over 9,000. And we could actually go ahead and do what does the scanner say about name?

Okay. Now if I go ahead and run this code again, you can see it's prompting for entry, but we have to enter this entry in the same format that we've defined in the format string. So this is name and we could say Goku. Then we add a space and we say powerlevel is going to be 9,000. Oh, let's give him 10,000 this time. I'm going to be generous. Now when I press enter, you can see what does the scanner say about Goku? As you can see, there's a space there, but that's my fault. Let's go ahead and remove that.

What does the scanner say about Goku? It's over 9,000. As you can see, this allows us to be able to scan data, say, if we're already expecting a format string, which can happen in the case of parsing log files or parsing any other data that may come into your application. If we expect it to be in a certain format, we can specify what that format string is and specify where we want to pull data out of it.

As you can see, the scanner function can be really powerful for obtaining user data or from scanning data from an input stream. Again, let's go ahead and do this. So we could do this time name Vegeta. Let's go ahead and do Nappa. And the power level this time we'll say was only 8,000. You can just say, what does the scanner say about Nappa? And we didn't print anything out because the power level wasn't over 9,000. Of course, this will error if we don't pass in the correct string.

So we'll go ahead and do an if error here and we'll do a log.Fatalln just so that we can see what that error looks like. And we'll just go error. Let's say go run. And we can say foo bar. As you can see, input does not match format. And we exited with a status of 1. You'll also notice that it instantly failed as soon as it notices something goes wrong. So for instance, if we go ahead and write go run and we do Nami, I guess, and we could even go ahead and go Goku, etc. If we do that, you can see we're expecting name, but we passed in Nami. And so it failed as soon as it read the Y, then the rest of the input was actually saved until the next line, which is something to be considerate of.

In that case, you would probably continue to read from standard inputs. So you would go ahead and just io.Copy or something similar. You would just read whatever's remaining on the standard input stream before exiting early. In any case, that covers the Scan, Scanln, and Scanf methods, and how we can use them to actually scan data from the standard input stream in order to obtain it and use it within our code. These are very, very powerful tools when it comes to obtaining data, either from prompting it from our user in the case of the Scanln method, or from actually pulling data out of a formatted string, which is great from things such as reading from structured logs or any other form of structured data that we just want to get into our application.

As I mentioned, there are some other methods that we have here, such as the Fscan and the Sscan methods. These are all variants of the scan methods we've seen before, so they work in the same way. However, they have a slight difference. The Fscan method accepts an io.Reader, which means we could go ahead and pass in anything that conforms to this interface, be it a file, a byte array, etc, etc. We've looked at io.Reader interface already, but this just means it makes the application even more versatile. So you're not limited to using it with the standard input stream, you can use it with other streams as well. Very powerful stuff.

Additionally, we also have the Sscan, which if we take a look at the documentation, and we can see it's scan, here we go, Sscan accepts an argument string, storing successive space separated values into successive arguments. So again, very similar to the Fscan, but rather than accepting an io.Reader, this just accepts a string. So in our case, we could actually go ahead and say our data string that we received is name Goku power level 9001, let's say. And in this case, rather than scanning from the io input, we could use Sscanf, and we just pass in the data as the first property.

And now it's not going to prompt for input, but you can see it's already formatting the string for us. So we can use Sscan basically as a shorthand to prevent us from needing to convert this string into an io.Reader, which will be done using the NewReader function or something similar. In any case, that covers the nine scan methods that are available to us when it comes to the fmt package, and how they can be used in order to pull data from files, standard input, or even just strings themselves.

These functions are a really powerful way to be able to parse and pull out data into your application, and so if you need to read data from a structured log, or anything similar, I recommend making use of these when it comes to your own code. When it comes to prompting for user data however, whilst the Scanln method is great for unstructured data or boundless data, there are some better approaches when you want to do some other things, such as selecting from a list of inputs, or if you want to open up a text editor in order to be able to modify an existing piece of content or piece of data.

We'll take a look at those approaches more however in module number six. For the meantime however, that wraps up what we can do when it comes to using these scan functions.