Explore more of Go's `fmt` package methods!

Learn Go: fmt Package

Using `fmt.Println()` and `fmt.Print()`, we have the ability to concatenate strings, i.e. combine different strings into a single string: 

```go
guess := "C"
fmt.Println("Is", guess, "your final answer?")
// Prints: Is C your final answer?
```

With `fmt.Printf()`, we can _interpolate_ strings, or leave placeholders in a string and use values to fill in the placeholders. Let's revisit the same example using `fmt.Printf()`:

```go
guess := "C"
fmt.Printf("Is %v your final answer?", guess)
// Prints: Is C your final answer?
```

The first argument we provide `fmt.Printf()` is the string: `"Is %v your final answer?"`. The `%v` portion is our placeholder and is known as a _verb_ in Go. Verbs are identified by the combination of a `%` character followed by a letter. The specific letter informs what fills in the placeholder, in this case, `%v` gets the value of `"C"` from our second argument, `guess`. 

As long as we provide enough arguments, we can even add multiple placeholders:

```go
selection1 := "soup"
selection2 := "salad"
fmt.Printf("Do I want %v or %v?", selection1, selection2)
// Prints: Do I want soup or salad?
```

Notice that the placement of the arguments matters! If we switched the position of `selection1` and `selection2`, it would print: `Do I want salad or soup?`. 

We'll go over more verbs in the next exercise, but let's first practice using `fmt.Printf()` with `%v`. 


The Printf Method

If we need to interpolate a string, without printing it, then we can use `fmt.Sprintf()`. 

Just like `fmt.Printf()`, `fmt.Sprintf()` can also use verbs:

```go
correctAns := "A"
answer := fmt.Sprintf("And the correct answer is… %v!", correctAns)

fmt.Print(answer) // Prints: And the correct answer is… A!
```

`fmt.Sprintf()` works very similarly to `fmt.Printf()`, the major difference is that `fmt.Sprintf()` returns its value instead of printing it out!  



The Sprintf Method

While we've been using `fmt` methods to print things out, remember, it's the formatter package. We have other methods that don't print strings, but format them instead like `fmt.Sprint()` and `fmt.Sprintln()`. 

```go
grade := "100"
compliment := "Great job!"
teacherSays := fmt.Sprint("You scored a ", grade, " on the test! ", compliment)

fmt.Print(teacherSays)
// Prints: You scored a 100 on the test! Great job!
```

Take a closer look at `teacherSays` and how calling `fmt.Sprint()` doesn't print out anything. Rather, it _returned_ a value that we store in `teacherSays`. When a value is returned, it means that a function did some computation and is giving back the computed value. Afterward, we can use the returned value for later usage. We'll elaborate more on returns in our Go functions lesson. For now, we should acknowledge that returning a value and printing it are two different things. In our code above, we've formatted one string by concatenating four separate strings. To see the value of `teacherSays`, we have to use a print statement. 

`fmt.Sprintln()` works like `fmt.Sprint()` but it automatically includes spaces between the arguments for us (just like `fmt.Println()` vs `fmt.Print()`!):

```go
quote = fmt.Sprintln("Look ma,", "no spaces!")
fmt.Print(quote) // Prints Look ma, no spaces!
```

Even though we didn't add a trailing space in `"Look ma,"` or a leading space in `"no spaces!"`, `quote` is concatenated with a space in between: `"Look ma, no spaces!"`. 


Sprint and Sprintln 

`fmt` is one of Go's core packages. We've used it for print information to the terminal using the method `fmt.Println()`. `fmt` has a broader purpose, helping us _format_ data, which is why it's sometimes referred to as the format package (though it's pronounced "fumpt", and no that's not a typo).  

But let's not focus on the odd pronunciation, instead, let's go over what else we can use `fmt` to do! In addition to `Println()`, there's also `Print()` and `Printf()` each with their own variation of how to print data. There's also `Sprint()`, `Sprintln()`, and `Sprintf()` which formats but does not print anything to the terminal. We can even get user input by using `Scan()`. There are many more methods in [Go's `fmt` package](https://golang.org/pkg/fmt/), but in this lesson, we'll focus on the ones we just mentioned. 

In this lesson, we'll cover the intricacies of using these methods, so let's go formatting!


The fmt Package

Wonderful work getting through the `fmt` package's methods! There are many more methods that we didn't include, but you can read through [Go's fmt documentation](https://golang.org/pkg/fmt/) for more in-depth information. Remember, each method is unique in its own way, and it's up to you to decide what you need to do and which method will help you accomplish that need! 

In this lesson we went over:
* How `fmt` is pronounced and its purpose. 
* The difference between `fmt.Println()` and `fmt.Print()`. 
* How to interpolate strings using `fmt.Printf()` and verbs.
* The verbs: `%v`, `%T`, `%d`, and `%f`. 
* `fmt.Sprint()`, `fmt.Sprintln()`, `fmt.Sprintf()` will not print strings, but formats them.
* `fmt.Scan()` allows us to take in user input. 



Review

Another helpful method from the `fmt` package is `.Scan()` which allows us to get user input! Let's see an example of this in action:

```go
fmt.Println("How are you doing?") 

var response string 
fmt.Scan(&response)

fmt.Printf("I'm %v.", response) 
```

We'll go through this line by line:
First, we print `How are you doing?` to the terminal. Then we declare a variable, `response` with the type `string`. `fmt.Scan(&response)` takes the first value before a space and stores it in `response`. In the terminal, we would see:

```bash
How are you doing?
```

If we type in `good` and press enter, we would see:

```
How are you doing?
good
I'm good.
```

However, if we tried to type in `not bad`: 

```
How are you doing?
not bad
I'm not.
```
Only the `not` part is saved, since it was separated from `bad` by a space.  If we were expecting two values, we'd need to declare two variables ahead of time: 

```go
fmt.Println("How are you doing?") 

var response1 string 
var response2 string 
fmt.Scan(&response1)
fmt.Scan(&response2)

fmt.Printf("I'm %v %v", response1, response2) 
```

`fmt.Scan()` expects _addresses_ for arguments, hence the `&` before `response1` and `response2`. We'll cover more about addresses in a later lesson. For now, let's get comfortable with the syntax. 


Getting User Input

`fmt.Println()` allows us to print to the terminal and view the data that we're working with. It has some defaulting styling built-in that makes viewing data easier for us. `fmt.Println()` prints its _arguments_ (data provided within its parentheses `( )`) with an included space in between each argument and adds a line break at the end. Take for example:

```go
fmt.Println("Println", "formats", "really well")
fmt.Println("Right?")
```
Which prints:

```bash
Println formats really well
Right?
```

Notice that our first print statement has 3 arguments and each one has an accompanying space between each argument even though we never outright included one in our code. For our second print statement, the argument is printed on the next line since `Println()` adds a line break for us.

However, there are times we might not want the default formatting. In such cases, using `fmt.Print()` would be more appropriate:

```go
fmt.Print("The answer is", ": ")
fmt.Print("12")
``` 
The above code snippet would print:

```
The answer is: 12
```

Notice that there's no default spacing added when `fmt.Print()` has multiple arguments. Also, since `fmt.Print()` doesn't add a line break after printing, the argument for the second print statement print on the same line as the first print statement's. 

Let's compare this for ourselves. 


The Print Method

In addition to `%v`, Go has a variety of useful verbs (check [their documentation](https://golang.org/pkg/fmt/#hdr-Printing) for a comprehensive list). Let's go over a few in this exercise, starting with `%T`:

```go
specialNum := 42
fmt.Printf("This value's type is %T.", specialNum)
// Prints: This value's type is int.

quote := "To do or not to do"
fmt.Printf("This value's type is %T.", quote)
// Prints: This value's type is string.
```

As seen by the example above, the verb `%T` prints out the type of the second argument.  

Now look at `%d`:

```go
votingAge := 18
fmt.Printf("You must be %d years old to vote.", votingAge)
// Prints: You must be 18 years old to vote. 
```

Using `%d` we can interpolate a number into a string! If we need to include a float:

```go
gpa := 3.8
fmt.Printf("You're averaging: %f.", gpa)
// Prints: You're averaging 3.800000.
```

With `%f`, we can limit how precise we are by including a value between the `%` and `f` like: `%.2f`. If we include this in our code:

```go
gpa := 3.8
fmt.Printf("You're averaging: %.2f.", gpa)
// Prints: You're averaging 3.80.
```


Let's explore these new verbs in our own code. 
